tunacode-cli 0.0.35__py3-none-any.whl → 0.0.37__py3-none-any.whl

tunacode/cli/commands/__init__.py

@@ -0,0 +1,62 @@
+"""Command system for TunaCode CLI.
+
+This package provides a modular command system with:
+- Base classes and infrastructure in `base.py`
+- Command registry and factory in `registry.py`
+- Command implementations organized by category in `implementations/`
+
+The main public API provides backward compatibility with the original
+commands.py module while enabling better organization and maintainability.
+"""
+
+# Import base classes and infrastructure
+from .base import Command, CommandCategory, CommandSpec, SimpleCommand
+
+# Import all command implementations for backward compatibility
+from .implementations import (
+    BranchCommand,
+    ClearCommand,
+    CompactCommand,
+    DumpCommand,
+    FixCommand,
+    HelpCommand,
+    InitCommand,
+    IterationsCommand,
+    ModelCommand,
+    ParseToolsCommand,
+    RefreshConfigCommand,
+    ThoughtsCommand,
+    UpdateCommand,
+    YoloCommand,
+)
+
+# Import registry and factory
+from .registry import CommandDependencies, CommandFactory, CommandRegistry
+
+# Maintain backward compatibility by exposing the same public API
+__all__ = [
+    # Base infrastructure
+    "Command",
+    "SimpleCommand",
+    "CommandSpec",
+    "CommandCategory",
+    # Registry and factory
+    "CommandRegistry",
+    "CommandFactory",
+    "CommandDependencies",
+    # All command classes (imported from implementations)
+    "YoloCommand",
+    "DumpCommand",
+    "ThoughtsCommand",
+    "IterationsCommand",
+    "ClearCommand",
+    "FixCommand",
+    "ParseToolsCommand",
+    "RefreshConfigCommand",
+    "HelpCommand",
+    "BranchCommand",
+    "CompactCommand",
+    "UpdateCommand",
+    "ModelCommand",
+    "InitCommand",
+]

tunacode/cli/commands/base.py

@@ -0,0 +1,99 @@
+"""Base classes and infrastructure for TunaCode CLI commands."""
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from enum import Enum
+from typing import List
+
+from ...types import CommandArgs, CommandContext, CommandResult
+
+
+class CommandCategory(Enum):
+    """Categories for organizing commands."""
+
+    SYSTEM = "system"
+    NAVIGATION = "navigation"
+    DEVELOPMENT = "development"
+    MODEL = "model"
+    DEBUG = "debug"
+
+
+class Command(ABC):
+    """Base class for all commands."""
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """The primary name of the command."""
+        pass
+
+    @property
+    @abstractmethod
+    def aliases(self) -> CommandArgs:
+        """Alternative names/aliases for the command."""
+        pass
+
+    @property
+    def description(self) -> str:
+        """Description of what the command does."""
+        return ""
+
+    @property
+    def category(self) -> CommandCategory:
+        """Category this command belongs to."""
+        return CommandCategory.SYSTEM
+
+    @abstractmethod
+    async def execute(self, args: CommandArgs, context: CommandContext) -> CommandResult:
+        """
+        Execute the command.
+
+        Args:
+            args: Command arguments (excluding the command name)
+            context: Execution context with state and config
+
+        Returns:
+            Command-specific return value
+        """
+        pass
+
+
+@dataclass
+class CommandSpec:
+    """Specification for a command's metadata."""
+
+    name: str
+    aliases: List[str]
+    description: str
+    category: CommandCategory = CommandCategory.SYSTEM
+
+
+class SimpleCommand(Command):
+    """Base class for simple commands without complex logic.
+
+    This class provides a standard implementation for commands that don't
+    require special initialization or complex behavior. It reads all
+    properties from a class-level CommandSpec attribute.
+    """
+
+    spec: CommandSpec
+
+    @property
+    def name(self) -> str:
+        """The primary name of the command."""
+        return self.__class__.spec.name
+
+    @property
+    def aliases(self) -> CommandArgs:
+        """Alternative names/aliases for the command."""
+        return self.__class__.spec.aliases
+
+    @property
+    def description(self) -> str:
+        """Description of what the command does."""
+        return self.__class__.spec.description
+
+    @property
+    def category(self) -> CommandCategory:
+        """Category this command belongs to."""
+        return self.__class__.spec.category

