tunacode-cli 0.0.1__py3-none-any.whl

tunacode/core/agents/main.py

@@ -0,0 +1,119 @@
+"""Module: sidekick.core.agents.main
+
+Main agent functionality and coordination for the Sidekick CLI.
+Provides agent creation, message processing, and tool call management.
+"""
+
+from datetime import datetime, timezone
+from typing import Optional
+
+from pydantic_ai import Agent, Tool
+from pydantic_ai.messages import ModelRequest, ToolReturnPart
+
+from tunacode.core.state import StateManager
+from tunacode.services.mcp import get_mcp_servers
+from tunacode.tools.read_file import read_file
+from tunacode.tools.run_command import run_command
+from tunacode.tools.update_file import update_file
+from tunacode.tools.write_file import write_file
+from tunacode.types import (AgentRun, ErrorMessage, ModelName, PydanticAgent, ToolCallback,
+                            ToolCallId, ToolName)
+
+
+async def _process_node(node, tool_callback: Optional[ToolCallback], state_manager: StateManager):
+    if hasattr(node, "request"):
+        state_manager.session.messages.append(node.request)
+
+    if hasattr(node, "model_response"):
+        state_manager.session.messages.append(node.model_response)
+        for part in node.model_response.parts:
+            if part.part_kind == "tool-call" and tool_callback:
+                await tool_callback(part, node)
+
+
+def get_or_create_agent(model: ModelName, state_manager: StateManager) -> PydanticAgent:
+    if model not in state_manager.session.agents:
+        max_retries = state_manager.session.user_config["settings"]["max_retries"]
+        state_manager.session.agents[model] = Agent(
+            model=model,
+            tools=[
+                Tool(read_file, max_retries=max_retries),
+                Tool(run_command, max_retries=max_retries),
+                Tool(update_file, max_retries=max_retries),
+                Tool(write_file, max_retries=max_retries),
+            ],
+            mcp_servers=get_mcp_servers(state_manager),
+        )
+    return state_manager.session.agents[model]
+
+
+def patch_tool_messages(
+    error_message: ErrorMessage = "Tool operation failed",
+    state_manager: StateManager = None,
+):
+    """
+    Find any tool calls without responses and add synthetic error responses for them.
+    Takes an error message to use in the synthesized tool response.
+
+    Ignores tools that have corresponding retry prompts as the model is already
+    addressing them.
+    """
+    if state_manager is None:
+        raise ValueError("state_manager is required for patch_tool_messages")
+
+    messages = state_manager.session.messages
+
+    if not messages:
+        return
+
+    # Map tool calls to their tool returns
+    tool_calls: dict[ToolCallId, ToolName] = {}  # tool_call_id -> tool_name
+    tool_returns: set[ToolCallId] = set()  # set of tool_call_ids with returns
+    retry_prompts: set[ToolCallId] = set()  # set of tool_call_ids with retry prompts
+
+    for message in messages:
+        if hasattr(message, "parts"):
+            for part in message.parts:
+                if (
+                    hasattr(part, "part_kind")
+                    and hasattr(part, "tool_call_id")
+                    and part.tool_call_id
+                ):
+                    if part.part_kind == "tool-call":
+                        tool_calls[part.tool_call_id] = part.tool_name
+                    elif part.part_kind == "tool-return":
+                        tool_returns.add(part.tool_call_id)
+                    elif part.part_kind == "retry-prompt":
+                        retry_prompts.add(part.tool_call_id)
+
+    # Identify orphaned tools (those without responses and not being retried)
+    for tool_call_id, tool_name in list(tool_calls.items()):
+        if tool_call_id not in tool_returns and tool_call_id not in retry_prompts:
+            messages.append(
+                ModelRequest(
+                    parts=[
+                        ToolReturnPart(
+                            tool_name=tool_name,
+                            content=error_message,
+                            tool_call_id=tool_call_id,
+                            timestamp=datetime.now(timezone.utc),
+                            part_kind="tool-return",
+                        )
+                    ],
+                    kind="request",
+                )
+            )
+
+
+async def process_request(
+    model: ModelName,
+    message: str,
+    state_manager: StateManager,
+    tool_callback: Optional[ToolCallback] = None,
+) -> AgentRun:
+    agent = get_or_create_agent(model, state_manager)
+    mh = state_manager.session.messages.copy()
+    async with agent.iter(message, message_history=mh) as agent_run:
+        async for node in agent_run:
+            await _process_node(node, tool_callback, state_manager)
+        return agent_run

