tzamuncode 0.1.0__py3-none-any.whl

tzamuncode/cli/realtime_chat_methods.py

@@ -0,0 +1,200 @@
+"""
+Additional methods for RealtimeChat class
+These will be added to realtime_chat.py
+"""
+
+import json
+from pathlib import Path
+from rich.syntax import Syntax
+from rich.prompt import Prompt, Confirm
+
+
+def read_file(self, file_path: str):
+    """Read and display a file with syntax highlighting"""
+    try:
+        full_path = self.workspace / file_path
+        
+        if not full_path.exists():
+            console.print(f"\n[bold red]✗[/bold red] File not found: {file_path}\n")
+            return
+        
+        if full_path.is_dir():
+            console.print(f"\n[bold red]✗[/bold red] {file_path} is a directory, not a file\n")
+            return
+        
+        # Read file content
+        content = full_path.read_text()
+        
+        # Detect language for syntax highlighting
+        suffix = full_path.suffix.lstrip('.')
+        lang_map = {
+            'py': 'python', 'js': 'javascript', 'ts': 'typescript',
+            'jsx': 'jsx', 'tsx': 'tsx', 'java': 'java', 'cpp': 'cpp',
+            'c': 'c', 'go': 'go', 'rs': 'rust', 'rb': 'ruby',
+            'php': 'php', 'html': 'html', 'css': 'css', 'json': 'json',
+            'yaml': 'yaml', 'yml': 'yaml', 'xml': 'xml', 'md': 'markdown',
+            'sh': 'bash', 'bash': 'bash', 'sql': 'sql'
+        }
+        language = lang_map.get(suffix, 'text')
+        
+        console.print()
+        console.print(f"[bold cyan]📄 {file_path}[/bold cyan] ({len(content)} chars, {len(content.splitlines())} lines)\n")
+        
+        # Syntax highlighted display
+        syntax = Syntax(content, language, theme="monokai", line_numbers=True)
+        console.print(syntax)
+        console.print()
+        
+        # Add to conversation context
+        self.conversation_history.append({
+            "role": "user",
+            "content": f"I read the file {file_path}:\n```{language}\n{content}\n```"
+        })
+        
+    except Exception as e:
+        console.print(f"\n[bold red]✗ Error reading file:[/bold red] {e}\n")
+
+
+def write_file(self, file_path: str):
+    """Write content to a file interactively"""
+    try:
+        console.print()
+        console.print(f"[bold cyan]Writing to:[/bold cyan] {file_path}")
+        console.print("[dim]Enter content (type 'EOF' on a new line to finish):[/dim]\n")
+        
+        lines = []
+        while True:
+            line = input()
+            if line == 'EOF':
+                break
+            lines.append(line)
+        
+        content = '\n'.join(lines)
+        
+        full_path = self.workspace / file_path
+        
+        # Confirm if file exists
+        if full_path.exists():
+            if not Confirm.ask(f"\n[bold yellow]⚠[/bold yellow] File exists. Overwrite?"):
+                console.print("[dim]Write cancelled[/dim]\n")
+                return
+        
+        # Create parent directories if needed
+        full_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        # Write file
+        full_path.write_text(content)
+        
+        console.print(f"\n[bold green]✓[/bold green] Written {len(content)} chars to {file_path}\n")
+        
+        # Add to conversation context
+        self.conversation_history.append({
+            "role": "user",
+            "content": f"I wrote to file {file_path}:\n```\n{content}\n```"
+        })
+        
+    except KeyboardInterrupt:
+        console.print("\n[dim]Write cancelled[/dim]\n")
+    except Exception as e:
+        console.print(f"\n[bold red]✗ Error writing file:[/bold red] {e}\n")
+
+
+def switch_backend(self):
+    """Switch between vLLM and Ollama backends"""
+    console.print()
+    console.print("[bold cyan]Switch AI Backend[/bold cyan]\n")
+    console.print(f"Current: [bold]{'vLLM' if self.use_vllm else 'Ollama'}[/bold]\n")
+    console.print("  [bold]1[/bold]. ⚡ [cyan]vLLM[/cyan] - Fast inference (Qwen 2.5 7B)")
+    console.print("  [bold]2[/bold]. 🦙 [green]Ollama[/green] - Powerful models (Qwen 2.5 32B)")
+    
+    choice = Prompt.ask("\nSwitch to", choices=["1", "2"], default="2" if self.use_vllm else "1")
+    
+    new_use_vllm = (choice == "1")
+    
+    if new_use_vllm == self.use_vllm:
+        console.print("\n[dim]Already using this backend[/dim]\n")
+        return
+    
+    # Switch backend
+    self.use_vllm = new_use_vllm
+    
+    if self.use_vllm:
+        from ..models.vllm_client import VLLMClient
+        self.model = "qwen2.5-7b-instruct"
+        self.client = VLLMClient(model=self.model)
+        self.backend = "vLLM"
+        console.print("\n[bold green]✓[/bold green] Switched to [cyan]vLLM[/cyan] backend\n")
+    else:
+        from ..models.ollama import OllamaClient
+        self.model = "qwen2.5:32b"
+        self.client = OllamaClient(model=self.model)
+        self.backend = "Ollama"
+        console.print("\n[bold green]✓[/bold green] Switched to [green]Ollama[/green] backend\n")
+
+
+def show_conversation_history(self):
+    """Show conversation history"""
+    console.print()
+    
+    if len(self.conversation_history) <= 1:  # Only system prompt
+        console.print("[dim]No conversation history yet[/dim]\n")
+        return
+    
+    console.print(f"[bold cyan]Conversation History[/bold cyan] ({len(self.conversation_history) - 1} messages)\n")
+    
+    for idx, msg in enumerate(self.conversation_history[1:], 1):  # Skip system prompt
+        role = msg['role']
+        content = msg['content']
+        
+        if role == 'user':
+            console.print(f"[bold green]{idx}. You[/bold green] › {content[:100]}{'...' if len(content) > 100 else ''}")
+        else:
+            console.print(f"[bold blue]{idx}. AI[/bold blue] › {content[:100]}{'...' if len(content) > 100 else ''}")
+    
+    console.print()
+
+
+def save_conversation(self, filename: str):
+    """Save conversation to JSON file"""
+    try:
+        save_path = self.workspace / filename
+        
+        # Prepare data
+        data = {
+            'model': self.model,
+            'backend': self.backend,
+            'workspace': str(self.workspace),
+            'conversation': self.conversation_history
+        }
+        
+        # Save to file
+        with open(save_path, 'w') as f:
+            json.dump(data, f, indent=2)
+        
+        console.print(f"\n[bold green]✓[/bold green] Conversation saved to {filename}\n")
+        
+    except Exception as e:
+        console.print(f"\n[bold red]✗ Error saving:[/bold red] {e}\n")
+
+
+def load_conversation(self, filename: str):
+    """Load conversation from JSON file"""
+    try:
+        load_path = self.workspace / filename
+        
+        if not load_path.exists():
+            console.print(f"\n[bold red]✗[/bold red] File not found: {filename}\n")
+            return
+        
+        # Load data
+        with open(load_path, 'r') as f:
+            data = json.load(f)
+        
+        # Restore conversation
+        self.conversation_history = data['conversation']
+        
+        console.print(f"\n[bold green]✓[/bold green] Loaded conversation from {filename}")
+        console.print(f"[dim]Model: {data.get('model', 'unknown')} | Messages: {len(self.conversation_history)}[/dim]\n")
+        
+    except Exception as e:
+        console.print(f"\n[bold red]✗ Error loading:[/bold red] {e}\n")

