tunacode-cli 0.0.11__py3-none-any.whl → 0.0.12__py3-none-any.whl

tunacode/cli/commands.py

@@ -1,4 +1,4 @@
-"""Command system for Sidekick CLI."""
+"""Command system for TunaCode CLI."""
 
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
@@ -248,14 +248,13 @@ class BranchCommand(SimpleCommand):
 
     async def execute(self, args: List[str], context: CommandContext) -> None:
         import subprocess
-
-        from ..services.undo_service import is_in_git_project
+        import os
 
         if not args:
             await ui.error("Usage: /branch <branch-name>")
             return
 
-        if not is_in_git_project():
+        if not os.path.exists(".git"):
             await ui.error("Not a git repository")
             return
 

tunacode/cli/main.py

@@ -1,8 +1,7 @@
 """
-Module: sidekick.cli.main
+Module: tunacode.cli.main
 
-CLI entry point and main command handling for the Sidekick application.
-Manages application startup, version checking, and REPL initialization.
+Enhanced CLI entry point with better styling while staying CLI-based.
 """
 
 import asyncio
@@ -17,7 +16,7 @@ from tunacode.ui import console as ui
 from tunacode.utils.system import check_for_updates
 
 app_settings = ApplicationSettings()
-app = typer.Typer(help=app_settings.name)
+app = typer.Typer(help="🐟 TunaCode - Your AI-powered development assistant")
 state_manager = StateManager()
 
 
@@ -29,6 +28,8 @@ def main(
     model: str = typer.Option(None, "--model", help="Default model to use (e.g., openai/gpt-4)"),
     key: str = typer.Option(None, "--key", help="API key for the provider"),
 ):
+    """🚀 Start TunaCode - Your AI-powered development assistant"""
+    
     if version:
         asyncio.run(ui.version())
         return

tunacode/cli/repl.py

@@ -1,7 +1,7 @@
 """
-Module: sidekick.cli.repl
+Module: tunacode.cli.repl
 
-Interactive REPL (Read-Eval-Print Loop) implementation for Sidekick.
+Interactive REPL (Read-Eval-Print Loop) implementation for TunaCode.
 Handles user input, command processing, and agent interaction in an interactive shell.
 """
 
@@ -207,18 +207,7 @@ async def repl(state_manager: StateManager):
     action = None
 
     # Professional startup information
-    await ui.info("TunaCode v0.1 - Beta Release")
-    await ui.muted("• Caution: This tool can modify your codebase")
     await ui.muted(f"• Model: {state_manager.session.current_model}")
-    await ui.line()
-    
-    # Important safety warning
-    await ui.warning("⚠️  IMPORTANT: The /undo command has been removed for safety reasons")
-    await ui.muted("• Always use git branches before making major changes")
-    await ui.muted("• Use '/branch <name>' to create a new branch for experiments")
-    await ui.muted("• Commit your work frequently to preserve changes")
-    await ui.line()
-    
     await ui.success("Ready to assist with your development")
     await ui.line()
     

tunacode/cli/textual_app.py