tunacode/core/setup/__init__.py

@@ -0,0 +1,17 @@
+from .agent_setup import AgentSetup
+from .base import BaseSetup
+from .config_setup import ConfigSetup
+from .coordinator import SetupCoordinator
+from .environment_setup import EnvironmentSetup
+from .git_safety_setup import GitSafetySetup
+from .undo_setup import UndoSetup
+
+__all__ = [
+    "BaseSetup",
+    "SetupCoordinator",
+    "ConfigSetup",
+    "EnvironmentSetup",
+    "GitSafetySetup",
+    "UndoSetup",
+    "AgentSetup",
+]

tunacode/core/setup/agent_setup.py

@@ -0,0 +1,41 @@
+"""Module: sidekick.core.setup.agent_setup
+
+Agent initialization and configuration for the Sidekick CLI.
+Handles the setup and validation of AI agents with the selected model.
+"""
+
+from typing import Any, Optional
+
+from tunacode.core.setup.base import BaseSetup
+from tunacode.core.state import StateManager
+from tunacode.ui import console as ui
+
+
+class AgentSetup(BaseSetup):
+    """Setup step for agent initialization."""
+
+    def __init__(self, state_manager: StateManager, agent: Optional[Any] = None):
+        super().__init__(state_manager)
+        self.agent = agent
+
+    @property
+    def name(self) -> str:
+        return "Agent"
+
+    async def should_run(self, force_setup: bool = False) -> bool:
+        """Agent setup should run if an agent is provided."""
+        return self.agent is not None
+
+    async def execute(self, force_setup: bool = False) -> None:
+        """Initialize the agent with the current model."""
+        if self.agent is not None:
+            await ui.info(f"Initializing Agent({self.state_manager.session.current_model})")
+            self.agent.agent = self.agent.get_agent()
+
+    async def validate(self) -> bool:
+        """Validate that agent was initialized correctly."""
+        if self.agent is None:
+            return True  # No agent to validate
+
+        # Check if agent was initialized
+        return hasattr(self.agent, "agent") and self.agent.agent is not None

tunacode/core/setup/base.py

