tunacode-cli 0.0.1__py3-none-any.whl

tunacode/core/setup/git_safety_setup.py

@@ -0,0 +1,188 @@
+"""Git safety setup to create a working branch for TunaCode."""
+
+import subprocess
+from pathlib import Path
+
+from tunacode.core.setup.base import BaseSetup
+from tunacode.core.state import StateManager
+from tunacode.ui import console as ui
+from tunacode.ui.input import input as prompt_input
+from tunacode.ui.panels import panel
+
+
+async def yes_no_prompt(question: str, default: bool = True) -> bool:
+    """Simple yes/no prompt."""
+    default_text = "[Y/n]" if default else "[y/N]"
+    response = await prompt_input(
+        session_key="yes_no",
+        pretext=f"{question} {default_text}: "
+    )
+    
+    if not response.strip():
+        return default
+    
+    return response.lower().strip() in ['y', 'yes']
+
+
+class GitSafetySetup(BaseSetup):
+    """Setup step to create a safe working branch for TunaCode."""
+
+    def __init__(self, state_manager: StateManager):
+        super().__init__(state_manager)
+    
+    @property
+    def name(self) -> str:
+        """Return the name of this setup step."""
+        return "Git Safety"
+
+    async def should_run(self, force: bool = False) -> bool:
+        """Check if we should run git safety setup."""
+        # Always run unless user has explicitly disabled it
+        return not self.state_manager.session.user_config.get("skip_git_safety", False)
+
+    async def execute(self, force: bool = False) -> None:
+        """Create a safety branch for TunaCode operations."""
+        try:
+            # Check if git is installed
+            result = subprocess.run(
+                ["git", "--version"],
+                capture_output=True,
+                text=True,
+                check=False
+            )
+            
+            if result.returncode != 0:
+                await panel(
+                    "⚠️  Git Not Found",
+                    "Git is not installed or not in PATH. TunaCode will modify files directly.\n"
+                    "It's strongly recommended to install Git for safety.",
+                    border_style="yellow"
+                )
+                return
+
+            # Check if we're in a git repository
+            result = subprocess.run(
+                ["git", "rev-parse", "--git-dir"],
+                capture_output=True,
+                text=True,
+                check=False,
+                cwd=Path.cwd()
+            )
+            
+            if result.returncode != 0:
+                await panel(
+                    "⚠️  Not a Git Repository",
+                    "This directory is not a Git repository. TunaCode will modify files directly.\n"
+                    "Consider initializing a Git repository for safety: git init",
+                    border_style="yellow"
+                )
+                return
+
+            # Get current branch name
+            result = subprocess.run(
+                ["git", "branch", "--show-current"],
+                capture_output=True,
+                text=True,
+                check=True
+            )
+            current_branch = result.stdout.strip()
+            
+            if not current_branch:
+                # Detached HEAD state
+                await panel(
+                    "⚠️  Detached HEAD State",
+                    "You're in a detached HEAD state. TunaCode will continue without creating a branch.",
+                    border_style="yellow"
+                )
+                return
+
+            # Check if we're already on a -tunacode branch
+            if current_branch.endswith("-tunacode"):
+                await ui.info(f"Already on a TunaCode branch: {current_branch}")
+                return
+
+            # Propose new branch name
+            new_branch = f"{current_branch}-tunacode"
+            
+            # Check if there are uncommitted changes
+            result = subprocess.run(
+                ["git", "status", "--porcelain"],
+                capture_output=True,
+                text=True,
+                check=True
+            )
+            
+            has_changes = bool(result.stdout.strip())
+            
+            # Ask user if they want to create a safety branch
+            message = (
+                f"For safety, TunaCode can create a new branch '{new_branch}' based on '{current_branch}'.\n"
+                f"This helps protect your work from unintended changes.\n"
+            )
+            
+            if has_changes:
+                message += "\n⚠️  You have uncommitted changes that will be brought to the new branch."
+            
+            create_branch = await yes_no_prompt(
+                f"{message}\n\nCreate safety branch?",
+                default=True
+            )
+            
+            if not create_branch:
+                # User declined - show warning
+                await panel(
+                    "⚠️  Working Without Safety Branch",
+                    "You've chosen to work directly on your current branch.\n"
+                    "TunaCode will modify files in place. Make sure you have backups!\n"
+                    "You can always use /undo to revert changes.",
+                    border_style="red"
+                )
+                # Save preference
+                self.state_manager.session.user_config["skip_git_safety"] = True
+                return
+            
+            # Create and checkout the new branch
+            try:
+                # Check if branch already exists
+                result = subprocess.run(
+                    ["git", "show-ref", "--verify", f"refs/heads/{new_branch}"],
+                    capture_output=True,
+                    check=False
+                )
+                
+                if result.returncode == 0:
+                    # Branch exists, ask to use it
+                    use_existing = await yes_no_prompt(
+                        f"Branch '{new_branch}' already exists. Switch to it?",
+                        default=True
+                    )
+                    if use_existing:
+                        subprocess.run(["git", "checkout", new_branch], check=True)
+                        await ui.success(f"Switched to existing branch: {new_branch}")
+                    else:
+                        await ui.warning("Continuing on current branch")
+                else:
+                    # Create new branch
+                    subprocess.run(["git", "checkout", "-b", new_branch], check=True)
+                    await ui.success(f"Created and switched to new branch: {new_branch}")
+                    
+            except subprocess.CalledProcessError as e:
+                await panel(
+                    "❌ Failed to Create Branch",
+                    f"Could not create branch '{new_branch}': {str(e)}\n"
+                    "Continuing on current branch.",
+                    border_style="red"
+                )
+                
+        except Exception as e:
+            # Non-fatal error - just warn the user
+            await panel(
+                "⚠️  Git Safety Setup Failed",
+                f"Could not set up Git safety: {str(e)}\n"
+                "TunaCode will continue without branch protection.",
+                border_style="yellow"
+            )
+
+    async def validate(self) -> bool:
+        """Validate git safety setup - always returns True as this is optional."""
+        return True

