chat-console 0.1.1__tar.gz

chat_console-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

chat_console-0.1.1/PKG-INFO

@@ -0,0 +1,111 @@
+Metadata-Version: 2.2
+Name: chat-console
+Version: 0.1.1
+Summary: A command-line interface for chatting with LLMs, storing chats and (future) rag interactions
+Home-page: https://github.com/wazacraftrfid/chat-console
+Author: Johnathan Greenaway
+Author-email: john@fimbriata.dev
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: textual>=0.11.1
+Requires-Dist: typer>=0.7.0
+Requires-Dist: requests>=2.28.1
+Requires-Dist: anthropic>=0.5.0
+Requires-Dist: openai>=0.27.0
+Requires-Dist: python-dotenv>=0.21.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Chat CLI
+
+A comprehensive command-line interface for chatting with various AI language models. This application allows you to interact with different LLM providers through an intuitive terminal-based interface.
+
+## Features
+
+- Interactive terminal UI with Textual library
+- Support for multiple AI models:
+  - OpenAI models (GPT-3.5, GPT-4)
+  - Anthropic models (Claude 3 Opus, Sonnet, Haiku)
+- Conversation history with search functionality
+- Customizable response styles (concise, detailed, technical, friendly)
+- Code syntax highlighting
+- Markdown rendering
+
+## Installation
+
+1. Clone this repository:
+   ```
+   git clone https://github.com/yourusername/chat-cli.git
+   cd chat-cli
+   ```
+
+2. Install the required dependencies:
+   ```
+   pip install -r requirements.txt
+   ```
+
+3. Set up your API keys:
+   
+   Create a `.env` file in the project root directory with your API keys:
+   ```
+   OPENAI_API_KEY=your_openai_api_key_here
+   ANTHROPIC_API_KEY=your_anthropic_api_key_here
+   ```
+
+## Usage
+
+Run the application:
+```
+chat-cli
+```
+
+### Keyboard Shortcuts
+
+- `q` - Quit the application
+- `n` - Start a new conversation
+- `s` - Toggle sidebar
+- `f` - Focus search box
+- `Escape` - Cancel current generation
+- `Ctrl+C` - Quit the application
+
+### Configuration
+
+The application creates a configuration file at `~/.chatcli/config.json` on first run. You can edit this file to:
+
+- Change the default model
+- Modify available models
+- Add or edit response styles
+- Change the theme
+- Adjust other settings
+
+## Data Storage
+
+Conversation history is stored in a SQLite database at `~/.chatcli/chat_history.db`.
+
+## Development
+
+The application is structured as follows:
+
+- `main.py` - Main application entry point
+- `app/` - Application modules
+  - `api/` - LLM provider API client implementations
+  - `ui/` - User interface components
+  - `config.py` - Configuration management
+  - `database.py` - Database operations
+  - `models.py` - Data models
+  - `utils.py` - Utility functions
+
+## License
+
+MIT

chat_console-0.1.1/README.md

