tunacode-cli 0.0.1__py3-none-any.whl

tunacode/cli/repl.py

@@ -0,0 +1,251 @@
+"""
+Module: sidekick.cli.repl
+
+Interactive REPL (Read-Eval-Print Loop) implementation for Sidekick.
+Handles user input, command processing, and agent interaction in an interactive shell.
+"""
+
+import json
+from asyncio.exceptions import CancelledError
+
+from prompt_toolkit.application import run_in_terminal
+from prompt_toolkit.application.current import get_app
+from pydantic_ai.exceptions import UnexpectedModelBehavior
+
+from tunacode.configuration.settings import ApplicationSettings
+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.ui import console as ui
+from tunacode.ui.tool_ui import ToolUI
+
+from ..types import CommandContext, CommandResult, StateManager, ToolArgs
+from .commands import CommandRegistry
+
+# Tool UI instance
+_tool_ui = ToolUI()
+
+
+def _parse_args(args) -> ToolArgs:
+    """
+    Parse tool arguments from a JSON string or dictionary.
+
+    Args:
+        args (str or dict): A JSON-formatted string or a dictionary containing tool arguments.
+
+    Returns:
+        dict: The parsed arguments.
+
+    Raises:
+        ValueError: If 'args' is not a string or dictionary, or if the string is not valid JSON.
+    """
+    if isinstance(args, str):
+        try:
+            return json.loads(args)
+        except json.JSONDecodeError:
+            raise ValidationError(f"Invalid JSON: {args}")
+    elif isinstance(args, dict):
+        return args
+    else:
+        raise ValidationError(f"Invalid args type: {type(args)}")
+
+
+async def _tool_confirm(tool_call, node, state_manager: StateManager):
+    """Confirm tool execution with separated business logic and UI."""
+    # Create tool handler with state
+    tool_handler = ToolHandler(state_manager)
+    args = _parse_args(tool_call.args)
+
+    # Check if confirmation is needed
+    if not tool_handler.should_confirm(tool_call.tool_name):
+        # Log MCP tools when skipping confirmation
+        app_settings = ApplicationSettings()
+        if tool_call.tool_name not in app_settings.internal_tools:
+            title = _tool_ui._get_tool_title(tool_call.tool_name)
+            await _tool_ui.log_mcp(title, args)
+        return
+
+    # Stop spinner during user interaction
+    state_manager.session.spinner.stop()
+
+    # Create confirmation request
+    request = tool_handler.create_confirmation_request(tool_call.tool_name, args)
+
+    # Show UI and get response
+    response = await _tool_ui.show_confirmation(request, state_manager)
+
+    # Process the response
+    if not tool_handler.process_confirmation(response, tool_call.tool_name):
+        raise UserAbortError("User aborted.")
+
+    await ui.line()  # Add line after user input
+    state_manager.session.spinner.start()
+
+
+async def _tool_handler(part, node, state_manager: StateManager):
+    """Handle tool execution with separated business logic and UI."""
+    await ui.info(f"Tool({part.tool_name})")
+    state_manager.session.spinner.stop()
+
+    try:
+        # Create tool handler with state
+        tool_handler = ToolHandler(state_manager)
+        args = _parse_args(part.args)
+
+        # Use a synchronous function in run_in_terminal to avoid async deadlocks
+        def confirm_func():
+            # Skip confirmation if not needed
+            if not tool_handler.should_confirm(part.tool_name):
+                return False
+
+            # Create confirmation request
+            request = tool_handler.create_confirmation_request(part.tool_name, args)
+
+            # Show sync UI and get response
+            response = _tool_ui.show_sync_confirmation(request)
+
+            # Process the response
+            if not tool_handler.process_confirmation(response, part.tool_name):
+                return True  # Abort
+            return False  # Continue
+
+        # Run the confirmation in the terminal
+        should_abort = await run_in_terminal(confirm_func)
+
+        if should_abort:
+            raise UserAbortError("User aborted.")
+
+    except UserAbortError:
+        patch_tool_messages("Operation aborted by user.", state_manager)
+        raise
+    finally:
+        state_manager.session.spinner.start()
+
+
+# Initialize command registry
+_command_registry = CommandRegistry()
+_command_registry.register_all_default_commands()
+
+
+async def _handle_command(command: str, state_manager: StateManager) -> CommandResult:
+    """
+    Handles a command string using the command registry.
+
+    Args:
+        command: The command string entered by the user.
+        state_manager: The state manager instance.
+
+    Returns:
+        Command result (varies by command).
+    """
+    # Create command context
+    context = CommandContext(state_manager=state_manager, process_request=process_request)
+
+    try:
+        # Set the process_request callback for commands that need it
+        _command_registry.set_process_request_callback(process_request)
+
+        # Execute the command
+        return await _command_registry.execute(command, context)
+    except ValidationError as e:
+        await ui.error(str(e))
+
+
+async def process_request(text: str, state_manager: StateManager, output: bool = True):
+    """Process input using the agent, handling cancellation safely."""
+    state_manager.session.spinner = await ui.spinner(
+        True, state_manager.session.spinner, state_manager
+    )
+    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:
+            await ui.error(str(e))
+            return
+
+        # Create a partial function that includes state_manager
+        def tool_callback_with_state(part, node):
+            return _tool_handler(part, node, state_manager)
+
+        res = await agent.process_request(
+            state_manager.session.current_model,
+            text,
+            state_manager,
+            tool_callback=tool_callback_with_state,
+        )
+        if output:
+            await ui.agent(res.result.output)
+    except CancelledError:
+        await ui.muted("Request cancelled")
+    except UserAbortError:
+        await ui.muted("Operation aborted.")
+    except UnexpectedModelBehavior as e:
+        error_message = str(e)
+        await ui.muted(error_message)
+        patch_tool_messages(error_message, state_manager)
+    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  # Preserve the original exception chain
+        await ui.error(str(e))
+    finally:
+        await ui.spinner(False, state_manager.session.spinner, state_manager)
+        state_manager.session.current_task = None
+
+        # Force refresh of the multiline input prompt to restore placeholder
+        if "multiline" in state_manager.session.input_sessions:
+            await run_in_terminal(
+                lambda: state_manager.session.input_sessions["multiline"].app.invalidate()
+            )
+
+
+async def repl(state_manager: StateManager):
+    action = None
+
+    # Hacky startup message
+    await ui.warning("⚠️  tunaCode v0.1 - BETA SOFTWARE")
+    await ui.muted("→ All changes will be made on a new branch for safety")
+    await ui.muted("→ Use with caution! This tool can modify your codebase")
+    await ui.muted(f"→ Model loaded: {state_manager.session.current_model}")
+    await ui.line()
+    await ui.success("ready to hack...")
+    await ui.line()
+    
+    instance = agent.get_or_create_agent(state_manager.session.current_model, state_manager)
+
+    async with instance.run_mcp_servers():
+        while True:
+            try:
+                line = await ui.multiline_input(state_manager, _command_registry)
+            except (EOFError, KeyboardInterrupt):
+                break
+
+            if not line:
+                continue
+
+            if line.lower() in ["exit", "quit"]:
+                break
+
+            if line.startswith("/"):
+                action = await _handle_command(line, state_manager)
+                if action == "restart":
+                    break
+                continue
+
+            # Check if another task is already running
+            if state_manager.session.current_task and not state_manager.session.current_task.done():
+                await ui.muted("Agent is busy, press Ctrl+C to interrupt.")
+                continue
+
+            state_manager.session.current_task = get_app().create_background_task(
+                process_request(line, state_manager)
+            )
+
+    if action == "restart":
+        await repl(state_manager)
+    else:
+        await ui.info("Thanks for all the fish.")