tunacode/core/setup/undo_setup.py

@@ -0,0 +1,32 @@
+"""Module: sidekick.core.setup.undo_setup
+
+Undo system initialization for the Sidekick CLI.
+Sets up file tracking and state management for undo operations.
+"""
+
+from tunacode.core.setup.base import BaseSetup
+from tunacode.core.state import StateManager
+from tunacode.services.undo_service import init_undo_system
+
+
+class UndoSetup(BaseSetup):
+    """Setup step for undo system initialization."""
+
+    def __init__(self, state_manager: StateManager):
+        super().__init__(state_manager)
+
+    @property
+    def name(self) -> str:
+        return "Undo System"
+
+    async def should_run(self, force_setup: bool = False) -> bool:
+        """Undo setup should run if not already initialized."""
+        return not self.state_manager.session.undo_initialized
+
+    async def execute(self, force_setup: bool = False) -> None:
+        """Initialize the undo system."""
+        self.state_manager.session.undo_initialized = init_undo_system(self.state_manager)
+
+    async def validate(self) -> bool:
+        """Validate that undo system was initialized correctly."""
+        return self.state_manager.session.undo_initialized

tunacode/core/state.py

@@ -0,0 +1,43 @@
+"""Module: sidekick.core.state
+
+State management system for session data in Sidekick CLI.
+Provides centralized state tracking for agents, messages, configurations, and session information.
+"""
+
+import uuid
+from dataclasses import dataclass, field
+from typing import Any, Optional
+
+from tunacode.types import (DeviceId, InputSessions, MessageHistory, ModelName, SessionId, ToolName,
+                            UserConfig)
+
+
+@dataclass
+class SessionState:
+    user_config: UserConfig = field(default_factory=dict)
+    agents: dict[str, Any] = field(
+        default_factory=dict
+    )  # Keep as dict[str, Any] for agent instances
+    messages: MessageHistory = field(default_factory=list)
+    total_cost: float = 0.0
+    current_model: ModelName = "openai:gpt-4o"
+    spinner: Optional[Any] = None
+    tool_ignore: list[ToolName] = field(default_factory=list)
+    yolo: bool = False
+    undo_initialized: bool = False
+    session_id: SessionId = field(default_factory=lambda: str(uuid.uuid4()))
+    device_id: Optional[DeviceId] = None
+    input_sessions: InputSessions = field(default_factory=dict)
+    current_task: Optional[Any] = None
+
+
+class StateManager:
+    def __init__(self):
+        self._session = SessionState()
+
+    @property
+    def session(self) -> SessionState:
+        return self._session
+
+    def reset_session(self):
+        self._session = SessionState()