@@ -0,0 +1,82 @@
+# Chat CLI
+
+A comprehensive command-line interface for chatting with various AI language models. This application allows you to interact with different LLM providers through an intuitive terminal-based interface.
+
+## Features
+
+- Interactive terminal UI with Textual library
+- Support for multiple AI models:
+  - OpenAI models (GPT-3.5, GPT-4)
+  - Anthropic models (Claude 3 Opus, Sonnet, Haiku)
+- Conversation history with search functionality
+- Customizable response styles (concise, detailed, technical, friendly)
+- Code syntax highlighting
+- Markdown rendering
+
+## Installation
+
+1. Clone this repository:
+   ```
+   git clone https://github.com/yourusername/chat-cli.git
+   cd chat-cli
+   ```
+
+2. Install the required dependencies:
+   ```
+   pip install -r requirements.txt
+   ```
+
+3. Set up your API keys:
+   
+   Create a `.env` file in the project root directory with your API keys:
+   ```
+   OPENAI_API_KEY=your_openai_api_key_here
+   ANTHROPIC_API_KEY=your_anthropic_api_key_here
+   ```
+
+## Usage
+
+Run the application:
+```
+chat-cli
+```
+
+### Keyboard Shortcuts
+
+- `q` - Quit the application
+- `n` - Start a new conversation
+- `s` - Toggle sidebar
+- `f` - Focus search box
+- `Escape` - Cancel current generation
+- `Ctrl+C` - Quit the application
+
+### Configuration
+
+The application creates a configuration file at `~/.chatcli/config.json` on first run. You can edit this file to:
+
+- Change the default model
+- Modify available models
+- Add or edit response styles
+- Change the theme
+- Adjust other settings
+
+## Data Storage
+
+Conversation history is stored in a SQLite database at `~/.chatcli/chat_history.db`.
+
+## Development
+
+The application is structured as follows:
+
+- `main.py` - Main application entry point
+- `app/` - Application modules
+  - `api/` - LLM provider API client implementations
+  - `ui/` - User interface components
+  - `config.py` - Configuration management
+  - `database.py` - Database operations
+  - `models.py` - Data models
+  - `utils.py` - Utility functions
+
+## License
+
+MIT

chat_console-0.1.1/app/__init__.py

@@ -0,0 +1,6 @@
+"""
+Chat CLI
+A command-line interface for chatting with various LLM providers like ChatGPT and Claude.
+"""
+
+__version__ = "1.0.0"

chat_console-0.1.1/app/api/__init__.py

@@ -0,0 +1 @@
+"""API client implementations for different LLM providers."""

chat_console-0.1.1/app/api/anthropic.py

@@ -0,0 +1,92 @@
+import anthropic
+from typing import List, Dict, Any, Optional, Generator, AsyncGenerator
+from .base import BaseModelClient
+from ..config import ANTHROPIC_API_KEY
+
+class AnthropicClient(BaseModelClient):
+    def __init__(self):
+        self.client = anthropic.Anthropic(api_key=ANTHROPIC_API_KEY)
+    
+    def _prepare_messages(self, messages: List[Dict[str, str]], style: Optional[str] = None) -> List[Dict[str, str]]:
+        """Prepare messages for Claude API"""
+        # Anthropic expects role to be 'user' or 'assistant'
+        processed_messages = []
+        
+        for msg in messages:
+            role = msg["role"]
+            if role == "system":
+                # For Claude, we'll convert system messages to user messages with a special prefix
+                processed_messages.append({
+                    "role": "user",
+                    "content": f"<system>\n{msg['content']}\n</system>"
+                })
+            else:
+                processed_messages.append(msg)
+        
+        # Add style instructions if provided
+        if style and style != "default":
+            # Find first non-system message to attach style to
+            for i, msg in enumerate(processed_messages):
+                if msg["role"] == "user":
+                    content = msg["content"]
+                    if "<userStyle>" not in content:
+                        style_instructions = self._get_style_instructions(style)
+                        msg["content"] = f"<userStyle>{style_instructions}</userStyle>\n\n{content}"
+                    break
+        
+        return processed_messages
+    
+    def _get_style_instructions(self, style: str) -> str:
+        """Get formatting instructions for different styles"""
+        styles = {
+            "concise": "Be extremely concise and to the point. Use short sentences and paragraphs. Avoid unnecessary details.",
+            "detailed": "Be comprehensive and thorough in your responses. Provide detailed explanations, examples, and cover all relevant aspects of the topic.",
+            "technical": "Use precise technical language and terminology. Be formal and focus on accuracy and technical details.",
+            "friendly": "Be warm, approachable and conversational. Use casual language, personal examples, and a friendly tone.",
+        }
+        
+        return styles.get(style, "")
+    
+    def generate_completion(self, messages: List[Dict[str, str]], 
+                           model: str, 
+                           style: Optional[str] = None, 
+                           temperature: float = 0.7, 
+                           max_tokens: Optional[int] = None) -> str:
+        """Generate a text completion using Claude"""
+        processed_messages = self._prepare_messages(messages, style)
+        
+        response = self.client.messages.create(
+            model=model,
+            messages=processed_messages,
+            temperature=temperature,
+            max_tokens=max_tokens or 1024,
+        )
+        
+        return response.content[0].text
+    
+    async def generate_stream(self, messages: List[Dict[str, str]], 
+                            model: str, 
+                            style: Optional[str] = None,
+                            temperature: float = 0.7, 
+                            max_tokens: Optional[int] = None) -> AsyncGenerator[str, None]:
+        """Generate a streaming text completion using Claude"""
+        processed_messages = self._prepare_messages(messages, style)
+        
+        stream = self.client.messages.stream(
+            model=model,
+            messages=processed_messages,
+            temperature=temperature,
+            max_tokens=max_tokens or 1024,
+        )
+        async for chunk in stream:
+            if chunk.type == "content_block":
+                yield chunk.text
+    
+    def get_available_models(self) -> List[Dict[str, Any]]:
+        """Get list of available Claude models"""
+        return [
+            {"id": "claude-3-opus", "name": "Claude 3 Opus"},
+            {"id": "claude-3-sonnet", "name": "Claude 3 Sonnet"},
+            {"id": "claude-3-haiku", "name": "Claude 3 Haiku"},
+            {"id": "claude-3.7-sonnet", "name": "Claude 3.7 Sonnet"},
+        ]

