tunacode-cli 0.0.1__py3-none-any.whl

tunacode/tools/run_command.py

@@ -0,0 +1,107 @@
+"""
+Module: sidekick.tools.run_command
+
+Command execution tool for agent operations in the Sidekick application.
+Provides controlled shell command execution with output capture and truncation.
+"""
+
+import subprocess
+
+from tunacode.constants import (CMD_OUTPUT_FORMAT, CMD_OUTPUT_NO_ERRORS, CMD_OUTPUT_NO_OUTPUT,
+                                CMD_OUTPUT_TRUNCATED, COMMAND_OUTPUT_END_SIZE,
+                                COMMAND_OUTPUT_START_INDEX, COMMAND_OUTPUT_THRESHOLD,
+                                ERROR_COMMAND_EXECUTION, MAX_COMMAND_OUTPUT)
+from tunacode.exceptions import ToolExecutionError
+from tunacode.tools.base import BaseTool
+from tunacode.types import ToolResult
+from tunacode.ui import console as default_ui
+
+
+class RunCommandTool(BaseTool):
+    """Tool for running shell commands."""
+
+    @property
+    def tool_name(self) -> str:
+        return "Shell"
+
+    async def _execute(self, command: str) -> ToolResult:
+        """Run a shell command and return the output.
+
+        Args:
+            command: The command to run.
+
+        Returns:
+            ToolResult: The output of the command (stdout and stderr).
+
+        Raises:
+            FileNotFoundError: If command not found
+            Exception: Any command execution errors
+        """
+        process = subprocess.Popen(
+            command,
+            shell=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+        stdout, stderr = process.communicate()
+        output = stdout.strip() or CMD_OUTPUT_NO_OUTPUT
+        error = stderr.strip() or CMD_OUTPUT_NO_ERRORS
+        resp = CMD_OUTPUT_FORMAT.format(output=output, error=error).strip()
+
+        # Truncate if the output is too long to prevent issues
+        if len(resp) > MAX_COMMAND_OUTPUT:
+            # Include both the beginning and end of the output
+            start_part = resp[:COMMAND_OUTPUT_START_INDEX]
+            end_part = (
+                resp[-COMMAND_OUTPUT_END_SIZE:]
+                if len(resp) > COMMAND_OUTPUT_THRESHOLD
+                else resp[COMMAND_OUTPUT_START_INDEX:]
+            )
+            truncated_resp = start_part + CMD_OUTPUT_TRUNCATED + end_part
+            return truncated_resp
+
+        return resp
+
+    async def _handle_error(self, error: Exception, command: str = None) -> ToolResult:
+        """Handle errors with specific messages for common cases.
+
+        Raises:
+            ToolExecutionError: Always raised with structured error information
+        """
+        if isinstance(error, FileNotFoundError):
+            err_msg = ERROR_COMMAND_EXECUTION.format(command=command, error=error)
+        else:
+            # Use parent class handling for other errors
+            await super()._handle_error(error, command)
+            return  # super() will raise, this is unreachable
+
+        if self.ui:
+            await self.ui.error(err_msg)
+
+        raise ToolExecutionError(tool_name=self.tool_name, message=err_msg, original_error=error)
+
+    def _get_error_context(self, command: str = None) -> str:
+        """Get error context for command execution."""
+        if command:
+            return f"running command '{command}'"
+        return super()._get_error_context()
+
+
+# Create the function that maintains the existing interface
+async def run_command(command: str) -> ToolResult:
+    """
+    Run a shell command and return the output. User must confirm risky commands.
+
+    Args:
+        command (str): The command to run.
+
+    Returns:
+        ToolResult: The output of the command (stdout and stderr) or an error message.
+    """
+    tool = RunCommandTool(default_ui)
+    try:
+        return await tool.execute(command)
+    except ToolExecutionError as e:
+        # Return error message for pydantic-ai compatibility
+        return str(e)

tunacode/tools/update_file.py

@@ -0,0 +1,117 @@
+"""
+Module: sidekick.tools.update_file
+
+File update tool for agent operations in the Sidekick application.
+Enables safe text replacement in existing files with target/patch semantics.
+"""
+
+import os
+
+from pydantic_ai.exceptions import ModelRetry
+
+from tunacode.exceptions import ToolExecutionError
+from tunacode.tools.base import FileBasedTool
+from tunacode.types import FileContent, FilePath, ToolResult
+from tunacode.ui import console as default_ui
+
+
+class UpdateFileTool(FileBasedTool):
+    """Tool for updating existing files by replacing text blocks."""
+
+    @property
+    def tool_name(self) -> str:
+        return "Update"
+
+    async def _execute(
+        self, filepath: FilePath, target: FileContent, patch: FileContent
+    ) -> ToolResult:
+        """Update an existing file by replacing a target text block with a patch.
+
+        Args:
+            filepath: The path to the file to update.
+            target: The entire, exact block of text to be replaced.
+            patch: The new block of text to insert.
+
+        Returns:
+            ToolResult: A message indicating success.
+
+        Raises:
+            ModelRetry: If file not found or target not found
+            Exception: Any file operation errors
+        """
+        if not os.path.exists(filepath):
+            raise ModelRetry(
+                f"File '{filepath}' not found. Cannot update. "
+                "Verify the filepath or use `write_file` if it's a new file."
+            )
+
+        with open(filepath, "r", encoding="utf-8") as f:
+            original = f.read()
+
+        if target not in original:
+            # Provide context to help the LLM find the target
+            context_lines = 10
+            lines = original.splitlines()
+            snippet = "\n".join(lines[:context_lines])
+            # Use ModelRetry to guide the LLM
+            raise ModelRetry(
+                f"Target block not found in '{filepath}'. "
+                "Ensure the `target` argument exactly matches the content you want to replace. "
+                f"File starts with:\n---\n{snippet}\n---"
+            )
+
+        new_content = original.replace(target, patch, 1)  # Replace only the first occurrence
+
+        if original == new_content:
+            # This could happen if target and patch are identical
+            raise ModelRetry(
+                f"Update target found, but replacement resulted in no changes to '{filepath}'. "
+                "Was the `target` identical to the `patch`? Please check the file content."
+            )
+
+        with open(filepath, "w", encoding="utf-8") as f:
+            f.write(new_content)
+
+        return f"File '{filepath}' updated successfully."
+
+    def _format_args(
+        self, filepath: FilePath, target: FileContent = None, patch: FileContent = None
+    ) -> str:
+        """Format arguments, truncating target and patch for display."""
+        args = [repr(filepath)]
+
+        if target is not None:
+            if len(target) > 50:
+                args.append(f"target='{target[:47]}...'")
+            else:
+                args.append(f"target={repr(target)}")
+
+        if patch is not None:
+            if len(patch) > 50:
+                args.append(f"patch='{patch[:47]}...'")
+            else:
+                args.append(f"patch={repr(patch)}")
+
+        return ", ".join(args)
+
+
+# Create the function that maintains the existing interface
+async def update_file(filepath: FilePath, target: FileContent, patch: FileContent) -> ToolResult:
+    """
+    Update an existing file by replacing a target text block with a patch.
+    Requires confirmation with diff before applying.
+
+    Args:
+        filepath (FilePath): The path to the file to update.
+        target (FileContent): The entire, exact block of text to be replaced.
+        patch (FileContent): The new block of text to insert.
+
+    Returns:
+        ToolResult: A message indicating the success or failure of the operation.
+    """
+    tool = UpdateFileTool(default_ui)
+    try:
+        return await tool.execute(filepath, target, patch)
+    except ToolExecutionError as e:
+        # Return error message for pydantic-ai compatibility
+        return str(e)

tunacode/tools/write_file.py

@@ -0,0 +1,82 @@
+"""
+Module: sidekick.tools.write_file
+
+File writing tool for agent operations in the Sidekick application.
+Creates new files with automatic directory creation and overwrite protection.
+"""
+
+import os
+
+from pydantic_ai.exceptions import ModelRetry
+
+from tunacode.exceptions import ToolExecutionError
+from tunacode.tools.base import FileBasedTool
+from tunacode.types import FileContent, FilePath, ToolResult
+from tunacode.ui import console as default_ui
+
+
+class WriteFileTool(FileBasedTool):
+    """Tool for writing content to new files."""
+
+    @property
+    def tool_name(self) -> str:
+        return "Write"
+
+    async def _execute(self, filepath: FilePath, content: FileContent) -> ToolResult:
+        """Write content to a new file. Fails if the file already exists.
+
+        Args:
+            filepath: The path to the file to write to.
+            content: The content to write to the file.
+
+        Returns:
+            ToolResult: A message indicating success.
+
+        Raises:
+            ModelRetry: If the file already exists
+            Exception: Any file writing errors
+        """
+        # Prevent overwriting existing files with this tool.
+        if os.path.exists(filepath):
+            # Use ModelRetry to guide the LLM
+            raise ModelRetry(
+                f"File '{filepath}' already exists. "
+                "Use the `update_file` tool to modify it, or choose a different filepath."
+            )
+
+        # Create directories if they don't exist
+        dirpath = os.path.dirname(filepath)
+        if dirpath and not os.path.exists(dirpath):
+            os.makedirs(dirpath, exist_ok=True)
+
+        with open(filepath, "w", encoding="utf-8") as file:
+            file.write(content)
+
+        return f"Successfully wrote to new file: {filepath}"
+
+    def _format_args(self, filepath: FilePath, content: FileContent = None) -> str:
+        """Format arguments, truncating content for display."""
+        if content is not None and len(content) > 50:
+            return f"{repr(filepath)}, content='{content[:47]}...'"
+        return super()._format_args(filepath, content)
+
+
+# Create the function that maintains the existing interface
+async def write_file(filepath: FilePath, content: FileContent) -> ToolResult:
+    """
+    Write content to a new file. Fails if the file already exists.
+    Requires confirmation before writing.
+
+    Args:
+        filepath (FilePath): The path to the file to write to.
+        content (FileContent): The content to write to the file.
+
+    Returns:
+        ToolResult: A message indicating the success or failure of the operation.
+    """
+    tool = WriteFileTool(default_ui)
+    try:
+        return await tool.execute(filepath, content)
+    except ToolExecutionError as e:
+        # Return error message for pydantic-ai compatibility
+        return str(e)

tunacode/types.py

@@ -0,0 +1,259 @@
+"""
+Centralized type definitions for Sidekick CLI.
+
+This module contains all type aliases, protocols, and type definitions
+used throughout the Sidekick codebase.
+"""
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Awaitable, Callable, Dict, List, Optional, Protocol, Tuple, Union
+
+# Try to import pydantic-ai types if available
+try:
+    from pydantic_ai import Agent
+    from pydantic_ai.messages import ModelRequest, ModelResponse, ToolReturnPart
+
+    PydanticAgent = Agent
+    MessagePart = Union[ToolReturnPart, Any]
+except ImportError:
+    # Fallback if pydantic-ai is not available
+    PydanticAgent = Any
+    MessagePart = Any
+    ModelRequest = Any
+    ModelResponse = Any
+
+# =============================================================================
+# Core Types
+# =============================================================================
+
+# Basic type aliases
+UserConfig = Dict[str, Any]
+EnvConfig = Dict[str, str]
+ModelName = str
+ToolName = str
+SessionId = str
+DeviceId = str
+InputSessions = Dict[str, Any]
+
+# =============================================================================
+# Configuration Types
+# =============================================================================
+
+
+@dataclass
+class ModelPricing:
+    """Pricing information for a model."""
+
+    input: float
+    cached_input: float
+    output: float
+
+
+@dataclass
+class ModelConfig:
+    """Configuration for a model including pricing."""
+
+    pricing: ModelPricing
+
+
+ModelRegistry = Dict[str, ModelConfig]
+
+# Path configuration
+ConfigPath = Path
+ConfigFile = Path
+
+# =============================================================================
+# Tool Types
+# =============================================================================
+
+# Tool execution types
+ToolArgs = Dict[str, Any]
+ToolResult = str
+ToolCallback = Callable[[Any, Any], Awaitable[None]]
+ToolCallId = str
+
+
+class ToolFunction(Protocol):
+    """Protocol for tool functions."""
+
+    async def __call__(self, *args, **kwargs) -> str: ...
+
+
+@dataclass
+class ToolConfirmationRequest:
+    """Request for tool execution confirmation."""
+
+    tool_name: str
+    args: Dict[str, Any]
+    filepath: Optional[str] = None
+
+
+@dataclass
+class ToolConfirmationResponse:
+    """Response from tool confirmation dialog."""
+
+    approved: bool
+    skip_future: bool = False
+    abort: bool = False
+
+
+# =============================================================================
+# UI Types
+# =============================================================================
+
+
+class UILogger(Protocol):
+    """Protocol for UI logging operations."""
+
+    async def info(self, message: str) -> None: ...
+    async def error(self, message: str) -> None: ...
+    async def warning(self, message: str) -> None: ...
+    async def debug(self, message: str) -> None: ...
+    async def success(self, message: str) -> None: ...
+
+
+# UI callback types
+UICallback = Callable[[str], Awaitable[None]]
+UIInputCallback = Callable[[str, str], Awaitable[str]]
+
+# =============================================================================
+# Agent Types
+# =============================================================================
+
+# Agent response types
+AgentResponse = Any  # Replace with proper pydantic-ai types when available
+MessageHistory = List[Any]
+AgentRun = Any  # pydantic_ai.RunContext or similar
+
+# Agent configuration
+AgentConfig = Dict[str, Any]
+AgentName = str
+
+# =============================================================================
+# Session and State Types
+# =============================================================================
+
+
+@dataclass
+class SessionState:
+    """Complete session state for the application."""
+
+    user_config: Dict[str, Any]
+    agents: Dict[str, Any]
+    messages: List[Any]
+    total_cost: float
+    current_model: str
+    spinner: Optional[Any]
+    tool_ignore: List[str]
+    yolo: bool
+    undo_initialized: bool
+    session_id: str
+    device_id: Optional[str]
+    input_sessions: Dict[str, Any]
+    current_task: Optional[Any]
+
+
+# Forward reference for StateManager to avoid circular imports
+StateManager = Any  # Will be replaced with actual StateManager type
+
+# =============================================================================
+# Command Types
+# =============================================================================
+
+# Command execution types
+CommandArgs = List[str]
+CommandResult = Optional[Any]
+ProcessRequestCallback = Callable[[str, StateManager, bool], Awaitable[Any]]
+
+
+@dataclass
+class CommandContext:
+    """Context passed to command handlers."""
+
+    state_manager: StateManager
+    process_request: Optional[ProcessRequestCallback] = None
+
+
+# =============================================================================
+# Service Types
+# =============================================================================
+
+# MCP (Model Context Protocol) types
+MCPServerConfig = Dict[str, Any]
+MCPServers = Dict[str, MCPServerConfig]
+
+
+# =============================================================================
+# File Operation Types
+# =============================================================================
+
+# File-related types
+FilePath = Union[str, Path]
+FileContent = str
+FileEncoding = str
+FileDiff = Tuple[str, str]  # (original, modified)
+FileSize = int
+LineNumber = int
+
+# =============================================================================
+# Error Handling Types
+# =============================================================================
+
+# Error context types
+ErrorContext = Dict[str, Any]
+OriginalError = Optional[Exception]
+ErrorMessage = str
+
+# =============================================================================
+# Async Types
+# =============================================================================
+
+# Async function types
+AsyncFunc = Callable[..., Awaitable[Any]]
+AsyncToolFunc = Callable[..., Awaitable[str]]
+AsyncVoidFunc = Callable[..., Awaitable[None]]
+
+# =============================================================================
+# Diff and Update Types
+# =============================================================================
+
+# Types for file updates and diffs
+UpdateOperation = Dict[str, Any]
+DiffLine = str
+DiffHunk = List[DiffLine]
+
+# =============================================================================
+# Validation Types
+# =============================================================================
+
+# Input validation types
+ValidationResult = Union[bool, str]  # True for valid, error message for invalid
+Validator = Callable[[Any], ValidationResult]
+
+# =============================================================================
+# Cost Tracking Types
+# =============================================================================
+
+# Cost calculation types
+TokenCount = int
+CostAmount = float
+
+
+@dataclass
+class TokenUsage:
+    """Token usage for a request."""
+
+    input_tokens: int
+    cached_tokens: int
+    output_tokens: int
+
+
+@dataclass
+class CostBreakdown:
+    """Breakdown of costs for a request."""
+
+    input_cost: float
+    cached_cost: float
+    output_cost: float
+    total_cost: float

tunacode/ui/__init__.py

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

tunacode/ui/completers.py

@@ -0,0 +1,129 @@
+"""Completers for file references and commands."""
+
+import os
+from typing import Iterable, Optional
+
+from prompt_toolkit.completion import CompleteEvent, Completer, Completion, merge_completers
+from prompt_toolkit.document import Document
+
+from ..cli.commands import CommandRegistry
+
+
+class CommandCompleter(Completer):
+    """Completer for slash commands."""
+    
+    def __init__(self, command_registry: Optional[CommandRegistry] = None):
+        self.command_registry = command_registry
+    
+    def get_completions(
+        self, document: Document, complete_event: CompleteEvent
+    ) -> Iterable[Completion]:
+        """Get completions for slash commands."""
+        # Get the text before cursor
+        text = document.text_before_cursor
+        
+        # Check if we're at the start of a line or after whitespace
+        if text and not text.isspace() and text[-1] != '\n':
+            # Only complete commands at the start of input or after a newline
+            last_newline = text.rfind('\n')
+            line_start = text[last_newline + 1:] if last_newline >= 0 else text
+            
+            # Skip if not at the beginning of a line
+            if line_start and not line_start.startswith('/'):
+                return
+        
+        # Get the word before cursor
+        word_before_cursor = document.get_word_before_cursor(WORD=True)
+        
+        # Only complete if word starts with /
+        if not word_before_cursor.startswith('/'):
+            return
+            
+        # Get command names from registry
+        if self.command_registry:
+            command_names = self.command_registry.get_command_names()
+        else:
+            # Fallback list of commands
+            command_names = ['/help', '/clear', '/dump', '/yolo', '/undo', 
+                           '/branch', '/compact', '/model', '/init']
+        
+        # Get the partial command (without /)
+        partial = word_before_cursor[1:].lower()
+        
+        # Yield completions for matching commands
+        for cmd in command_names:
+            if cmd.startswith('/') and cmd[1:].lower().startswith(partial):
+                yield Completion(
+                    text=cmd,
+                    start_position=-len(word_before_cursor),
+                    display=cmd,
+                    display_meta='command'
+                )
+
+
+class FileReferenceCompleter(Completer):
+    """Completer for @file references that provides file path suggestions."""
+
+    def get_completions(
+        self, document: Document, complete_event: CompleteEvent
+    ) -> Iterable[Completion]:
+        """Get completions for @file references."""
+        # Get the word before cursor
+        word_before_cursor = document.get_word_before_cursor(WORD=True)
+        
+        # Check if we're in an @file reference
+        if not word_before_cursor.startswith("@"):
+            return
+            
+        # Get the path part after @
+        path_part = word_before_cursor[1:]  # Remove @
+        
+        # Determine directory and prefix
+        if "/" in path_part:
+            # Path includes directory
+            dir_path = os.path.dirname(path_part)
+            prefix = os.path.basename(path_part)
+        else:
+            # Just filename, search in current directory
+            dir_path = "."
+            prefix = path_part
+            
+        # Get matching files
+        try:
+            if os.path.exists(dir_path) and os.path.isdir(dir_path):
+                for item in sorted(os.listdir(dir_path)):
+                    if item.startswith(prefix):
+                        full_path = os.path.join(dir_path, item) if dir_path != "." else item
+                        
+                        # Skip hidden files unless explicitly requested
+                        if item.startswith(".") and not prefix.startswith("."):
+                            continue
+                            
+                        # Add / for directories
+                        if os.path.isdir(full_path):
+                            display = item + "/"
+                            completion = full_path + "/"
+                        else:
+                            display = item
+                            completion = full_path
+                            
+                        # Calculate how much to replace
+                        start_position = -len(path_part)
+                        
+                        yield Completion(
+                            text=completion,
+                            start_position=start_position,
+                            display=display,
+                            display_meta="dir" if os.path.isdir(full_path) else "file"
+                        )
+        except (OSError, PermissionError):
+            # Silently ignore inaccessible directories
+            pass
+
+
+def create_completer(command_registry: Optional[CommandRegistry] = None) -> Completer:
+    """Create a merged completer for both commands and file references."""
+    return merge_completers([
+        CommandCompleter(command_registry),
+        FileReferenceCompleter(),
+    ])