tunacode/cli/commands/implementations/__init__.py

@@ -0,0 +1,38 @@
+"""Command implementations for TunaCode CLI."""
+
+# Import all command classes for easy access
+from .conversation import CompactCommand
+from .debug import (
+    DumpCommand,
+    FixCommand,
+    IterationsCommand,
+    ParseToolsCommand,
+    ThoughtsCommand,
+    YoloCommand,
+)
+from .development import BranchCommand, InitCommand
+from .model import ModelCommand
+from .system import ClearCommand, HelpCommand, RefreshConfigCommand, StreamingCommand, UpdateCommand
+
+__all__ = [
+    # System commands
+    "HelpCommand",
+    "ClearCommand",
+    "RefreshConfigCommand",
+    "StreamingCommand",
+    "UpdateCommand",
+    # Debug commands
+    "YoloCommand",
+    "DumpCommand",
+    "ThoughtsCommand",
+    "IterationsCommand",
+    "FixCommand",
+    "ParseToolsCommand",
+    # Development commands
+    "BranchCommand",
+    "InitCommand",
+    # Model commands
+    "ModelCommand",
+    # Conversation commands
+    "CompactCommand",
+]

tunacode/cli/commands/implementations/conversation.py

@@ -0,0 +1,115 @@
+"""Conversation management commands for TunaCode CLI."""
+
+from typing import List, Optional
+
+from ....types import CommandContext, ProcessRequestCallback
+from ....ui import console as ui
+from ..base import CommandCategory, CommandSpec, SimpleCommand
+
+
+class CompactCommand(SimpleCommand):
+    """Compact conversation context."""
+
+    spec = CommandSpec(
+        name="compact",
+        aliases=["/compact"],
+        description="Summarize and compact the conversation history",
+        category=CommandCategory.SYSTEM,
+    )
+
+    def __init__(self, process_request_callback: Optional[ProcessRequestCallback] = None):
+        self._process_request = process_request_callback
+
+    async def execute(self, args: List[str], context: CommandContext) -> None:
+        # Use the injected callback or get it from context
+        process_request = self._process_request or context.process_request
+
+        if not process_request:
+            await ui.error("Compact command not available - process_request not configured")
+            return
+
+        # Count current messages
+        original_count = len(context.state_manager.session.messages)
+
+        # Generate summary with output captured
+        summary_prompt = (
+            "Summarize the conversation so far in a concise paragraph, "
+            "focusing on the main topics discussed and any important context "
+            "that should be preserved."
+        )
+        result = await process_request(
+            summary_prompt,
+            context.state_manager,
+            output=False,  # We'll handle the output ourselves
+        )
+
+        # Extract summary text from result
+        summary_text = ""
+
+        # First try: standard result structure
+        if (
+            result
+            and hasattr(result, "result")
+            and result.result
+            and hasattr(result.result, "output")
+        ):
+            summary_text = result.result.output
+
+        # Second try: check messages for assistant response
+        if not summary_text:
+            messages = context.state_manager.session.messages
+            # Look through new messages in reverse order
+            for i in range(len(messages) - 1, original_count - 1, -1):
+                msg = messages[i]
+                # Handle ModelResponse objects
+                if hasattr(msg, "parts") and msg.parts:
+                    for part in msg.parts:
+                        if hasattr(part, "content") and part.content:
+                            content = part.content
+                            # Skip JSON thought objects
+                            if content.strip().startswith('{"thought"'):
+                                lines = content.split("\n")
+                                # Find the actual summary after the JSON
+                                for i, line in enumerate(lines):
+                                    if (
+                                        line.strip()
+                                        and not line.strip().startswith("{")
+                                        and not line.strip().endswith("}")
+                                    ):
+                                        summary_text = "\n".join(lines[i:]).strip()
+                                        break
+                            else:
+                                summary_text = content
+                            if summary_text:
+                                break
+                # Handle dict-style messages
+                elif isinstance(msg, dict):
+                    if msg.get("role") == "assistant" and msg.get("content"):
+                        summary_text = msg["content"]
+                        break
+                # Handle other message types
+                elif hasattr(msg, "content") and hasattr(msg, "role"):
+                    if getattr(msg, "role", None) == "assistant":
+                        summary_text = msg.content
+                        break
+
+                if summary_text:
+                    break
+
+        if not summary_text:
+            await ui.error("Failed to generate summary - no assistant response found")
+            return
+
+        # Display summary in a formatted panel
+        from tunacode.ui import panels
+
+        await panels.panel("Conversation Summary", summary_text, border_style="cyan")
+
+        # Show statistics
+        await ui.info(f"Current message count: {original_count}")
+        await ui.info("After compaction: 3 (summary + last 2 messages)")
+
+        # Truncate the conversation history
+        context.state_manager.session.messages = context.state_manager.session.messages[-2:]
+
+        await ui.success("Context history has been summarized and truncated.")