chat_console-0.1.1/app/api/base.py

@@ -0,0 +1,74 @@
+from abc import ABC, abstractmethod
+from typing import List, Dict, Any, Optional, Generator, AsyncGenerator
+
+class BaseModelClient(ABC):
+    """Base class for AI model clients"""
+    
+    @abstractmethod
+    async def generate_completion(self, messages: List[Dict[str, str]], 
+                                model: str, 
+                                style: Optional[str] = None, 
+                                temperature: float = 0.7, 
+                                max_tokens: Optional[int] = None) -> str:
+        """Generate a text completion"""
+        pass
+    
+    @abstractmethod
+    @abstractmethod
+    async def generate_stream(self, messages: List[Dict[str, str]], 
+                            model: str, 
+                            style: Optional[str] = None,
+                            temperature: float = 0.7, 
+                            max_tokens: Optional[int] = None) -> AsyncGenerator[str, None]:
+        """Generate a streaming text completion"""
+        yield ""  # Placeholder implementation
+    
+    @abstractmethod
+    def get_available_models(self) -> List[Dict[str, Any]]:
+        """Get list of available models from this provider"""
+        pass
+    
+    @staticmethod
+    def get_client_for_model(model_name: str) -> 'BaseModelClient':
+        """Factory method to get appropriate client for model"""
+        from ..config import CONFIG
+        from .anthropic import AnthropicClient
+        from .openai import OpenAIClient
+        
+        # For known models, use their configured provider
+        model_info = CONFIG["available_models"].get(model_name)
+        if model_info:
+            provider = model_info["provider"]
+        else:
+            # For custom models, infer provider from name prefix
+            model_name_lower = model_name.lower()
+            if any(name in model_name_lower for name in ["gpt", "text-", "davinci"]):
+                provider = "openai"
+            elif any(name in model_name_lower for name in ["claude", "anthropic"]):
+                provider = "anthropic"
+            elif any(name in model_name_lower for name in ["llama", "mistral", "codellama", "gemma"]):
+                provider = "ollama"
+            else:
+                # Try to get from Ollama API first
+                from .ollama import OllamaClient
+                try:
+                    client = OllamaClient()
+                    models = client.get_available_models()
+                    if any(model["id"] == model_name for model in models):
+                        provider = "ollama"
+                    else:
+                        # Default to OpenAI if not found
+                        provider = "openai"
+                except:
+                    # Default to OpenAI if Ollama not available
+                    provider = "openai"
+        
+        if provider == "anthropic":
+            return AnthropicClient()
+        elif provider == "openai":
+            return OpenAIClient()
+        elif provider == "ollama":
+            from .ollama import OllamaClient
+            return OllamaClient()
+        else:
+            raise ValueError(f"Unknown provider: {provider}")