tunacode/configuration/__init__.py

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

tunacode/configuration/defaults.py

@@ -0,0 +1,26 @@
+"""
+Module: sidekick.configuration.defaults
+
+Default configuration values for the Sidekick CLI.
+Provides baseline settings for user configuration including API keys,
+tool settings, and MCP servers.
+"""
+
+from tunacode.constants import GUIDE_FILE_NAME, TOOL_READ_FILE
+from tunacode.types import UserConfig
+
+DEFAULT_USER_CONFIG: UserConfig = {
+    "default_model": "openrouter:openai/gpt-4.1",
+    "env": {
+        "ANTHROPIC_API_KEY": "",
+        "GEMINI_API_KEY": "",
+        "OPENAI_API_KEY": "",
+        "OPENROUTER_API_KEY": "",
+    },
+    "settings": {
+        "max_retries": 10,
+        "tool_ignore": [TOOL_READ_FILE],
+        "guide_file": GUIDE_FILE_NAME,
+    },
+    "mcpServers": {},
+}

tunacode/configuration/models.py

@@ -0,0 +1,69 @@
+"""
+Module: sidekick.configuration.models
+
+Configuration model definitions and model registry for AI models.
+Manages available AI models, their configurations, and pricing information.
+"""
+
+from tunacode.types import ModelConfig, ModelName, ModelPricing
+from tunacode.types import ModelRegistry as ModelRegistryType
+
+
+class ModelRegistry:
+    def __init__(self):
+        self._models = self._load_default_models()
+
+    def _load_default_models(self) -> ModelRegistryType:
+        return {
+            "anthropic:claude-opus-4-20250514": ModelConfig(
+                pricing=ModelPricing(input=3.00, cached_input=1.50, output=15.00)
+            ),
+            "anthropic:claude-sonnet-4-20250514": ModelConfig(
+                pricing=ModelPricing(input=3.00, cached_input=1.50, output=15.00)
+            ),
+            "anthropic:claude-3-7-sonnet-latest": ModelConfig(
+                pricing=ModelPricing(input=3.00, cached_input=1.50, output=15.00)
+            ),
+            "google-gla:gemini-2.0-flash": ModelConfig(
+                pricing=ModelPricing(input=0.10, cached_input=0.025, output=0.40)
+            ),
+            "google-gla:gemini-2.5-flash-preview-05-20": ModelConfig(
+                pricing=ModelPricing(input=0.15, cached_input=0.025, output=0.60)
+            ),
+            "google-gla:gemini-2.5-pro-preview-05-06": ModelConfig(
+                pricing=ModelPricing(input=1.25, cached_input=0.025, output=10.00)
+            ),
+            "openai:gpt-4.1": ModelConfig(
+                pricing=ModelPricing(input=2.00, cached_input=0.50, output=8.00)
+            ),
+            "openai:gpt-4.1-mini": ModelConfig(
+                pricing=ModelPricing(input=0.40, cached_input=0.10, output=1.60)
+            ),
+            "openai:gpt-4.1-nano": ModelConfig(
+                pricing=ModelPricing(input=0.10, cached_input=0.025, output=0.40)
+            ),
+            "openai:gpt-4o": ModelConfig(
+                pricing=ModelPricing(input=2.50, cached_input=1.25, output=10.00)
+            ),
+            "openai:o3": ModelConfig(
+                pricing=ModelPricing(input=10.00, cached_input=2.50, output=40.00)
+            ),
+            "openai:o3-mini": ModelConfig(
+                pricing=ModelPricing(input=1.10, cached_input=0.55, output=4.40)
+            ),
+            "openrouter:mistralai/devstral-small": ModelConfig(
+                pricing=ModelPricing(input=0.0, cached_input=0.0, output=0.0)
+            ),
+            "openrouter:openai/gpt-4.1": ModelConfig(
+                pricing=ModelPricing(input=2.00, cached_input=0.50, output=8.00)
+            ),
+        }
+
+    def get_model(self, name: ModelName) -> ModelConfig:
+        return self._models.get(name)
+
+    def list_models(self) -> ModelRegistryType:
+        return self._models.copy()
+
+    def list_model_ids(self) -> list[ModelName]:
+        return list(self._models.keys())