tunacode/cli/commands/implementations/debug.py

@@ -0,0 +1,189 @@
+"""Debug and troubleshooting commands for TunaCode CLI."""
+
+from typing import List
+
+from ....types import CommandContext
+from ....ui import console as ui
+from ..base import CommandCategory, CommandSpec, SimpleCommand
+
+
+class YoloCommand(SimpleCommand):
+    """Toggle YOLO mode (skip confirmations)."""
+
+    spec = CommandSpec(
+        name="yolo",
+        aliases=["/yolo"],
+        description="Toggle YOLO mode (skip tool confirmations)",
+        category=CommandCategory.DEVELOPMENT,
+    )
+
+    async def execute(self, args: List[str], context: CommandContext) -> None:
+        state = context.state_manager.session
+        state.yolo = not state.yolo
+        if state.yolo:
+            await ui.success("All tools are now active ⚡ Please proceed with caution.\n")
+        else:
+            await ui.info("Tool confirmations re-enabled for safety.\n")
+
+
+class DumpCommand(SimpleCommand):
+    """Dump message history."""
+
+    spec = CommandSpec(
+        name="dump",
+        aliases=["/dump"],
+        description="Dump the current message history",
+        category=CommandCategory.DEBUG,
+    )
+
+    async def execute(self, args: List[str], context: CommandContext) -> None:
+        await ui.dump_messages(context.state_manager.session.messages)
+
+
+class ThoughtsCommand(SimpleCommand):
+    """Toggle display of agent thoughts."""
+
+    spec = CommandSpec(
+        name="thoughts",
+        aliases=["/thoughts"],
+        description="Show or hide agent thought messages",
+        category=CommandCategory.DEBUG,
+    )
+
+    async def execute(self, args: List[str], context: CommandContext) -> None:
+        state = context.state_manager.session
+
+        # No args - toggle
+        if not args:
+            state.show_thoughts = not state.show_thoughts
+            status = "ON" if state.show_thoughts else "OFF"
+            await ui.success(f"Thought display {status}")
+            return
+
+        # Parse argument
+        arg = args[0].lower()
+        if arg in {"on", "1", "true"}:
+            state.show_thoughts = True
+        elif arg in {"off", "0", "false"}:
+            state.show_thoughts = False
+        else:
+            await ui.error("Usage: /thoughts [on|off]")
+            return
+
+        status = "ON" if state.show_thoughts else "OFF"
+        await ui.success(f"Thought display {status}")
+
+
+class IterationsCommand(SimpleCommand):
+    """Configure maximum agent iterations for ReAct reasoning."""
+
+    spec = CommandSpec(
+        name="iterations",
+        aliases=["/iterations"],
+        description="Set maximum agent iterations for complex reasoning",
+        category=CommandCategory.DEBUG,
+    )
+
+    async def execute(self, args: List[str], context: CommandContext) -> None:
+        state = context.state_manager.session
+
+        # Guard clause - handle "no args" case first and return early
+        if not args:
+            current = state.user_config.get("settings", {}).get("max_iterations", 40)
+            await ui.info(f"Current maximum iterations: {current}")
+            await ui.muted("Usage: /iterations <number> (1-100)")
+            return
+
+        # update the logic to not be as nested messely, the above guars needing to get as messy
+        try:
+            new_limit = int(args[0])
+            if new_limit < 1 or new_limit > 100:
+                await ui.error("Iterations must be between 1 and 100")
+                return
+
+            # Update the user config
+            if "settings" not in state.user_config:
+                state.user_config["settings"] = {}
+            state.user_config["settings"]["max_iterations"] = new_limit
+
+            await ui.success(f"Maximum iterations set to {new_limit}")
+        except ValueError:
+            await ui.error("Please provide a valid number")
+
+
+class FixCommand(SimpleCommand):
+    """Fix orphaned tool calls that cause API errors."""
+
+    spec = CommandSpec(
+        name="fix",
+        aliases=["/fix"],
+        description="Fix orphaned tool calls causing API errors",
+        category=CommandCategory.DEBUG,
+    )
+
+    async def execute(self, args: List[str], context: CommandContext) -> None:
+        from tunacode.core.agents.main import patch_tool_messages
+
+        # Count current messages
+        before_count = len(context.state_manager.session.messages)
+
+        # Patch orphaned tool calls
+        patch_tool_messages("Tool call resolved by /fix command", context.state_manager)
+
+        # Count after patching
+        after_count = len(context.state_manager.session.messages)
+        patched_count = after_count - before_count
+
+        if patched_count > 0:
+            await ui.success(f"Fixed {patched_count} orphaned tool call(s)")
+            await ui.muted("You can now continue the conversation normally")
+        else:
+            await ui.info("No orphaned tool calls found")
+
+
+class ParseToolsCommand(SimpleCommand):
+    """Parse and execute JSON tool calls from the last response."""
+
+    spec = CommandSpec(
+        name="parsetools",
+        aliases=["/parsetools"],
+        description=("Parse JSON tool calls from last response when structured calling fails"),
+        category=CommandCategory.DEBUG,
+    )
+
+    async def execute(self, args: List[str], context: CommandContext) -> None:
+        from tunacode.core.agents.main import extract_and_execute_tool_calls
+
+        # Find the last model response in messages
+        messages = context.state_manager.session.messages
+        if not messages:
+            await ui.error("No message history found")
+            return
+
+        # Look for the most recent response with text content
+        found_content = False
+        for msg in reversed(messages):
+            if hasattr(msg, "parts"):
+                for part in msg.parts:
+                    if hasattr(part, "content") and isinstance(part.content, str):
+                        # Create tool callback
+                        from tunacode.cli.repl import _tool_handler
+
+                        def tool_callback_with_state(part, node):
+                            return _tool_handler(part, node, context.state_manager)
+
+                        try:
+                            await extract_and_execute_tool_calls(
+                                part.content,
+                                tool_callback_with_state,
+                                context.state_manager,
+                            )
+                            await ui.success("JSON tool parsing completed")
+                            found_content = True
+                            return
+                        except Exception as e:
+                            await ui.error(f"Failed to parse tools: {str(e)}")
+                            return
+
+        if not found_content:
+            await ui.error("No parseable content found in recent messages")