chat_console-0.1.1/app/api/ollama.py

@@ -0,0 +1,116 @@
+import aiohttp
+import json
+from typing import List, Dict, Any, Optional, Generator, AsyncGenerator
+from .base import BaseModelClient
+from ..config import CONFIG
+
+class OllamaClient(BaseModelClient):
+    def __init__(self):
+        self.base_url = "http://localhost:11434"
+        
+    def _prepare_messages(self, messages: List[Dict[str, str]], style: Optional[str] = None) -> str:
+        """Convert chat messages to Ollama format"""
+        # Convert messages to a single string with role prefixes
+        formatted_messages = []
+        
+        for msg in messages:
+            role = msg["role"]
+            content = msg["content"]
+            
+            if role == "system":
+                formatted_messages.append(f"System: {content}")
+            elif role == "user":
+                formatted_messages.append(f"Human: {content}")
+            elif role == "assistant":
+                formatted_messages.append(f"Assistant: {content}")
+                
+        # Add style instructions if provided
+        if style and style != "default":
+            style_instructions = self._get_style_instructions(style)
+            formatted_messages.insert(0, f"System: {style_instructions}")
+            
+        return "\n\n".join(formatted_messages)
+    
+    def _get_style_instructions(self, style: str) -> str:
+        """Get formatting instructions for different styles"""
+        styles = {
+            "concise": "Be extremely concise and to the point. Use short sentences and avoid unnecessary details.",
+            "detailed": "Be comprehensive and thorough. Provide detailed explanations and examples.",
+            "technical": "Use precise technical language and terminology. Focus on accuracy and technical details.",
+            "friendly": "Be warm and conversational. Use casual language and a friendly tone.",
+        }
+        
+        return styles.get(style, "")
+    
+    async def generate_completion(self, messages: List[Dict[str, str]], 
+                                model: str, 
+                                style: Optional[str] = None, 
+                                temperature: float = 0.7, 
+                                max_tokens: Optional[int] = None) -> str:
+        """Generate a text completion using Ollama"""
+        prompt = self._prepare_messages(messages, style)
+        
+        async with aiohttp.ClientSession() as session:
+            async with session.post(
+                f"{self.base_url}/api/generate",
+                json={
+                    "model": model,
+                    "prompt": prompt,
+                    "temperature": temperature,
+                    "stream": False
+                }
+            ) as response:
+                response.raise_for_status()
+                data = await response.json()
+                return data["response"]
+    
+    async def generate_stream(self, messages: List[Dict[str, str]], 
+                            model: str, 
+                            style: Optional[str] = None,
+                            temperature: float = 0.7, 
+                            max_tokens: Optional[int] = None) -> AsyncGenerator[str, None]:
+        """Generate a streaming text completion using Ollama"""
+        prompt = self._prepare_messages(messages, style)
+        
+        async with aiohttp.ClientSession() as session:
+            async with session.post(
+                f"{self.base_url}/api/generate",
+                json={
+                    "model": model,
+                    "prompt": prompt,
+                    "temperature": temperature,
+                    "stream": True
+                }
+            ) as response:
+                response.raise_for_status()
+                async for line in response.content:
+                    if line:
+                        chunk = line.decode().strip()
+                        try:
+                            data = json.loads(chunk)
+                            if "response" in data:
+                                yield data["response"]
+                        except json.JSONDecodeError:
+                            continue
+    
+    async def get_available_models(self) -> List[Dict[str, Any]]:
+        """Get list of available Ollama models"""
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.get(f"{self.base_url}/api/tags") as response:
+                    response.raise_for_status()
+                    data = await response.json()
+                    models = data["models"]
+                    
+                    return [
+                        {"id": model["name"], "name": model["name"].title()}
+                        for model in models
+                    ]
+        except:
+            # Return some default models if Ollama is not running
+            return [
+                {"id": "llama2", "name": "Llama 2"},
+                {"id": "mistral", "name": "Mistral"},
+                {"id": "codellama", "name": "Code Llama"},
+                {"id": "gemma", "name": "Gemma"}
+            ]