@@ -0,0 +1,423 @@
+"""
+Modern Textual-based TUI for TunaCode.
+
+Provides a rich, interactive terminal user interface with:
+- Split-pane layout with chat history and input
+- Sidebar with model info and commands
+- Modern dialog boxes for tool confirmations
+- Real-time status updates
+"""
+
+import asyncio
+from typing import Optional
+
+from rich.markdown import Markdown
+from textual import on, work
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.containers import Container, Horizontal, Vertical, VerticalScroll
+from textual.message import Message
+from textual.reactive import reactive
+from textual.widgets import (
+    Button, Footer, Header, Input, Label, Markdown as MarkdownWidget, 
+    Static, TextArea, TabbedContent, TabPane
+)
+
+from tunacode.configuration.settings import ApplicationSettings
+from tunacode.core.state import StateManager
+from tunacode.setup import setup
+from tunacode.utils.system import check_for_updates
+
+
+class ChatMessage(Static):
+    """A single chat message widget."""
+    
+    def __init__(self, sender: str, content: str, message_type: str = "user"):
+        super().__init__()
+        self.sender = sender
+        self.content = content
+        self.message_type = message_type
+        
+    def compose(self) -> ComposeResult:
+        """Compose the chat message."""
+        if self.message_type == "user":
+            yield Static(f"[bold cyan]❯ You[/bold cyan]\n{self.content}", classes="user-message")
+        elif self.message_type == "agent":
+            yield Static(f"[bold green]🤖 TunaCode[/bold green]\n{self.content}", classes="agent-message")
+        elif self.message_type == "system":
+            yield Static(f"[bold yellow]⚠️ System[/bold yellow]\n{self.content}", classes="system-message")
+        elif self.message_type == "tool":
+            yield Static(f"[bold magenta]🔧 Tool[/bold magenta]\n{self.content}", classes="tool-message")
+
+
+class Sidebar(Container):
+    """Sidebar with model info and commands."""
+    
+    def __init__(self, state_manager: StateManager):
+        super().__init__()
+        self.state_manager = state_manager
+    
+    def compose(self) -> ComposeResult:
+        """Compose the sidebar."""
+        yield Static("[bold]TunaCode[/bold]", classes="sidebar-title")
+        yield Static(f"Model: {self.state_manager.session.current_model}", id="current-model")
+        yield Static("", classes="spacer")
+        
+        yield Static("[bold]Commands[/bold]", classes="section-title")
+        yield Static("/help - Show help", classes="command-item")
+        yield Static("/clear - Clear chat", classes="command-item")
+        yield Static("/model - Switch model", classes="command-item")
+        yield Static("/yolo - Toggle confirmations", classes="command-item")
+        yield Static("", classes="spacer")
+        
+        yield Static("[bold]Status[/bold]", classes="section-title")
+        yield Static("● Ready", id="status", classes="status-ready")
+
+
+class ChatHistory(VerticalScroll):
+    """Scrollable chat history container."""
+    
+    def add_message(self, sender: str, content: str, message_type: str = "user") -> None:
+        """Add a new message to the chat history."""
+        message = ChatMessage(sender, content, message_type)
+        self.mount(message)
+        self.scroll_end(animate=True)
+
+
+class InputArea(Container):
+    """Input area with text area and send button."""
+    
+    class SendMessage(Message):
+        """Message sent when user submits input."""
+        
+        def __init__(self, content: str) -> None:
+            self.content = content
+            super().__init__()
+    
+    def compose(self) -> ComposeResult:
+        """Compose the input area."""
+        with Horizontal():
+            yield TextArea(id="message-input")
+            yield Button("Send", id="send-button", variant="primary")
+    
+    @on(Button.Pressed, "#send-button")
+    def send_message(self) -> None:
+        """Send the current message."""
+        text_area = self.query_one("#message-input", TextArea)
+        content = text_area.text.strip()
+        if content:
+            self.post_message(self.SendMessage(content))
+            text_area.clear()
+    
+    def on_key(self, event) -> None:
+        """Handle key events."""
+        if event.key == "ctrl+enter":
+            self.send_message()
+
+
+class TunaCodeApp(App):
+    """Main TunaCode Textual application."""
+    
+    CSS = """
+    Sidebar {
+        width: 30;
+        background: $surface;
+        border: thick $primary;
+        padding: 1;
+    }
+    
+    .sidebar-title {
+        text-align: center;
+        color: $primary;
+        margin-bottom: 1;
+    }
+    
+    .section-title {
+        color: $accent;
+        margin: 1 0;
+    }
+    
+    .command-item {
+        color: $text-muted;
+        margin-left: 1;
+    }
+    
+    .status-ready {
+        color: $success;
+    }
+    
+    .status-busy {
+        color: $warning;
+    }
+    
+    .status-error {
+        color: $error;
+    }
+    
+    ChatHistory {
+        border: thick $primary;
+        padding: 1;
+        height: 1fr;
+    }
+    
+    .user-message {
+        background: $surface;
+        border-left: thick $primary;
+        padding: 1;
+        margin: 1 0;
+    }
+    
+    .agent-message {
+        background: $surface;
+        border-left: thick $success;
+        padding: 1;
+        margin: 1 0;
+    }
+    
+    .system-message {
+        background: $surface;
+        border-left: thick $warning;
+        padding: 1;
+        margin: 1 0;
+    }
+    
+    .tool-message {
+        background: $surface;
+        border-left: thick $accent;
+        padding: 1;
+        margin: 1 0;
+    }
+    
+    InputArea {
+        height: 5;
+        padding: 1;
+    }
+    
+    #message-input {
+        height: 3;
+    }
+    
+    #send-button {
+        width: 10;
+        margin-left: 1;
+    }
+    """
+    
+    BINDINGS = [
+        Binding("ctrl+c", "quit", "Quit"),
+        Binding("ctrl+l", "clear_chat", "Clear"),
+        Binding("f1", "help", "Help"),
+        Binding("f2", "model_info", "Model"),
+    ]
+    
+    def __init__(self, state_manager: StateManager):
+        super().__init__()
+        self.state_manager = state_manager
+        self.chat_history: Optional[ChatHistory] = None
+        self.sidebar: Optional[Sidebar] = None
+        self.input_area: Optional[InputArea] = None
+    
+    def compose(self) -> ComposeResult:
+        """Compose the main application layout."""
+        yield Header()
+        
+        with Horizontal():
+            self.sidebar = Sidebar(self.state_manager)
+            yield self.sidebar
+            
+            with Vertical():
+                self.chat_history = ChatHistory()
+                yield self.chat_history
+                
+                self.input_area = InputArea()
+                yield self.input_area
+        
+        yield Footer()
+    
+    def on_mount(self) -> None:
+        """Called when the app is mounted."""
+        # Add welcome messages
+        self.chat_history.add_message(
+            "System", 
+            "Welcome to TunaCode v0.11 - Your AI-powered development assistant", 
+            "system"
+        )
+        self.chat_history.add_message(
+            "System",
+            f"Current model: {self.state_manager.session.current_model}",
+            "system"
+        )
+        self.chat_history.add_message(
+            "System",
+            "⚠️ IMPORTANT: Always use git branches before making major changes\nType '/help' for available commands",
+            "system"
+        )
+    
+    @on(InputArea.SendMessage)
+    async def handle_message(self, message: InputArea.SendMessage) -> None:
+        """Handle incoming messages from the input area."""
+        content = message.content
+        
+        # Add user message to chat
+        self.chat_history.add_message("You", content, "user")
+        
+        # Update status
+        status_widget = self.sidebar.query_one("#status", Static)
+        status_widget.update("● Processing...")
+        status_widget.classes = "status-busy"
+        
+        if content.startswith("/"):
+            await self.handle_command(content)
+        else:
+            await self.handle_user_input(content)
+        
+        # Reset status
+        status_widget.update("● Ready")
+        status_widget.classes = "status-ready"
+    
+    async def handle_command(self, command: str) -> None:
+        """Handle slash commands."""
+        if command == "/help":
+            help_text = """Available Commands:
+            
+/help - Show this help message
+/clear - Clear chat history
+/model - Show current model info
+/yolo - Toggle confirmation prompts
+/quit - Exit the application
+
+Keyboard Shortcuts:
+Ctrl+C - Quit
+Ctrl+L - Clear chat
+F1 - Help
+F2 - Model info
+Ctrl+Enter - Send message"""
+            self.chat_history.add_message("System", help_text, "system")
+            
+        elif command == "/clear":
+            await self.action_clear_chat()
+            
+        elif command == "/model":
+            model_info = f"Current model: {self.state_manager.session.current_model}"
+            self.chat_history.add_message("System", model_info, "system")
+            
+        elif command == "/yolo":
+            # Toggle yolo mode
+            current_state = getattr(self.state_manager.session, 'yolo_mode', False)
+            self.state_manager.session.yolo_mode = not current_state
+            new_state = "enabled" if not current_state else "disabled"
+            self.chat_history.add_message("System", f"Confirmation prompts {new_state}", "system")
+            
+        elif command == "/quit":
+            await self.action_quit()
+            
+        else:
+            self.chat_history.add_message("System", f"Unknown command: {command}", "system")
+    
+    async def handle_user_input(self, text: str) -> None:
+        """Handle regular user input."""
+        try:
+            # Use the bridge to process the input
+            if not hasattr(self, '_bridge'):
+                from tunacode.cli.textual_bridge import TextualAgentBridge
+                self._bridge = TextualAgentBridge(self.state_manager, self._bridge_message_callback)
+            
+            # Process the request
+            response = await self._bridge.process_user_input(text)
+            
+            # Add the agent's response to chat
+            self.chat_history.add_message("TunaCode", response, "agent")
+            
+        except Exception as e:
+            self.chat_history.add_message("System", f"Error: {str(e)}", "system")
+    
+    async def _bridge_message_callback(self, message_type: str, content: str) -> None:
+        """Callback for bridge to send messages to the UI."""
+        self.chat_history.add_message("System", content, message_type)
+    
+    def action_clear_chat(self) -> None:
+        """Clear the chat history."""
+        self.chat_history.remove_children()
+        self.chat_history.add_message("System", "Chat cleared", "system")
+    
+    def action_help(self) -> None:
+        """Show help information."""
+        self.handle_command("/help")
+    
+    def action_model_info(self) -> None:
+        """Show model information."""
+        self.handle_command("/model")
+
+
+async def run_textual_app(state_manager: StateManager) -> None:
+    """Run the Textual application."""
+    app = TunaCodeApp(state_manager)
+    await app.run_async()
+
+
+def main():
+    """Main entry point for the Textual app."""
+    import sys
+    
+    # Handle command line arguments
+    version_flag = "--version" in sys.argv or "-v" in sys.argv
+    if version_flag:
+        from tunacode.constants import APP_VERSION
+        print(f"TunaCode v{APP_VERSION}")
+        return
+    
+    # Initialize state manager
+    state_manager = StateManager()
+    app_settings = ApplicationSettings()
+    
+    # Show banner
+    print("🐟 TunaCode - Modern AI Development Assistant")
+    print("=" * 50)
+    
+    # Check for updates
+    has_update, latest_version = check_for_updates()
+    if has_update:
+        print(f"📦 Update available: v{latest_version}")
+        print("Run: pip install --upgrade tunacode-cli")
+        print()
+    
+    # Parse CLI arguments for configuration
+    cli_config = {}
+    args = sys.argv[1:]
+    i = 0
+    while i < len(args):
+        if args[i] == "--model" and i + 1 < len(args):
+            cli_config["model"] = args[i + 1]
+            i += 2
+        elif args[i] == "--key" and i + 1 < len(args):
+            cli_config["key"] = args[i + 1]
+            i += 2
+        elif args[i] == "--baseurl" and i + 1 < len(args):
+            cli_config["baseurl"] = args[i + 1]
+            i += 2
+        elif args[i] == "--setup":
+            cli_config["setup"] = True
+            i += 1
+        else:
+            i += 1
+    
+    async def run_app():
+        try:
+            # Run setup
+            run_setup = cli_config.get("setup", False)
+            await setup(run_setup, state_manager, cli_config)
+            
+            # Run the Textual app
+            await run_textual_app(state_manager)
+            
+        except KeyboardInterrupt:
+            print("\n👋 Goodbye!")
+        except Exception as e:
+            print(f"❌ Error: {e}")
+    
+    # Run the async app
+    asyncio.run(run_app())
+
+
+if __name__ == "__main__":
+    main()

