chat-console 0.1.1__py3-none-any.whl

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"

app/api/__init__.py

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

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"},
+        ]

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}")

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"}
+            ]

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"}
+        ]

app/config.py

@@ -0,0 +1,127 @@
+import os
+from dotenv import load_dotenv
+from pathlib import Path
+import json
+
+# Load environment variables
+load_dotenv()
+
+# Base paths
+APP_DIR = Path.home() / ".terminalchat"
+APP_DIR.mkdir(exist_ok=True)
+DB_PATH = APP_DIR / "chat_history.db"
+CONFIG_PATH = APP_DIR / "config.json"
+
+# API Keys
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY", "")
+ANTHROPIC_API_KEY = os.getenv("ANTHROPIC_API_KEY", "")
+OLLAMA_BASE_URL = os.getenv("OLLAMA_BASE_URL", "http://localhost:11434")
+
+# Default configuration
+DEFAULT_CONFIG = {
+    "default_model": "gpt-3.5-turbo",
+    "available_models": {
+        "gpt-3.5-turbo": {
+            "provider": "openai",
+            "max_tokens": 4096,
+            "display_name": "GPT-3.5 Turbo"
+        },
+        "gpt-4": {
+            "provider": "openai",
+            "max_tokens": 8192,
+            "display_name": "GPT-4"
+        },
+        "claude-3-opus": {
+            "provider": "anthropic",
+            "max_tokens": 4096,
+            "display_name": "Claude 3 Opus"
+        },
+        "claude-3-sonnet": {
+            "provider": "anthropic",
+            "max_tokens": 4096,
+            "display_name": "Claude 3 Sonnet"
+        },
+        "claude-3-haiku": {
+            "provider": "anthropic",
+            "max_tokens": 4096,
+            "display_name": "Claude 3 Haiku"
+        },
+        "claude-3.7-sonnet": {
+            "provider": "anthropic",
+            "max_tokens": 4096,
+            "display_name": "Claude 3.7 Sonnet"
+        },
+        "llama2": {
+            "provider": "ollama",
+            "max_tokens": 4096,
+            "display_name": "Llama 2"
+        },
+        "mistral": {
+            "provider": "ollama",
+            "max_tokens": 4096,
+            "display_name": "Mistral"
+        },
+        "codellama": {
+            "provider": "ollama",
+            "max_tokens": 4096,
+            "display_name": "Code Llama"
+        },
+        "gemma": {
+            "provider": "ollama",
+            "max_tokens": 4096,
+            "display_name": "Gemma"
+        }
+    },
+    "theme": "dark",
+    "user_styles": {
+        "default": {
+            "name": "Default",
+            "description": "Standard assistant responses"
+        },
+        "concise": {
+            "name": "Concise",
+            "description": "Brief and to the point responses"
+        },
+        "detailed": {
+            "name": "Detailed",
+            "description": "Comprehensive and thorough responses"
+        },
+        "technical": {
+            "name": "Technical",
+            "description": "Technical and precise language"
+        },
+        "friendly": {
+            "name": "Friendly",
+            "description": "Warm and conversational tone"
+        }
+    },
+    "default_style": "default",
+    "max_history_items": 100,
+    "highlight_code": True,
+    "auto_save": True
+}
+
+def load_config():
+    """Load the user configuration or create default if not exists"""
+    if not CONFIG_PATH.exists():
+        save_config(DEFAULT_CONFIG)
+        return DEFAULT_CONFIG
+    
+    try:
+        with open(CONFIG_PATH, 'r') as f:
+            config = json.load(f)
+        # Merge with defaults to ensure all keys exist
+        merged_config = DEFAULT_CONFIG.copy()
+        merged_config.update(config)
+        return merged_config
+    except Exception as e:
+        print(f"Error loading config: {e}. Using defaults.")
+        return DEFAULT_CONFIG
+
+def save_config(config):
+    """Save the configuration to disk"""
+    with open(CONFIG_PATH, 'w') as f:
+        json.dump(config, f, indent=2)
+
+# Current configuration
+CONFIG = load_config()