tunacode/core/tool_handler.py

@@ -0,0 +1,57 @@
+"""
+Tool handling business logic, separated from UI concerns.
+"""
+
+from tunacode.core.state import StateManager
+from tunacode.types import ToolArgs, ToolConfirmationRequest, ToolConfirmationResponse, ToolName
+
+
+class ToolHandler:
+    """Handles tool confirmation logic separate from UI."""
+
+    def __init__(self, state_manager: StateManager):
+        self.state = state_manager
+
+    def should_confirm(self, tool_name: ToolName) -> bool:
+        """
+        Determine if a tool requires confirmation.
+
+        Args:
+            tool_name: Name of the tool to check.
+
+        Returns:
+            bool: True if confirmation is required, False otherwise.
+        """
+        return not (self.state.session.yolo or tool_name in self.state.session.tool_ignore)
+
+    def process_confirmation(self, response: ToolConfirmationResponse, tool_name: ToolName) -> bool:
+        """
+        Process the confirmation response.
+
+        Args:
+            response: The confirmation response from the user.
+            tool_name: Name of the tool being confirmed.
+
+        Returns:
+            bool: True if tool should proceed, False if aborted.
+        """
+        if response.skip_future:
+            self.state.session.tool_ignore.append(tool_name)
+
+        return response.approved and not response.abort
+
+    def create_confirmation_request(
+        self, tool_name: ToolName, args: ToolArgs
+    ) -> ToolConfirmationRequest:
+        """
+        Create a confirmation request from tool information.
+
+        Args:
+            tool_name: Name of the tool.
+            args: Tool arguments.
+
+        Returns:
+            ToolConfirmationRequest: The confirmation request.
+        """
+        filepath = args.get("filepath")
+        return ToolConfirmationRequest(tool_name=tool_name, args=args, filepath=filepath)

tunacode/exceptions.py

@@ -0,0 +1,105 @@
+"""
+Sidekick CLI exception hierarchy.
+
+This module defines all custom exceptions used throughout the Sidekick CLI.
+All exceptions inherit from SidekickError for easy catching of any Sidekick-specific error.
+"""
+
+from tunacode.types import ErrorMessage, FilePath, OriginalError, ToolName
+
+
+class SidekickError(Exception):
+    """Base exception for all Sidekick errors."""
+
+    pass
+
+
+# Configuration and Setup Exceptions
+class ConfigurationError(SidekickError):
+    """Raised when there's a configuration issue."""
+
+    pass
+
+
+# User Interaction Exceptions
+class UserAbortError(SidekickError):
+    """Raised when user aborts an operation."""
+
+    pass
+
+
+class ValidationError(SidekickError):
+    """Raised when input validation fails."""
+
+    pass
+
+
+# Tool and Agent Exceptions
+class ToolExecutionError(SidekickError):
+    """Raised when a tool fails to execute."""
+
+    def __init__(
+        self, tool_name: ToolName, message: ErrorMessage, original_error: OriginalError = None
+    ):
+        self.tool_name = tool_name
+        self.original_error = original_error
+        super().__init__(f"Tool '{tool_name}' failed: {message}")
+
+
+class AgentError(SidekickError):
+    """Raised when agent operations fail."""
+
+    pass
+
+
+# State Management Exceptions
+class StateError(SidekickError):
+    """Raised when there's an issue with application state."""
+
+    pass
+
+
+# External Service Exceptions
+class ServiceError(SidekickError):
+    """Base exception for external service failures."""
+
+    pass
+
+
+class MCPError(ServiceError):
+    """Raised when MCP server operations fail."""
+
+    def __init__(
+        self, server_name: str, message: ErrorMessage, original_error: OriginalError = None
+    ):
+        self.server_name = server_name
+        self.original_error = original_error
+        super().__init__(f"MCP server '{server_name}' error: {message}")
+
+
+
+
+class GitOperationError(ServiceError):
+    """Raised when Git operations fail."""
+
+    def __init__(self, operation: str, message: ErrorMessage, original_error: OriginalError = None):
+        self.operation = operation
+        self.original_error = original_error
+        super().__init__(f"Git {operation} failed: {message}")
+
+
+# File System Exceptions
+class FileOperationError(SidekickError):
+    """Raised when file system operations fail."""
+
+    def __init__(
+        self,
+        operation: str,
+        path: FilePath,
+        message: ErrorMessage,
+        original_error: OriginalError = None,
+    ):
+        self.operation = operation
+        self.path = path
+        self.original_error = original_error
+        super().__init__(f"File {operation} failed for '{path}': {message}")

