tunacode-cli 0.0.4__py3-none-any.whl → 0.0.6__py3-none-any.whl

tunacode/core/agents/tinyagent_main.py

@@ -0,0 +1,171 @@
+"""TinyAgent-based agent implementation."""
+
+from contextlib import asynccontextmanager
+from datetime import datetime, timezone
+from typing import Any, Dict, Optional
+
+from tinyagent.react.react_agent import ReactAgent
+
+from tunacode.core.state import StateManager
+from tunacode.tools.tinyagent_tools import read_file, run_command, update_file, write_file
+from tunacode.types import ModelName, ToolCallback
+
+
+def get_or_create_react_agent(model: ModelName, state_manager: StateManager) -> ReactAgent:
+    """
+    Get or create a ReactAgent for the specified model.
+
+    Args:
+        model: The model name (e.g., "openai:gpt-4o", "openrouter:openai/gpt-4.1")
+        state_manager: The state manager instance
+
+    Returns:
+        ReactAgent instance configured for the model
+    """
+    agents = state_manager.session.agents
+
+    if model not in agents:
+        # Parse model string to determine provider and actual model name
+        # Format: "provider:model" or "openrouter:provider/model"
+        if model.startswith("openrouter:"):
+            # OpenRouter model - extract the actual model name
+            actual_model = model.replace("openrouter:", "")
+            # Set environment to use OpenRouter base URL
+            import os
+
+            os.environ["OPENAI_BASE_URL"] = "https://openrouter.ai/api/v1"
+            # Use OpenRouter API key if available
+            if state_manager.session.user_config["env"].get("OPENROUTER_API_KEY"):
+                os.environ["OPENAI_API_KEY"] = state_manager.session.user_config["env"][
+                    "OPENROUTER_API_KEY"
+                ]
+        else:
+            # Direct provider (openai, anthropic, google-gla)
+            provider, actual_model = model.split(":", 1)
+            # Reset to default base URL for direct providers
+            import os
+
+            if provider == "openai":
+                os.environ["OPENAI_BASE_URL"] = "https://api.openai.com/v1"
+            # Set appropriate API key
+            provider_key_map = {
+                "openai": "OPENAI_API_KEY",
+                "anthropic": "ANTHROPIC_API_KEY",
+                "google-gla": "GEMINI_API_KEY",
+            }
+            if provider in provider_key_map:
+                key_name = provider_key_map[provider]
+                if state_manager.session.user_config["env"].get(key_name):
+                    os.environ[key_name] = state_manager.session.user_config["env"][key_name]
+
+        # Create new ReactAgent with the actual model name
+        agent = ReactAgent(model_override=actual_model)
+
+        # Register our tools
+        for fn in (read_file, write_file, update_file, run_command):
+            agent.register_tool(fn._tool)
+
+        # Add MCP compatibility method
+        @asynccontextmanager
+        async def run_mcp_servers():
+            # TinyAgent doesn't have built-in MCP support yet
+            # This is a placeholder for compatibility
+            yield
+
+        agent.run_mcp_servers = run_mcp_servers
+
+        # Cache the agent
+        agents[model] = agent
+
+    return agents[model]
+
+
+async def process_request_with_tinyagent(
+    model: ModelName,
+    message: str,
+    state_manager: StateManager,
+    tool_callback: Optional[ToolCallback] = None,
+) -> Dict[str, Any]:
+    """
+    Process a request using TinyAgent's ReactAgent.
+
+    Args:
+        model: The model to use
+        message: The user message
+        state_manager: State manager instance
+        tool_callback: Optional callback for tool execution (for UI updates)
+
+    Returns:
+        Dict containing the result and any metadata
+    """
+    agent = get_or_create_react_agent(model, state_manager)
+
+    # Convert message history to format expected by tinyAgent
+    # Note: tinyAgent handles message history differently than pydantic-ai
+    # We'll need to adapt based on tinyAgent's actual API
+
+    try:
+        # Run the agent with the message
+        result = await agent.run_react(message)
+
+        # Update message history in state_manager
+        # This will need to be adapted based on how tinyAgent returns messages
+        state_manager.session.messages.append(
+            {
+                "role": "user",
+                "content": message,
+                "timestamp": datetime.now(timezone.utc).isoformat(),
+            }
+        )
+
+        state_manager.session.messages.append(
+            {
+                "role": "assistant",
+                "content": result,
+                "timestamp": datetime.now(timezone.utc).isoformat(),
+            }
+        )
+
+        return {"result": result, "success": True, "model": model}
+
+    except Exception as e:
+        # Handle errors
+        error_result = {
+            "result": f"Error: {str(e)}",
+            "success": False,
+            "model": model,
+            "error": str(e),
+        }
+
+        # Still update message history with the error
+        state_manager.session.messages.append(
+            {
+                "role": "user",
+                "content": message,
+                "timestamp": datetime.now(timezone.utc).isoformat(),
+            }
+        )
+
+        state_manager.session.messages.append(
+            {
+                "role": "assistant",
+                "content": f"Error occurred: {str(e)}",
+                "timestamp": datetime.now(timezone.utc).isoformat(),
+                "error": True,
+            }
+        )
+
+        return error_result
+
+
+def patch_tool_messages(
+    error_message: str = "Tool operation failed",
+    state_manager: StateManager = None,
+):
+    """
+    Compatibility function for patching tool messages.
+    With tinyAgent, this may not be needed as it handles tool errors differently.
+    """
+    # TinyAgent handles tool retries and errors internally
+    # This function is kept for compatibility but may be simplified
+    pass