tunacode/cli/textual_bridge.py

@@ -0,0 +1,158 @@
+"""
+Bridge module to integrate existing TunaCode agent logic with Textual UI.
+
+This module adapts the existing REPL and agent processing logic to work
+with the new Textual-based interface while maintaining compatibility.
+"""
+
+import asyncio
+from typing import Callable, Optional
+from asyncio.exceptions import CancelledError
+
+from pydantic_ai.exceptions import UnexpectedModelBehavior
+
+from tunacode.core.agents import main as agent
+from tunacode.core.agents.main import patch_tool_messages
+from tunacode.core.tool_handler import ToolHandler
+from tunacode.exceptions import AgentError, UserAbortError, ValidationError
+from tunacode.types import StateManager
+from tunacode.cli.commands import CommandRegistry
+from tunacode.cli.repl import _parse_args
+from tunacode.ui.tool_ui import ToolUI
+
+
+class TextualAgentBridge:
+    """Bridge between Textual UI and existing agent logic."""
+    
+    def __init__(self, state_manager: StateManager, message_callback: Callable):
+        self.state_manager = state_manager
+        self.message_callback = message_callback
+        self.tool_ui = ToolUI()
+        self.command_registry = CommandRegistry()
+        self.command_registry.register_all_default_commands()
+        
+    async def process_user_input(self, text: str) -> str:
+        """Process user input and return the agent's response."""
+        if text.startswith("/"):
+            return await self._handle_command(text)
+        else:
+            return await self._process_agent_request(text)
+    
+    async def _handle_command(self, command: str) -> str:
+        """Handle slash commands."""
+        try:
+            from tunacode.types import CommandContext
+            
+            # Create command context
+            context = CommandContext(
+                state_manager=self.state_manager, 
+                process_request=self._process_agent_request
+            )
+            
+            # Set the process_request callback for commands that need it
+            self.command_registry.set_process_request_callback(self._process_agent_request)
+            
+            # Execute the command
+            result = await self.command_registry.execute(command, context)
+            
+            if result == "restart":
+                return "Application restart requested."
+            elif result:
+                return str(result)
+            else:
+                return f"Command '{command}' executed successfully."
+                
+        except ValidationError as e:
+            return f"Error: {str(e)}"
+        except Exception as e:
+            return f"Command error: {str(e)}"
+    
+    async def _process_agent_request(self, text: str) -> str:
+        """Process input using the agent."""
+        try:
+            # Expand @file references before sending to the agent
+            try:
+                from tunacode.utils.text_utils import expand_file_refs
+                text = expand_file_refs(text)
+            except ValueError as e:
+                return f"Error: {str(e)}"
+            
+            # Notify UI about processing start
+            await self.message_callback("tool", "Processing request...")
+            
+            # Create a tool callback that integrates with Textual
+            def tool_callback_with_state(part, node):
+                return self._tool_handler(part, node)
+            
+            # Get or create agent instance
+            instance = agent.get_or_create_agent(
+                self.state_manager.session.current_model, 
+                self.state_manager
+            )
+            
+            # Process the request
+            async with instance.run_mcp_servers():
+                res = await agent.process_request(
+                    self.state_manager.session.current_model,
+                    text,
+                    self.state_manager,
+                    tool_callback=tool_callback_with_state,
+                )
+                
+                if res and res.result:
+                    return res.result.output
+                else:
+                    return "Request processed (no output)."
+                    
+        except CancelledError:
+            return "Request cancelled."
+        except UserAbortError:
+            return "Operation aborted."
+        except UnexpectedModelBehavior as e:
+            error_message = str(e)
+            patch_tool_messages(error_message, self.state_manager)
+            return f"Model error: {error_message}"
+        except Exception as e:
+            # Wrap unexpected exceptions in AgentError for better tracking
+            agent_error = AgentError(f"Agent processing failed: {str(e)}")
+            agent_error.__cause__ = e
+            return f"Error: {str(e)}"
+    
+    async def _tool_handler(self, part, node):
+        """Handle tool execution with Textual UI integration."""
+        await self.message_callback("tool", f"Tool: {part.tool_name}")
+        
+        try:
+            # Create tool handler with state
+            tool_handler = ToolHandler(self.state_manager)
+            args = _parse_args(part.args)
+            
+            # Check if confirmation is needed
+            if tool_handler.should_confirm(part.tool_name):
+                # Create confirmation request
+                request = tool_handler.create_confirmation_request(part.tool_name, args)
+                
+                # For now, show a simple confirmation in the UI
+                # In a full implementation, this would show a proper modal dialog
+                await self.message_callback("system", f"Tool confirmation: {part.tool_name} with args: {args}")
+                
+                # For demo purposes, auto-approve (in production, this should be interactive)
+                if not tool_handler.process_confirmation(True, part.tool_name):
+                    raise UserAbortError("User aborted tool execution.")
+            
+        except UserAbortError:
+            patch_tool_messages("Operation aborted by user.", self.state_manager)
+            raise
+
+
+class TextualToolConfirmation:
+    """Handle tool confirmations in Textual UI."""
+    
+    def __init__(self, app_instance):
+        self.app = app_instance
+        
+    async def show_confirmation(self, tool_name: str, args: dict) -> bool:
+        """Show tool confirmation dialog and return user's choice."""
+        # This would show a modal dialog in the Textual app
+        # For now, return True (auto-approve)
+        return True

tunacode/configuration/defaults.py

@@ -1,9 +1,8 @@
 """
-Module: sidekick.configuration.defaults
+Module: tunacode.configuration.defaults
 
-Default configuration values for the Sidekick CLI.
-Provides baseline settings for user configuration including API keys,
-tool settings, and MCP servers.
+Default configuration values for the TunaCode CLI.
+Provides sensible defaults for user configuration and environment variables.
 """
 
 from tunacode.constants import GUIDE_FILE_NAME, TOOL_READ_FILE

tunacode/configuration/models.py

@@ -1,8 +1,8 @@
 """
-Module: sidekick.configuration.models
+Module: tunacode.configuration.models
 
-Configuration model definitions and model registry for AI models.
-Manages available AI models, their configurations, and pricing information.
+Configuration data models and model registry for TunaCode CLI.
+Defines available AI models and their configurations.
 """
 
 from tunacode.types import ModelConfig, ModelName, ModelPricing