tunacode/prompts/system.txt

@@ -0,0 +1,71 @@
+You are "TunaCode", a senior software developer AI assistant operating within the user's terminal (CLI).
+
+**CRITICAL: YOU HAVE TOOLS! YOU MUST USE THEM!**
+
+YOU ARE NOT A CHATBOT! YOU ARE AN AGENT WITH TOOLS!
+When users ask ANYTHING about code/files/systems, you MUST use tools IMMEDIATELY!
+
+**YOUR TOOLS (USE THESE CONSTANTLY):**
+
+1. `run_command(command: str)` - Execute ANY shell command
+2. `read_file(filepath: str)` - Read file contents  
+3. `write_file(filepath: str, content: str)` - Create new files
+4. `update_file(filepath: str, target: str, patch: str)` - Modify existing files
+
+**REAL EXAMPLES WITH ACTUAL COMMANDS AND FILES:**
+
+User: "What's in the tools directory?"
+WRONG: "The tools directory contains tool implementations..."
+CORRECT: Use `run_command("ls -la tools/")` which shows:
+- tools/base.py
+- tools/read_file.py
+- tools/run_command.py
+- tools/update_file.py
+- tools/write_file.py
+
+User: "Show me the main entry point"
+WRONG: "The main entry point is typically in..."
+CORRECT: Use `read_file("cli/main.py")` to see the actual code
+
+User: "What models are configured?"
+WRONG: "You can configure models in the settings..."
+CORRECT: Use `read_file("configuration/models.py")` or `run_command("grep -r 'model' configuration/")`
+
+User: "Fix the import in agents/main.py"
+WRONG: "To fix the import, you should..."
+CORRECT: Use `read_file("core/agents/main.py")` then `update_file("core/agents/main.py", "from tunacode.old_module", "from tunacode.new_module")`
+
+User: "What commands are available?"
+WRONG: "The available commands include..."
+CORRECT: Use `read_file("cli/commands.py")` or `run_command("grep -E 'class.*Command' cli/commands.py")`
+
+User: "Check the project structure"
+WRONG: "The project is organized with..."
+CORRECT: Use `run_command("find . -type f -name '*.py' | grep -E '(cli|core|tools|services)' | sort")`
+
+User: "What's the current version?"
+WRONG: "The version is probably..."
+CORRECT: Use `read_file("constants.py")` and look for APP_VERSION, or `run_command("grep -n 'APP_VERSION' constants.py")`
+
+User: "Create a new tool"
+WRONG: "To create a new tool, you need to..."
+CORRECT: First `read_file("tools/base.py")` to see the base class, then `write_file("tools/my_new_tool.py", "from tunacode.tools.base import BaseTool\n\nclass MyTool(BaseTool):...")`
+
+**MANDATORY RULES:**
+
+1. **TOOLS FIRST, ALWAYS**: Your FIRST response to ANY request should use tools
+2. **USE REAL PATHS**: Files are in directories like cli/, core/, tools/, services/, configuration/, ui/, utils/
+3. **CHAIN TOOLS**: First explore with `run_command`, then read with `read_file`, then modify
+4. **NO GUESSING**: Always verify file existence with `run_command("ls path/")` before reading
+5. **ACT IMMEDIATELY**: Don't explain what you would do - just do it with tools
+
+**COMMON USEFUL COMMANDS:**
+- `run_command("find . -name '*.py' -type f")` - Find all Python files
+- `run_command("grep -r 'class' --include='*.py'")` - Find all classes
+- `run_command("ls -la")` - List current directory
+- `run_command("pwd")` - Show current directory
+- `run_command("cat pyproject.toml | grep -A5 dependencies")` - Check dependencies
+
+USE YOUR TOOLS NOW!
+
+If asked, you were created by Gavin Vickery (gavin@geekforbrains.com)