@@ -0,0 +1,37 @@
+"""Module: sidekick.core.setup.base
+
+Base setup step abstraction for the Sidekick CLI initialization process.
+Defines the contract that all setup steps must implement.
+"""
+
+from abc import ABC, abstractmethod
+
+from tunacode.core.state import StateManager
+
+
+class BaseSetup(ABC):
+    """Base class for all setup steps."""
+
+    def __init__(self, state_manager: StateManager):
+        self.state_manager = state_manager
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Return the name of this setup step."""
+        pass
+
+    @abstractmethod
+    async def should_run(self, force_setup: bool = False) -> bool:
+        """Determine if this setup step should run."""
+        pass
+
+    @abstractmethod
+    async def execute(self, force_setup: bool = False) -> None:
+        """Execute the setup step."""
+        pass
+
+    @abstractmethod
+    async def validate(self) -> bool:
+        """Validate that the setup was successful."""
+        pass

tunacode/core/setup/config_setup.py

@@ -0,0 +1,179 @@
+"""Module: sidekick.core.setup.config_setup
+
+Configuration system initialization for the Sidekick CLI.
+Handles user configuration loading, validation, and first-time setup onboarding.
+"""
+
+import json
+from pathlib import Path
+
+from tunacode.configuration.defaults import DEFAULT_USER_CONFIG
+from tunacode.configuration.models import ModelRegistry
+from tunacode.constants import APP_NAME, CONFIG_FILE_NAME, UI_COLORS
+from tunacode.core.setup.base import BaseSetup
+from tunacode.core.state import StateManager
+from tunacode.exceptions import ConfigurationError
+from tunacode.types import ConfigFile, ConfigPath, UserConfig
+from tunacode.ui import console as ui
+from tunacode.utils import system, user_configuration
+from tunacode.utils.text_utils import key_to_title
+
+
+class ConfigSetup(BaseSetup):
+    """Setup step for configuration and onboarding."""
+
+    def __init__(self, state_manager: StateManager):
+        super().__init__(state_manager)
+        self.config_dir: ConfigPath = Path.home() / ".config"
+        self.config_file: ConfigFile = self.config_dir / CONFIG_FILE_NAME
+        self.model_registry = ModelRegistry()
+
+    @property
+    def name(self) -> str:
+        return "Configuration"
+
+    async def should_run(self, force_setup: bool = False) -> bool:
+        """Config setup should always run to load and merge configuration."""
+        return True
+
+    async def execute(self, force_setup: bool = False) -> None:
+        """Setup configuration and run onboarding if needed."""
+        self.state_manager.session.device_id = system.get_device_id()
+        loaded_config = user_configuration.load_config()
+
+        if loaded_config and not force_setup:
+            # Silent loading
+            # Merge loaded config with defaults to ensure all required keys exist
+            self.state_manager.session.user_config = self._merge_with_defaults(loaded_config)
+        else:
+            if force_setup:
+                await ui.muted("Running setup process, resetting config")
+            else:
+                await ui.muted("No user configuration found, running setup")
+            self.state_manager.session.user_config = DEFAULT_USER_CONFIG.copy()
+            user_configuration.save_config(self.state_manager)  # Save the default config initially
+            await self._onboarding()
+
+        if not self.state_manager.session.user_config.get("default_model"):
+            raise ConfigurationError(
+                (
+                    f"No default model found in config at [bold]{self.config_file}[/bold]\n\n"
+                    "Run [code]sidekick --setup[/code] to rerun the setup process."
+                )
+            )
+
+        # Check if the configured model still exists
+        default_model = self.state_manager.session.user_config["default_model"]
+        if not self.model_registry.get_model(default_model):
+            await ui.panel(
+                "Model Not Found",
+                f"The configured model '[bold]{default_model}[/bold]' is no longer available.\n"
+                "Please select a new default model.",
+                border_style=UI_COLORS["warning"],
+            )
+            await self._step2_default_model()
+            user_configuration.save_config(self.state_manager)
+
+        self.state_manager.session.current_model = self.state_manager.session.user_config[
+            "default_model"
+        ]
+
+    async def validate(self) -> bool:
+        """Validate that configuration is properly set up."""
+        # Check that we have a user config
+        if not self.state_manager.session.user_config:
+            return False
+
+        # Check that we have a default model
+        if not self.state_manager.session.user_config.get("default_model"):
+            return False
+
+        # Check that the default model is valid
+        default_model = self.state_manager.session.user_config["default_model"]
+        if not self.model_registry.get_model(default_model):
+            return False
+
+        return True
+
+    def _merge_with_defaults(self, loaded_config: UserConfig) -> UserConfig:
+        """Merge loaded config with defaults to ensure all required keys exist."""
+        # Start with loaded config if available, otherwise use defaults
+        if loaded_config:
+            merged = loaded_config.copy()
+
+            # Add missing top-level keys from defaults
+            for key, default_value in DEFAULT_USER_CONFIG.items():
+                if key not in merged:
+                    merged[key] = default_value
+
+            return merged
+        else:
+            return DEFAULT_USER_CONFIG.copy()
+
+    async def _onboarding(self):
+        """Run the onboarding process for new users."""
+        initial_config = json.dumps(self.state_manager.session.user_config, sort_keys=True)
+
+        await self._step1_api_keys()
+
+        # Only continue if at least one API key was provided
+        env = self.state_manager.session.user_config.get("env", {})
+        has_api_key = any(key.endswith("_API_KEY") and env.get(key) for key in env)
+
+        if has_api_key:
+            if not self.state_manager.session.user_config.get("default_model"):
+                await self._step2_default_model()
+
+            # Compare configs to see if anything changed
+            current_config = json.dumps(self.state_manager.session.user_config, sort_keys=True)
+            if initial_config != current_config:
+                if user_configuration.save_config(self.state_manager):
+                    message = f"Config saved to: [bold]{self.config_file}[/bold]"
+                    await ui.panel("Finished", message, top=0, border_style=UI_COLORS["success"])
+                else:
+                    await ui.error("Failed to save configuration.")
+        else:
+            await ui.panel(
+                "Setup canceled",
+                "At least one API key is required.",
+                border_style=UI_COLORS["warning"],
+            )
+
+    async def _step1_api_keys(self):
+        """Onboarding step 1: Collect API keys."""
+        message = (
+            f"Welcome to {APP_NAME}!\n"
+            "Let's get you setup. First, we'll need to set some environment variables.\n"
+            "Skip the ones you don't need."
+        )
+        await ui.panel("Setup", message, border_style=UI_COLORS["primary"])
+        env_keys = self.state_manager.session.user_config["env"].copy()
+        for key in env_keys:
+            provider = key_to_title(key)
+            val = await ui.input(
+                "step1",
+                pretext=f"  {provider}: ",
+                is_password=True,
+                state_manager=self.state_manager,
+            )
+            val = val.strip()
+            if val:
+                self.state_manager.session.user_config["env"][key] = val
+
+    async def _step2_default_model(self):
+        """Onboarding step 2: Select default model."""
+        message = "Which model would you like to use by default?\n\n"
+
+        model_ids = self.model_registry.list_model_ids()
+        for index, model_id in enumerate(model_ids):
+            message += f"  {index} - {model_id}\n"
+        message = message.strip()
+
+        await ui.panel("Default Model", message, border_style=UI_COLORS["primary"])
+        choice = await ui.input(
+            "step2",
+            pretext="  Default model (#): ",
+            validator=ui.ModelValidator(len(model_ids)),
+            state_manager=self.state_manager,
+        )
+        self.state_manager.session.user_config["default_model"] = model_ids[int(choice)]

tunacode/core/setup/coordinator.py

@@ -0,0 +1,45 @@
+"""Module: sidekick.core.setup.coordinator
+
+Setup orchestration and coordination for the Sidekick CLI.
+Manages the execution order and validation of all registered setup steps.
+"""
+
+from typing import List
+
+from tunacode.core.setup.base import BaseSetup
+from tunacode.core.state import StateManager
+from tunacode.ui import console as ui
+
+
+class SetupCoordinator:
+    """Coordinator for running all setup steps in order."""
+
+    def __init__(self, state_manager: StateManager):
+        self.state_manager = state_manager
+        self.setup_steps: List[BaseSetup] = []
+
+    def register_step(self, step: BaseSetup) -> None:
+        """Register a setup step to be run."""
+        self.setup_steps.append(step)
+
+    async def run_setup(self, force_setup: bool = False) -> None:
+        """Run all registered setup steps in order."""
+        for step in self.setup_steps:
+            try:
+                if await step.should_run(force_setup):
+                    # Silent setup - no messages
+                    await step.execute(force_setup)
+
+                    if not await step.validate():
+                        await ui.error(f"Setup validation failed: {step.name}")
+                        raise RuntimeError(f"Setup step '{step.name}' failed validation")
+                else:
+                    # Skip silently
+                    pass
+            except Exception as e:
+                await ui.error(f"Setup failed at step '{step.name}': {str(e)}")
+                raise
+
+    def clear_steps(self) -> None:
+        """Clear all registered setup steps."""
+        self.setup_steps.clear()

tunacode/core/setup/environment_setup.py

@@ -0,0 +1,62 @@
+"""Module: sidekick.core.setup.environment_setup
+
+Environment detection and configuration for the Sidekick CLI.
+Handles setting up environment variables from user configuration.
+"""
+
+import os
+
+from tunacode.core.setup.base import BaseSetup
+from tunacode.core.state import StateManager
+from tunacode.types import EnvConfig
+from tunacode.ui import console as ui
+
+
+class EnvironmentSetup(BaseSetup):
+    """Setup step for environment variables."""
+
+    def __init__(self, state_manager: StateManager):
+        super().__init__(state_manager)
+
+    @property
+    def name(self) -> str:
+        return "Environment Variables"
+
+    async def should_run(self, force_setup: bool = False) -> bool:
+        """Environment setup should always run to set env vars from config."""
+        return True
+
+    async def execute(self, force_setup: bool = False) -> None:
+        """Set environment variables from the config file."""
+        if "env" not in self.state_manager.session.user_config or not isinstance(
+            self.state_manager.session.user_config["env"], dict
+        ):
+            self.state_manager.session.user_config["env"] = {}
+
+        env_dict: EnvConfig = self.state_manager.session.user_config["env"]
+        env_set_count = 0
+
+        for key, value in env_dict.items():
+            if not isinstance(value, str):
+                await ui.warning(f"Invalid env value in config: {key}")
+                continue
+            value = value.strip()
+            if value:
+                os.environ[key] = value
+                env_set_count += 1
+
+        # Silent env setup
+
+    async def validate(self) -> bool:
+        """Validate that environment variables were set correctly."""
+        # Check that at least one API key environment variable is set
+        env_dict = self.state_manager.session.user_config.get("env", {})
+        for key, value in env_dict.items():
+            if key.endswith("_API_KEY") and value and value.strip():
+                # Check if it was actually set in the environment
+                if os.environ.get(key) == value.strip():
+                    return True
+
+        # If no API keys are configured, that's still valid
+        # (user might be using other auth methods)
+        return True