tunacode/cli/commands/implementations/development.py

@@ -0,0 +1,77 @@
+"""Development-focused commands for TunaCode CLI."""
+
+import os
+import subprocess
+from typing import List
+
+from ....types import CommandContext, CommandResult
+from ....ui import console as ui
+from ..base import CommandCategory, CommandSpec, SimpleCommand
+
+
+class BranchCommand(SimpleCommand):
+    """Create and switch to a new git branch."""
+
+    spec = CommandSpec(
+        name="branch",
+        aliases=["/branch"],
+        description="Create and switch to a new git branch",
+        category=CommandCategory.DEVELOPMENT,
+    )
+
+    async def execute(self, args: List[str], context: CommandContext) -> None:
+        if not args:
+            await ui.error("Usage: /branch <branch-name>")
+            return
+
+        if not os.path.exists(".git"):
+            await ui.error("Not a git repository")
+            return
+
+        branch_name = args[0]
+
+        try:
+            subprocess.run(
+                ["git", "checkout", "-b", branch_name],
+                capture_output=True,
+                text=True,
+                check=True,
+                timeout=5,
+            )
+            await ui.success(f"Switched to new branch '{branch_name}'")
+        except subprocess.TimeoutExpired:
+            await ui.error("Git command timed out")
+        except subprocess.CalledProcessError as e:
+            error_msg = e.stderr.strip() if e.stderr else str(e)
+            await ui.error(f"Git error: {error_msg}")
+        except FileNotFoundError:
+            await ui.error("Git executable not found")
+
+
+class InitCommand(SimpleCommand):
+    """Creates or updates TUNACODE.md with project-specific context."""
+
+    spec = CommandSpec(
+        name="/init",
+        aliases=[],
+        description="Analyze codebase and create/update TUNACODE.md file",
+        category=CommandCategory.DEVELOPMENT,
+    )
+
+    async def execute(self, args, context: CommandContext) -> CommandResult:
+        """Execute the init command."""
+        # Minimal implementation to make test pass
+        prompt = """Please analyze this codebase and create a TUNACODE.md file containing:
+1. Build/lint/test commands - especially for running a single test
+2. Code style guidelines including imports, formatting, types, naming conventions, error handling, etc.
+
+The file you create will be given to agentic coding agents (such as yourself) that operate in this repository.
+Make it about 20 lines long.
+If there's already a TUNACODE.md, improve it.
+If there are Cursor rules (in .cursor/rules/ or .cursorrules) or Copilot rules (in .github/copilot-instructions.md),
+make sure to include them."""
+
+        # Call the agent to analyze and create/update the file
+        await context.process_request(prompt, context.state_manager)
+
+        return None