tunacode/core/setup/git_safety_setup.py

@@ -13,15 +13,12 @@ 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}: "
-    )
-    
+    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']
+
+    return response.lower().strip() in ["y", "yes"]
 
 
 class GitSafetySetup(BaseSetup):
@@ -29,7 +26,7 @@ class GitSafetySetup(BaseSetup):
 
     def __init__(self, state_manager: StateManager):
         super().__init__(state_manager)
-    
+
     @property
     def name(self) -> str:
         """Return the name of this setup step."""
@@ -45,18 +42,15 @@ class GitSafetySetup(BaseSetup):
         try:
             # Check if git is installed
             result = subprocess.run(
-                ["git", "--version"],
-                capture_output=True,
-                text=True,
-                check=False
+                ["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"
+                    border_style="yellow",
                 )
                 return
 
@@ -66,33 +60,31 @@ class GitSafetySetup(BaseSetup):
                 capture_output=True,
                 text=True,
                 check=False,
-                cwd=Path.cwd()
+                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"
+                    border_style="yellow",
                 )
                 return
 
             # Get current branch name
             result = subprocess.run(
-                ["git", "branch", "--show-current"],
-                capture_output=True,
-                text=True,
-                check=True
+                ["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"
+                    "You're in a detached HEAD state. TunaCode will continue "
+                    "without creating a branch.",
+                    border_style="yellow",
                 )
                 return
 
@@ -103,31 +95,28 @@ class GitSafetySetup(BaseSetup):
 
             # 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
+                ["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"For safety, TunaCode can create a new branch '{new_branch}' "
+                f"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
-            )
-            
+                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(
@@ -135,26 +124,25 @@ class GitSafetySetup(BaseSetup):
                     "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"
+                    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
+                    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
+                        f"Branch '{new_branch}' already exists. Switch to it?", default=True
                     )
                     if use_existing:
                         subprocess.run(["git", "checkout", new_branch], check=True)
@@ -165,24 +153,24 @@ class GitSafetySetup(BaseSetup):
                     # 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"
+                    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"
+                border_style="yellow",
             )
 
     async def validate(self) -> bool:
         """Validate git safety setup - always returns True as this is optional."""
-        return True
+        return True

tunacode/core/setup/optimized_coordinator.py

@@ -0,0 +1,73 @@
+"""Optimized setup coordinator with deferred loading."""
+
+import asyncio
+from typing import List, Set
+
+from tunacode.core.setup.base import BaseSetup
+from tunacode.core.state import StateManager
+from tunacode.ui import console as ui
+
+
+class OptimizedSetupCoordinator:
+    """Optimized coordinator that defers non-critical setup steps."""
+
+    def __init__(self, state_manager: StateManager):
+        self.state_manager = state_manager
+        self.critical_steps: List[BaseSetup] = []
+        self.deferred_steps: List[BaseSetup] = []
+        self._deferred_task = None
+
+        # Define critical steps that must run at startup
+        self.critical_step_names: Set[str] = {
+            "Configuration",  # Need config to know which model to use
+            "Environment Variables",  # Need API keys
+        }
+
+    def register_step(self, step: BaseSetup) -> None:
+        """Register a setup step, separating critical from deferred."""
+        if step.name in self.critical_step_names:
+            self.critical_steps.append(step)
+        else:
+            self.deferred_steps.append(step)
+
+    async def run_setup(self, force_setup: bool = False) -> None:
+        """Run critical setup immediately, defer the rest."""
+        # Run critical steps synchronously
+        for step in self.critical_steps:
+            try:
+                if await step.should_run(force_setup):
+                    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")
+            except Exception as e:
+                await ui.error(f"Setup failed at step '{step.name}': {str(e)}")
+                raise
+
+        # Schedule deferred steps to run in background
+        if self.deferred_steps and not self._deferred_task:
+            self._deferred_task = asyncio.create_task(self._run_deferred_steps(force_setup))
+
+    async def _run_deferred_steps(self, force_setup: bool) -> None:
+        """Run deferred steps in the background."""
+        # Wait a moment to let the main UI start
+        await asyncio.sleep(0.1)
+
+        for step in self.deferred_steps:
+            try:
+                if await step.should_run(force_setup):
+                    await step.execute(force_setup)
+                    # Don't validate deferred steps - they're non-critical
+            except Exception:
+                # Log but don't fail on deferred steps
+                pass
+
+    async def ensure_deferred_complete(self) -> None:
+        """Ensure deferred steps are complete before certain operations."""
+        if self._deferred_task and not self._deferred_task.done():
+            await self._deferred_task
+
+    def clear_steps(self) -> None:
+        """Clear all registered setup steps."""
+        self.critical_steps.clear()
+        self.deferred_steps.clear()

tunacode/exceptions.py

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