tzamuncode/cli/tui_chat.py

@@ -0,0 +1,323 @@
+"""
+TUI Chat Interface for TzamunCode
+Built with Textual for a Claude Code-like experience
+"""
+
+from textual.app import App, ComposeResult
+from textual.containers import Container, Vertical, Horizontal
+from textual.widgets import Header, Footer, Static, Input, RichLog
+from textual.binding import Binding
+from textual import events
+from rich.text import Text
+from rich.panel import Panel
+from rich.table import Table
+from typing import Optional
+
+from ..models.ollama import OllamaClient
+
+
+class CommandMenu(Static):
+    """Popup menu for slash commands"""
+    
+    COMMANDS = {
+        '/help': 'Show available commands',
+        '/models': 'List and switch models',
+        '/settings': 'Show settings',
+        '/clear': 'Clear conversation history',
+        '/exit': 'Exit chat',
+    }
+    
+    def compose(self) -> ComposeResult:
+        table = Table(title="Available Commands", border_style="cyan")
+        table.add_column("Command", style="cyan", no_wrap=True)
+        table.add_column("Description", style="white")
+        
+        for cmd, desc in self.COMMANDS.items():
+            table.add_row(cmd, desc)
+        
+        yield Static(table)
+
+
+class ShortcutsMenu(Static):
+    """Popup menu for keyboard shortcuts"""
+    
+    def compose(self) -> ComposeResult:
+        table = Table(title="Keyboard Shortcuts", border_style="blue")
+        table.add_column("Key", style="cyan", no_wrap=True)
+        table.add_column("Action", style="white")
+        
+        table.add_row("Ctrl+C", "Exit chat")
+        table.add_row("Ctrl+L", "Clear screen")
+        table.add_row("/", "Show commands")
+        table.add_row("?", "Show this help")
+        
+        yield Static(table)
+
+
+class ChatMessage(Static):
+    """A single chat message"""
+    
+    def __init__(self, role: str, content: str, **kwargs):
+        super().__init__(**kwargs)
+        self.role = role
+        self.content = content
+    
+    def render(self) -> Text:
+        if self.role == "user":
+            return Text(f"You › {self.content}", style="bold green")
+        else:
+            return Text(f"TzamunCode › {self.content}", style="bold blue")
+
+
+class TUIChat(App):
+    """TUI Chat Application"""
+    
+    CSS = """
+    Screen {
+        background: $surface;
+    }
+    
+    #header {
+        dock: top;
+        height: 5;
+        background: $primary;
+        color: $text;
+        content-align: center middle;
+    }
+    
+    #messages {
+        height: 1fr;
+        border: solid $primary;
+        background: $surface;
+        overflow-y: scroll;
+    }
+    
+    #input-container {
+        dock: bottom;
+        height: 3;
+        background: $panel;
+    }
+    
+    #input {
+        width: 100%;
+    }
+    
+    .command-menu {
+        layer: overlay;
+        offset: 0 -10;
+        width: 60;
+        height: auto;
+        background: $panel;
+        border: solid $primary;
+    }
+    
+    .shortcuts-menu {
+        layer: overlay;
+        offset: 0 -10;
+        width: 40;
+        height: auto;
+        background: $panel;
+        border: solid $primary;
+    }
+    """
+    
+    BINDINGS = [
+        Binding("ctrl+c", "quit", "Quit"),
+        Binding("ctrl+l", "clear", "Clear"),
+    ]
+    
+    def __init__(self, model: str = "qwen2.5:32b", **kwargs):
+        super().__init__(**kwargs)
+        self.model = model
+        self.client = OllamaClient(model=model)
+        self.conversation_history = []
+        self.command_menu_visible = False
+        self.shortcuts_menu_visible = False
+    
+    def compose(self) -> ComposeResult:
+        """Create child widgets"""
+        # Header with ASCII logo
+        header_text = """╔╦╗╔═╗╔═╗╔╦╗╦ ╦╔╗╔╔═╗╔═╗╔╦╗╔═╗
+ ║ ╔═╝╠═╣║║║║ ║║║║║  ║ ║ ║║╣ 
+ ╩ ╚═╝╩ ╩╩ ╩╚═╝╝╚╝╚═╝╚═╝═╩╝╚═╝
+AI Coding Assistant • Model: """ + self.model
+        
+        yield Static(header_text, id="header")
+        
+        # Message history
+        yield RichLog(id="messages", highlight=True, markup=True)
+        
+        # Input container
+        with Container(id="input-container"):
+            yield Input(placeholder="Type your message... (/ for commands, ? for shortcuts)", id="input")
+    
+    def on_mount(self) -> None:
+        """Called when app starts"""
+        messages = self.query_one("#messages", RichLog)
+        messages.write("[bold green]Welcome to TzamunCode![/bold green]")
+        messages.write("[dim]Type '/' for commands or '?' for shortcuts[/dim]")
+        messages.write("")
+        
+        # Focus input
+        self.query_one("#input", Input).focus()
+    
+    def on_input_changed(self, event: Input.Changed) -> None:
+        """Handle input changes in real-time"""
+        current_value = event.value
+        
+        # Show command menu when user types '/'
+        if current_value.endswith('/') and len(current_value) == 1:
+            self.show_command_menu()
+            # Clear the '/' from input
+            event.input.value = ""
+            return
+        
+        # Show shortcuts menu when user types '?'
+        if current_value.endswith('?') and len(current_value) == 1:
+            self.show_shortcuts_menu()
+            # Clear the '?' from input
+            event.input.value = ""
+            return
+    
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        """Handle input submission"""
+        user_input = event.value.strip()
+        
+        if not user_input:
+            return
+        
+        # Clear input
+        event.input.value = ""
+        
+        if user_input.lower() in ['exit', 'quit', '/exit']:
+            self.exit()
+            return
+        
+        if user_input == '/clear':
+            self.action_clear()
+            return
+        
+        if user_input.startswith('/'):
+            self.handle_slash_command(user_input)
+            return
+        
+        # Regular message - send to AI
+        self.send_message(user_input)
+    
+    def send_message(self, message: str) -> None:
+        """Send message to AI and display response"""
+        messages = self.query_one("#messages", RichLog)
+        
+        # Show user message
+        messages.write(f"[bold green]You[/bold green] › {message}")
+        
+        # Add to conversation history
+        self.conversation_history.append({"role": "user", "content": message})
+        
+        # Show thinking indicator
+        messages.write("[dim]TzamunCode is thinking...[/dim]")
+        
+        try:
+            # Get AI response (streaming)
+            response = ""
+            for chunk in self.client.chat_stream(self.conversation_history):
+                response += chunk
+            
+            # Remove thinking indicator and show response
+            messages.clear()
+            
+            # Re-show conversation
+            for msg in self.conversation_history:
+                if msg["role"] == "user":
+                    messages.write(f"[bold green]You[/bold green] › {msg['content']}")
+                elif msg["role"] == "assistant":
+                    messages.write(f"[bold blue]TzamunCode[/bold blue] › {msg['content']}")
+            
+            # Show new response
+            messages.write(f"[bold blue]TzamunCode[/bold blue] › {response}")
+            messages.write("")
+            
+            # Add to history
+            self.conversation_history.append({"role": "assistant", "content": response})
+            
+        except Exception as e:
+            messages.write(f"[bold red]Error:[/bold red] {e}")
+    
+    def show_command_menu(self) -> None:
+        """Show command menu"""
+        messages = self.query_one("#messages", RichLog)
+        
+        table = Table(title="Available Commands", border_style="cyan")
+        table.add_column("Command", style="cyan", no_wrap=True)
+        table.add_column("Description", style="white")
+        
+        table.add_row("/help", "Show available commands")
+        table.add_row("/models", "List and switch models")
+        table.add_row("/settings", "Show settings")
+        table.add_row("/clear", "Clear conversation history")
+        table.add_row("/exit", "Exit chat")
+        
+        messages.write(table)
+        messages.write("")
+    
+    def show_shortcuts_menu(self) -> None:
+        """Show shortcuts menu"""
+        messages = self.query_one("#messages", RichLog)
+        
+        table = Table(title="Keyboard Shortcuts", border_style="blue")
+        table.add_column("Key", style="cyan", no_wrap=True)
+        table.add_column("Action", style="white")
+        
+        table.add_row("Ctrl+C", "Exit chat")
+        table.add_row("Ctrl+L", "Clear screen")
+        table.add_row("/", "Show commands")
+        table.add_row("?", "Show this help")
+        
+        messages.write(table)
+        messages.write("")
+    
+    def handle_slash_command(self, command: str) -> None:
+        """Handle slash commands"""
+        messages = self.query_one("#messages", RichLog)
+        
+        if command == "/help":
+            self.show_command_menu()
+        elif command == "/models":
+            messages.write("[bold blue]Available Models:[/bold blue]")
+            try:
+                models = self.client.list_models()
+                for idx, model in enumerate(models, 1):
+                    status = "✓ Active" if model == self.model else ""
+                    messages.write(f"  {idx}. {model} {status}")
+            except Exception as e:
+                messages.write(f"[bold red]Error:[/bold red] {e}")
+            messages.write("")
+        elif command == "/settings":
+            messages.write(f"[bold blue]Current Settings:[/bold blue]")
+            messages.write(f"  Model: {self.model}")
+            messages.write(f"  Streaming: Enabled")
+            messages.write("")
+        elif command == "/clear":
+            self.action_clear()
+        else:
+            messages.write(f"[bold red]Unknown command:[/bold red] {command}")
+            messages.write("[dim]Type '/' to see available commands[/dim]")
+            messages.write("")
+    
+    def action_clear(self) -> None:
+        """Clear conversation history"""
+        self.conversation_history = []
+        messages = self.query_one("#messages", RichLog)
+        messages.clear()
+        messages.write("[bold green]Conversation cleared[/bold green]")
+        messages.write("")
+    
+    def action_quit(self) -> None:
+        """Quit the app"""
+        self.exit()
+
+
+def run_tui_chat(model: str = "qwen2.5:32b", system: Optional[str] = None):
+    """Run the TUI chat interface"""
+    app = TUIChat(model=model)
+    app.run()