chat_console-0.1.1/app/api/openai.py

@@ -0,0 +1,78 @@
+from openai import AsyncOpenAI
+from typing import List, Dict, Any, Optional, Generator, AsyncGenerator
+from .base import BaseModelClient
+from ..config import OPENAI_API_KEY
+
+class OpenAIClient(BaseModelClient):
+    def __init__(self):
+        self.client = AsyncOpenAI(api_key=OPENAI_API_KEY)
+    
+    def _prepare_messages(self, messages: List[Dict[str, str]], style: Optional[str] = None) -> List[Dict[str, str]]:
+        """Prepare messages for OpenAI API"""
+        processed_messages = messages.copy()
+        
+        # Add style instructions if provided
+        if style and style != "default":
+            style_instructions = self._get_style_instructions(style)
+            processed_messages.insert(0, {
+                "role": "system",
+                "content": style_instructions
+            })
+        
+        return processed_messages
+    
+    def _get_style_instructions(self, style: str) -> str:
+        """Get formatting instructions for different styles"""
+        styles = {
+            "concise": "You are a concise assistant. Provide brief, to-the-point responses without unnecessary elaboration.",
+            "detailed": "You are a detailed assistant. Provide comprehensive responses with thorough explanations and examples.",
+            "technical": "You are a technical assistant. Use precise technical language and focus on accuracy and technical details.",
+            "friendly": "You are a friendly assistant. Use a warm, conversational tone and relatable examples.",
+        }
+        
+        return styles.get(style, "")
+    
+    async def generate_completion(self, messages: List[Dict[str, str]], 
+                           model: str, 
+                           style: Optional[str] = None, 
+                           temperature: float = 0.7, 
+                           max_tokens: Optional[int] = None) -> str:
+        """Generate a text completion using OpenAI"""
+        processed_messages = self._prepare_messages(messages, style)
+        
+        response = await self.client.chat.completions.create(
+            model=model,
+            messages=processed_messages,
+            temperature=temperature,
+            max_tokens=max_tokens,
+        )
+        
+        return response.choices[0].message.content
+    
+    async def generate_stream(self, messages: List[Dict[str, str]], 
+                            model: str, 
+                            style: Optional[str] = None,
+                            temperature: float = 0.7, 
+                            max_tokens: Optional[int] = None) -> AsyncGenerator[str, None]:
+        """Generate a streaming text completion using OpenAI"""
+        processed_messages = self._prepare_messages(messages, style)
+        
+        stream = await self.client.chat.completions.create(
+            model=model,
+            messages=processed_messages,
+            temperature=temperature,
+            max_tokens=max_tokens,
+            stream=True,
+        )
+        
+        async for chunk in stream:
+            if chunk.choices and chunk.choices[0].delta.content:
+                yield chunk.choices[0].delta.content
+    
+    def get_available_models(self) -> List[Dict[str, Any]]:
+        """Get list of available OpenAI models"""
+        return [
+            {"id": "gpt-3.5-turbo", "name": "GPT-3.5 Turbo"},
+            {"id": "gpt-4", "name": "GPT-4"},
+            {"id": "gpt-4-turbo", "name": "GPT-4 Turbo"}
+        ]