tunacode/cli/commands/implementations/model.py

@@ -0,0 +1,61 @@
+"""Model management commands for TunaCode CLI."""
+
+from typing import Optional
+
+from .... import utils
+from ....exceptions import ConfigurationError
+from ....types import CommandArgs, CommandContext
+from ....ui import console as ui
+from ..base import CommandCategory, CommandSpec, SimpleCommand
+
+
+class ModelCommand(SimpleCommand):
+    """Manage model selection."""
+
+    spec = CommandSpec(
+        name="model",
+        aliases=["/model"],
+        description="Switch model (e.g., /model gpt-4 or /model openai:gpt-4)",
+        category=CommandCategory.MODEL,
+    )
+
+    async def execute(self, args: CommandArgs, context: CommandContext) -> Optional[str]:
+        # No arguments - show current model
+        if not args:
+            current_model = context.state_manager.session.current_model
+            await ui.info(f"Current model: {current_model}")
+            await ui.muted("Usage: /model <provider:model-name> [default]")
+            await ui.muted("Example: /model openai:gpt-4.1")
+            return None
+
+        # Get the model name from args
+        model_name = args[0]
+
+        # Check if provider prefix is present
+        if ":" not in model_name:
+            await ui.error("Model name must include provider prefix")
+            await ui.muted("Format: provider:model-name")
+            await ui.muted(
+                "Examples: openai:gpt-4.1, anthropic:claude-3-opus, google-gla:gemini-2.0-flash"
+            )
+            return None
+
+        # No validation - user is responsible for correct model names
+        await ui.warning("Model set without validation - verify the model name is correct")
+
+        # Set the model
+        context.state_manager.session.current_model = model_name
+
+        # Check if setting as default
+        if len(args) > 1 and args[1] == "default":
+            try:
+                utils.user_configuration.set_default_model(model_name, context.state_manager)
+                await ui.muted("Updating default model")
+                return "restart"
+            except ConfigurationError as e:
+                await ui.error(str(e))
+                return None
+
+        # Show success message with the new model
+        await ui.success(f"Switched to model: {model_name}")
+        return None