tzamuncode/config/__init__.py

@@ -0,0 +1 @@
+"""Configuration module"""

tzamuncode/models/__init__.py

@@ -0,0 +1 @@
+"""Models module for AI backends"""

tzamuncode/models/ollama.py

@@ -0,0 +1,124 @@
+"""
+Ollama client for TzamunCode
+"""
+
+import requests
+from typing import List, Dict, Generator, Optional
+import json
+
+class OllamaClient:
+    """Client for interacting with Ollama API"""
+    
+    def __init__(
+        self,
+        base_url: str = "http://localhost:11434",
+        model: str = "qwen2.5:32b",
+        timeout: int = 120
+    ):
+        self.base_url = base_url.rstrip('/')
+        self.model = model
+        self.timeout = timeout
+    
+    def generate(self, prompt: str, system: Optional[str] = None) -> str:
+        """Generate a response from the model"""
+        url = f"{self.base_url}/api/generate"
+        
+        payload = {
+            "model": self.model,
+            "prompt": prompt,
+            "stream": False,
+            "options": {
+                "temperature": 0.7,
+                "num_predict": 4096
+            }
+        }
+        
+        if system:
+            payload["system"] = system
+        
+        try:
+            response = requests.post(url, json=payload, timeout=self.timeout)
+            response.raise_for_status()
+            return response.json()["response"]
+        except requests.exceptions.RequestException as e:
+            raise Exception(f"Failed to generate response: {e}")
+    
+    def chat(self, messages: List[Dict[str, str]]) -> str:
+        """Chat with the model using conversation history"""
+        url = f"{self.base_url}/api/chat"
+        
+        payload = {
+            "model": self.model,
+            "messages": messages,
+            "stream": False,
+            "options": {
+                "temperature": 0.7,
+                "num_predict": 4096
+            }
+        }
+        
+        try:
+            response = requests.post(url, json=payload, timeout=self.timeout)
+            response.raise_for_status()
+            return response.json()["message"]["content"]
+        except requests.exceptions.RequestException as e:
+            raise Exception(f"Failed to chat: {e}")
+    
+    def chat_stream(self, messages: List[Dict[str, str]]) -> Generator[str, None, None]:
+        """Stream chat responses"""
+        url = f"{self.base_url}/api/chat"
+        
+        payload = {
+            "model": self.model,
+            "messages": messages,
+            "stream": True,
+            "options": {
+                "temperature": 0.7,
+                "num_predict": 4096
+            }
+        }
+        
+        try:
+            response = requests.post(url, json=payload, timeout=self.timeout, stream=True)
+            response.raise_for_status()
+            
+            for line in response.iter_lines():
+                if line:
+                    data = json.loads(line)
+                    if "message" in data:
+                        content = data["message"].get("content", "")
+                        if content:
+                            yield content
+                    
+                    if data.get("done", False):
+                        break
+                        
+        except requests.exceptions.RequestException as e:
+            raise Exception(f"Failed to stream chat: {e}")
+    
+    def list_models(self) -> List[str]:
+        """List available models"""
+        url = f"{self.base_url}/api/tags"
+        
+        try:
+            response = requests.get(url, timeout=10)
+            response.raise_for_status()
+            models = response.json().get("models", [])
+            return [model["name"] for model in models]
+        except requests.exceptions.RequestException as e:
+            raise Exception(f"Failed to list models: {e}")
+    
+    def pull_model(self, model_name: str) -> bool:
+        """Pull a model from Ollama library"""
+        url = f"{self.base_url}/api/pull"
+        
+        payload = {
+            "name": model_name
+        }
+        
+        try:
+            response = requests.post(url, json=payload, timeout=600)
+            response.raise_for_status()
+            return True
+        except requests.exceptions.RequestException as e:
+            raise Exception(f"Failed to pull model: {e}")