tunacode/configuration/settings.py

@@ -0,0 +1,32 @@
+"""
+Module: sidekick.configuration.settings
+
+Application settings management for the Sidekick CLI.
+Manages application paths, tool configurations, and runtime settings.
+"""
+
+from pathlib import Path
+
+from tunacode.constants import (APP_NAME, APP_VERSION, CONFIG_FILE_NAME, TOOL_READ_FILE,
+                                TOOL_RUN_COMMAND, TOOL_UPDATE_FILE, TOOL_WRITE_FILE)
+from tunacode.types import ConfigFile, ConfigPath, ToolName
+
+
+class PathConfig:
+    def __init__(self):
+        self.config_dir: ConfigPath = Path.home() / ".config"
+        self.config_file: ConfigFile = self.config_dir / CONFIG_FILE_NAME
+
+
+class ApplicationSettings:
+    def __init__(self):
+        self.version = APP_VERSION
+        self.name = APP_NAME
+        self.guide_file = f"{self.name.upper()}.md"
+        self.paths = PathConfig()
+        self.internal_tools: list[ToolName] = [
+            TOOL_READ_FILE,
+            TOOL_RUN_COMMAND,
+            TOOL_UPDATE_FILE,
+            TOOL_WRITE_FILE,
+        ]

tunacode/constants.py