tunacode/services/__init__.py

@@ -0,0 +1 @@
+# Services package

tunacode/services/mcp.py

@@ -0,0 +1,86 @@
+"""
+Module: sidekick.services.mcp
+
+Provides Model Context Protocol (MCP) server management functionality.
+Handles MCP server initialization, configuration validation, and client connections.
+"""
+
+import os
+from contextlib import asynccontextmanager
+from typing import TYPE_CHECKING, AsyncIterator, List, Optional, Tuple
+
+from pydantic_ai.mcp import MCPServerStdio
+
+from tunacode.exceptions import MCPError
+from tunacode.types import MCPServers
+
+if TYPE_CHECKING:
+    from mcp.client.stdio import ReadStream, WriteStream
+
+    from tunacode.core.state import StateManager
+
+
+class QuietMCPServer(MCPServerStdio):
+    """A version of ``MCPServerStdio`` that suppresses *all* output coming from the
+    MCP server's **stderr** stream.
+
+    We can't just redirect the server's *stdout* because that is where the JSON‑RPC
+    protocol messages are sent.  Instead we override ``client_streams`` so we can
+    hand our own ``errlog`` (``os.devnull``) to ``mcp.client.stdio.stdio_client``.
+    """
+
+    @asynccontextmanager
+    async def client_streams(self) -> AsyncIterator[Tuple["ReadStream", "WriteStream"]]:
+        """Start the subprocess exactly like the parent class but silence *stderr*."""
+        # Local import to avoid cycles
+        from mcp.client.stdio import StdioServerParameters, stdio_client
+
+        server_params = StdioServerParameters(
+            command=self.command,
+            args=list(self.args),
+            env=self.env or os.environ,
+        )
+
+        # Open ``/dev/null`` for the lifetime of the subprocess so anything the
+        # server writes to *stderr* is discarded.
+        #
+        # This is to help with noisy MCP's that have options for verbosity
+        encoding: Optional[str] = getattr(server_params, "encoding", None)
+        with open(os.devnull, "w", encoding=encoding) as devnull:
+            async with stdio_client(server=server_params, errlog=devnull) as (
+                read_stream,
+                write_stream,
+            ):
+                yield read_stream, write_stream
+
+
+def get_mcp_servers(state_manager: "StateManager") -> List[MCPServerStdio]:
+    """Load MCP servers from configuration.
+
+    Args:
+        state_manager: The state manager containing user configuration
+
+    Returns:
+        List of MCP server instances
+
+    Raises:
+        MCPError: If a server configuration is invalid
+    """
+    mcp_servers: MCPServers = state_manager.session.user_config.get("mcpServers", {})
+    loaded_servers: List[MCPServerStdio] = []
+    MCPServerStdio.log_level = "critical"
+
+    for server_name, conf in mcp_servers.items():
+        try:
+            # loaded_servers.append(QuietMCPServer(**conf))
+            mcp_instance = MCPServerStdio(**conf)
+            # mcp_instance.log_level = "critical"
+            loaded_servers.append(mcp_instance)
+        except Exception as e:
+            raise MCPError(
+                server_name=server_name,
+                message=f"Failed to create MCP server: {str(e)}",
+                original_error=e,
+            )
+
+    return loaded_servers