@@ -0,0 +1,129 @@
+"""
+Module: tunacode.constants
+
+Global constants and configuration values for the TunaCode CLI application.
+Centralizes all magic strings, UI text, error messages, and application constants.
+"""
+
+# Application info
+APP_NAME = "TunaCode"
+APP_VERSION = "0.5.1"
+
+# File patterns
+GUIDE_FILE_PATTERN = "{name}.md"
+GUIDE_FILE_NAME = "TUNACODE.md"
+ENV_FILE = ".env"
+CONFIG_FILE_NAME = "tunacode.json"
+
+# Default limits
+MAX_FILE_SIZE = 100 * 1024  # 100KB
+MAX_COMMAND_OUTPUT = 5000  # 5000 chars
+
+# Command output processing
+COMMAND_OUTPUT_THRESHOLD = 3500  # Length threshold for truncation
+COMMAND_OUTPUT_START_INDEX = 2500  # Where to start showing content
+COMMAND_OUTPUT_END_SIZE = 1000  # How much to show from the end
+
+# Tool names
+TOOL_READ_FILE = "read_file"
+TOOL_WRITE_FILE = "write_file"
+TOOL_UPDATE_FILE = "update_file"
+TOOL_RUN_COMMAND = "run_command"
+
+# Commands
+CMD_HELP = "/help"
+CMD_CLEAR = "/clear"
+CMD_DUMP = "/dump"
+CMD_YOLO = "/yolo"
+CMD_UNDO = "/undo"
+CMD_COMPACT = "/compact"
+CMD_MODEL = "/model"
+CMD_EXIT = "exit"
+CMD_QUIT = "quit"
+
+# Command descriptions
+DESC_HELP = "Show this help message"
+DESC_CLEAR = "Clear the conversation history"
+DESC_DUMP = "Show the current conversation history"
+DESC_YOLO = "Toggle confirmation prompts on/off"
+DESC_UNDO = "Undo the last file change"
+DESC_COMPACT = "Summarize the conversation context"
+DESC_MODEL = "List available models"
+DESC_MODEL_SWITCH = "Switch to a specific model"
+DESC_MODEL_DEFAULT = "Set a model as the default"
+DESC_EXIT = "Exit the application"
+
+# Command Configuration
+COMMAND_PREFIX = "/"
+COMMAND_CATEGORIES = {
+    "state": ["yolo", "undo"],
+    "debug": ["dump", "compact"],
+    "ui": ["clear", "help"],
+    "config": ["model"],
+}
+
+# System paths
+SIDEKICK_HOME_DIR = ".tunacode"
+SESSIONS_SUBDIR = "sessions"
+DEVICE_ID_FILE = "device_id"
+
+# UI colors - Modern sleek color scheme
+UI_COLORS = {
+    "primary": "#00d7ff",      # Bright cyan
+    "secondary": "#64748b",   # Slate gray
+    "accent": "#7c3aed",      # Purple accent
+    "success": "#10b981",     # Emerald green
+    "warning": "#f59e0b",     # Amber
+    "error": "#ef4444",       # Red
+    "muted": "#94a3b8",       # Light slate
+    "file_ref": "#00d7ff",    # Bright cyan
+    "background": "#0f172a",  # Dark slate
+    "border": "#334155",      # Slate border
+}
+
+# UI text and formatting
+UI_PROMPT_PREFIX = "❯ "
+UI_THINKING_MESSAGE = "[bold #00d7ff]● Thinking...[/bold #00d7ff]"
+UI_DARKGREY_OPEN = "<darkgrey>"
+UI_DARKGREY_CLOSE = "</darkgrey>"
+UI_BOLD_OPEN = "<bold>"
+UI_BOLD_CLOSE = "</bold>"
+UI_KEY_ENTER = "Enter"
+UI_KEY_ESC_ENTER = "Esc + Enter"
+
+# Panel titles
+PANEL_ERROR = "Error"
+PANEL_MESSAGE_HISTORY = "Message History"
+PANEL_MODELS = "Models"
+PANEL_AVAILABLE_COMMANDS = "Available Commands"
+
+# Error messages
+ERROR_PROVIDER_EMPTY = "Provider number cannot be empty"
+ERROR_INVALID_PROVIDER = "Invalid provider number"
+ERROR_FILE_NOT_FOUND = "Error: File not found at '{filepath}'."
+ERROR_FILE_TOO_LARGE = "Error: File '{filepath}' is too large (> 100KB)."
+ERROR_FILE_DECODE = "Error reading file '{filepath}': Could not decode using UTF-8."
+ERROR_FILE_DECODE_DETAILS = "It might be a binary file or use a different encoding. {error}"
+ERROR_COMMAND_NOT_FOUND = "Error: Command not found or failed to execute:"
+ERROR_COMMAND_EXECUTION = (
+    "Error: Command not found or failed to execute: {command}. Details: {error}"
+)
+ERROR_UNDO_INIT = "Error initializing undo system: {e}"
+
+# Command output messages
+CMD_OUTPUT_NO_OUTPUT = "No output."
+CMD_OUTPUT_NO_ERRORS = "No errors."
+CMD_OUTPUT_FORMAT = "STDOUT:\n{output}\n\nSTDERR:\n{error}"
+CMD_OUTPUT_TRUNCATED = "\n...\n[truncated]\n...\n"
+
+# Undo system messages
+UNDO_DISABLED_HOME = "Undo system disabled, running from home directory"
+UNDO_DISABLED_NO_GIT = "⚠️  Not in a git repository - undo functionality will be limited"
+UNDO_INITIAL_COMMIT = "Initial commit for tunacode undo history"
+UNDO_GIT_TIMEOUT = "Git initialization timed out"
+
+# Log/status messages
+MSG_UPDATE_AVAILABLE = "Update available: v{latest_version}"
+MSG_UPDATE_INSTRUCTION = "Exit, and run: [bold]pip install --upgrade tunacode-cli"
+MSG_VERSION_DISPLAY = "TunaCode CLI {version}"
+MSG_FILE_SIZE_LIMIT = " Please specify a smaller file or use other tools to process it."

tunacode/context.py

@@ -0,0 +1,83 @@
+import json
+import os
+import subprocess
+from pathlib import Path
+from typing import Dict, List
+
+from tunacode.utils.system import list_cwd
+from tunacode.utils.ripgrep import ripgrep
+
+
+async def get_git_status() -> Dict[str, object]:
+    """Return git branch and dirty state information."""
+    try:
+        result = subprocess.run(
+            ["git", "status", "--porcelain", "--branch"],
+            capture_output=True,
+            text=True,
+            check=True,
+            timeout=5,
+        )
+        lines = result.stdout.splitlines()
+        branch_line = lines[0][2:] if lines else ""
+        branch = branch_line.split("...")[0]
+        ahead = behind = 0
+        if "[" in branch_line and "]" in branch_line:
+            bracket = branch_line.split("[", 1)[1].split("]", 1)[0]
+            for part in bracket.split(","):
+                if "ahead" in part:
+                    ahead = int(part.split("ahead")[1].strip().strip(" ]"))
+                if "behind" in part:
+                    behind = int(part.split("behind")[1].strip().strip(" ]"))
+        dirty = any(line for line in lines[1:])
+        return {"branch": branch, "ahead": ahead, "behind": behind, "dirty": dirty}
+    except Exception:
+        return {}
+
+
+async def get_directory_structure(max_depth: int = 3) -> str:
+    """Return a simple directory tree string."""
+    files = list_cwd(max_depth=max_depth)
+    lines: List[str] = []
+    for path in files:
+        depth = path.count("/")
+        indent = "  " * depth
+        name = path.split("/")[-1]
+        lines.append(f"{indent}{name}")
+    return "\n".join(lines)
+
+
+async def get_code_style() -> str:
+    """Concatenate contents of all TUNACODE.md files up the directory tree."""
+    parts: List[str] = []
+    current = Path.cwd()
+    while True:
+        file = current / "TUNACODE.md"
+        if file.exists():
+            try:
+                parts.append(file.read_text(encoding="utf-8"))
+            except Exception:
+                pass
+        if current == current.parent:
+            break
+        current = current.parent
+    return "\n".join(parts)
+
+
+async def get_claude_files() -> List[str]:
+    """Return a list of additional TUNACODE.md files in the repo."""
+    return ripgrep("TUNACODE.md", ".")
+
+
+async def get_context() -> Dict[str, object]:
+    """Gather repository context."""
+    git = await get_git_status()
+    directory = await get_directory_structure()
+    style = await get_code_style()
+    claude_files = await get_claude_files()
+    return {
+        "git": git,
+        "directory": directory,
+        "codeStyle": style,
+        "claudeFiles": claude_files,
+    }