tunacode-cli 0.0.17__py3-none-any.whl → 0.0.18__py3-none-any.whl

tunacode/core/agents/main.py

@@ -9,8 +9,22 @@ import re
 from datetime import datetime, timezone
 from typing import Optional
 
-from pydantic_ai import Agent, Tool
-from pydantic_ai.messages import ModelRequest, ToolReturnPart
+# Lazy import for Agent and Tool
+
+
+def get_agent_tool():
+    import importlib
+
+    pydantic_ai = importlib.import_module("pydantic_ai")
+    return pydantic_ai.Agent, pydantic_ai.Tool
+
+
+def get_model_messages():
+    import importlib
+
+    messages = importlib.import_module("pydantic_ai.messages")
+    return messages.ModelRequest, messages.ToolReturnPart
+
 
 from tunacode.core.state import StateManager
 from tunacode.services.mcp import get_mcp_servers
@@ -20,15 +34,8 @@ 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,
-)
+from tunacode.types import (AgentRun, ErrorMessage, ModelName, PydanticAgent, ToolCallback,
+                            ToolCallId, ToolName)
 
 
 async def _process_node(node, tool_callback: Optional[ToolCallback], state_manager: StateManager):
@@ -40,63 +47,65 @@ async def _process_node(node, tool_callback: Optional[ToolCallback], state_manag
         # Display thought immediately if show_thoughts is enabled
         if state_manager.session.show_thoughts:
             from tunacode.ui import console as ui
+
             await ui.muted(f"💭 THOUGHT: {node.thought}")
 
     if hasattr(node, "model_response"):
         state_manager.session.messages.append(node.model_response)
-        
+
         # Enhanced ReAct thought processing
         if state_manager.session.show_thoughts:
-            from tunacode.ui import console as ui
             import json
             import re
-            
+
+            from tunacode.ui import console as ui
+
             for part in node.model_response.parts:
-                if hasattr(part, 'content') and isinstance(part.content, str):
+                if hasattr(part, "content") and isinstance(part.content, str):
                     content = part.content.strip()
-                    
+
                     # Pattern 1: Inline JSON thoughts {"thought": "..."}
                     thought_pattern = r'\{"thought":\s*"([^"]+)"\}'
                     matches = re.findall(thought_pattern, content)
                     for thought in matches:
                         await ui.muted(f"💭 REASONING: {thought}")
-                        
+
                     # Pattern 2: Standalone thought JSON objects
                     try:
                         if content.startswith('{"thought"'):
                             thought_obj = json.loads(content)
-                            if 'thought' in thought_obj:
+                            if "thought" in thought_obj:
                                 await ui.muted(f"💭 REASONING: {thought_obj['thought']}")
                     except (json.JSONDecodeError, KeyError):
                         pass
-                    
+
                     # Pattern 3: Multi-line thoughts with context
                     multiline_pattern = r'\{"thought":\s*"([^"]+(?:\\.[^"]*)*?)"\}'
                     multiline_matches = re.findall(multiline_pattern, content, re.DOTALL)
                     for thought in multiline_matches:
                         if thought not in [m for m in matches]:  # Avoid duplicates
                             # Clean up escaped characters
-                            cleaned_thought = thought.replace('\\"', '"').replace('\\n', ' ')
+                            cleaned_thought = thought.replace('\\"', '"').replace("\\n", " ")
                             await ui.muted(f"💭 REASONING: {cleaned_thought}")
-                    
+
                     # Pattern 4: Text-based reasoning indicators
                     reasoning_indicators = [
-                        (r'I need to (.+?)\.', 'PLANNING'),
-                        (r'Let me (.+?)\.', 'ACTION'),
-                        (r'The output shows (.+?)\.', 'OBSERVATION'),
-                        (r'Based on (.+?), I should (.+?)\.', 'DECISION')
+                        (r"I need to (.+?)\.", "PLANNING"),
+                        (r"Let me (.+?)\.", "ACTION"),
+                        (r"The output shows (.+?)\.", "OBSERVATION"),
+                        (r"Based on (.+?), I should (.+?)\.", "DECISION"),
                     ]
-                    
+
                     for pattern, label in reasoning_indicators:
                         indicator_matches = re.findall(pattern, content, re.IGNORECASE)
                         for match in indicator_matches:
                             if isinstance(match, tuple):
-                                match_text = ' '.join(match)
+                                match_text = " ".join(match)
                             else:
                                 match_text = match
                             await ui.muted(f"🎯 {label}: {match_text}")
                             break  # Only show first match per pattern
-        
+
         # Check for tool calls and fallback to JSON parsing if needed
         has_tool_calls = False
         for part in node.model_response.parts:
@@ -106,28 +115,32 @@ async def _process_node(node, tool_callback: Optional[ToolCallback], state_manag
             elif part.part_kind == "tool-return":
                 obs_msg = f"OBSERVATION[{part.tool_name}]: {part.content[:2_000]}"
                 state_manager.session.messages.append(obs_msg)
-        
+
         # If no structured tool calls found, try parsing JSON from text content
         if not has_tool_calls and tool_callback:
             for part in node.model_response.parts:
-                if hasattr(part, 'content') and isinstance(part.content, str):
+                if hasattr(part, "content") and isinstance(part.content, str):
                     await extract_and_execute_tool_calls(part.content, tool_callback, state_manager)
 
 
 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"]
-        
+
+        # Lazy import Agent and Tool
+        Agent, Tool = get_agent_tool()
+
         # Load system prompt
         import os
         from pathlib import Path
+
         prompt_path = Path(__file__).parent.parent.parent / "prompts" / "system.txt"
         try:
             with open(prompt_path, "r", encoding="utf-8") as f:
                 system_prompt = f.read().strip()
         except FileNotFoundError:
             system_prompt = None
-        
+
         state_manager.session.agents[model] = Agent(
             model=model,
             system_prompt=system_prompt,
@@ -186,6 +199,8 @@ def patch_tool_messages(
     # 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:
+            # Import ModelRequest and ToolReturnPart lazily
+            ModelRequest, ToolReturnPart = get_model_messages()
             messages.append(
                 ModelRequest(
                     parts=[
@@ -202,39 +217,41 @@ def patch_tool_messages(
             )
 
 
-async def parse_json_tool_calls(text: str, tool_callback: Optional[ToolCallback], state_manager: StateManager):
+async def parse_json_tool_calls(
+    text: str, tool_callback: Optional[ToolCallback], state_manager: StateManager
+):
     """
     Parse JSON tool calls from text when structured tool calling fails.
     Fallback for when API providers don't support proper tool calling.
     """
     if not tool_callback:
         return
-    
+
     # Pattern for JSON tool calls: {"tool": "tool_name", "args": {...}}
     # Find potential JSON objects and parse them
     potential_jsons = []
     brace_count = 0
     start_pos = -1
-    
+
     for i, char in enumerate(text):
-        if char == '{':
+        if char == "{":
             if brace_count == 0:
                 start_pos = i
             brace_count += 1
-        elif char == '}':
+        elif char == "}":
             brace_count -= 1
             if brace_count == 0 and start_pos != -1:
-                potential_json = text[start_pos:i+1]
+                potential_json = text[start_pos : i + 1]
                 try:
                     parsed = json.loads(potential_json)
-                    if isinstance(parsed, dict) and 'tool' in parsed and 'args' in parsed:
-                        potential_jsons.append((parsed['tool'], parsed['args']))
+                    if isinstance(parsed, dict) and "tool" in parsed and "args" in parsed:
+                        potential_jsons.append((parsed["tool"], parsed["args"]))
                 except json.JSONDecodeError:
                     pass
                 start_pos = -1
-    
+
     matches = potential_jsons
-    
+
     for tool_name, args in matches:
         try:
             # Create a mock tool call object
@@ -243,66 +260,73 @@ async def parse_json_tool_calls(text: str, tool_callback: Optional[ToolCallback]
                     self.tool_name = tool_name
                     self.args = args
                     self.tool_call_id = f"fallback_{datetime.now().timestamp()}"
-            
+
             class MockNode:
                 pass
-            
+
             # Execute the tool through the callback
             mock_call = MockToolCall(tool_name, args)
             mock_node = MockNode()
-            
+
             await tool_callback(mock_call, mock_node)
-            
+
             if state_manager.session.show_thoughts:
                 from tunacode.ui import console as ui
+
                 await ui.muted(f"🔧 FALLBACK: Executed {tool_name} via JSON parsing")
-                
+
         except Exception as e:
             if state_manager.session.show_thoughts:
                 from tunacode.ui import console as ui
+
                 await ui.error(f"❌ Error executing fallback tool {tool_name}: {str(e)}")
 
 
-async def extract_and_execute_tool_calls(text: str, tool_callback: Optional[ToolCallback], state_manager: StateManager):
+async def extract_and_execute_tool_calls(
+    text: str, tool_callback: Optional[ToolCallback], state_manager: StateManager
+):
     """
     Extract tool calls from text content and execute them.
     Supports multiple formats for maximum compatibility.
     """
     if not tool_callback:
         return
-    
+
     # Format 1: {"tool": "name", "args": {...}}
     await parse_json_tool_calls(text, tool_callback, state_manager)
-    
+
     # Format 2: Tool calls in code blocks
     code_block_pattern = r'```json\s*(\{(?:[^{}]|"[^"]*"|(?:\{[^}]*\}))*"tool"(?:[^{}]|"[^"]*"|(?:\{[^}]*\}))*\})\s*```'
     code_matches = re.findall(code_block_pattern, text, re.MULTILINE | re.DOTALL)
-    
+
     for match in code_matches:
         try:
             tool_data = json.loads(match)
-            if 'tool' in tool_data and 'args' in tool_data:
+            if "tool" in tool_data and "args" in tool_data:
+
                 class MockToolCall:
                     def __init__(self, tool_name: str, args: dict):
                         self.tool_name = tool_name
                         self.args = args
                         self.tool_call_id = f"codeblock_{datetime.now().timestamp()}"
-                
+
                 class MockNode:
                     pass
-                
-                mock_call = MockToolCall(tool_data['tool'], tool_data['args'])
+
+                mock_call = MockToolCall(tool_data["tool"], tool_data["args"])
                 mock_node = MockNode()
-                
+
                 await tool_callback(mock_call, mock_node)
-                
+
                 if state_manager.session.show_thoughts:
                     from tunacode.ui import console as ui
+
                     await ui.muted(f"🔧 FALLBACK: Executed {tool_data['tool']} from code block")
-                    
+
         except (json.JSONDecodeError, KeyError, Exception) as e:
             if state_manager.session.show_thoughts:
                 from tunacode.ui import console as ui
+
                 await ui.error(f"❌ Error parsing code block tool call: {str(e)}")
 
 
@@ -316,22 +340,24 @@ async def process_request(
     mh = state_manager.session.messages.copy()
     # Get max iterations from config (default: 20)
     max_iterations = state_manager.session.user_config.get("settings", {}).get("max_iterations", 20)
-    
+
     async with agent.iter(message, message_history=mh) as agent_run:
         i = 0
         async for node in agent_run:
             await _process_node(node, tool_callback, state_manager)
             i += 1
-            
+
             # Display iteration progress if thoughts are enabled
             if state_manager.session.show_thoughts and i > 1:
                 from tunacode.ui import console as ui
+
                 await ui.muted(f"🔄 Iteration {i}/{max_iterations}")
-            
+
             if i >= max_iterations:
                 if state_manager.session.show_thoughts:
                     from tunacode.ui import console as ui
+
                     await ui.warning(f"⚠️ Reached maximum iterations ({max_iterations})")
                 break
-                
+
         return agent_run

tunacode/core/setup/config_setup.py

@@ -38,9 +38,30 @@ class ConfigSetup(BaseSetup):
         return True
 
     async def execute(self, force_setup: bool = False) -> None:
-        """Setup configuration and run onboarding if needed."""
+        """Setup configuration and run onboarding if needed, with config fingerprint fast path."""
+        import hashlib
+
         self.state_manager.session.device_id = system.get_device_id()
         loaded_config = user_configuration.load_config()
+        # Fast path: if config fingerprint matches last loaded and config is already present, skip reprocessing
+        new_fp = None
+        if loaded_config:
+            b = json.dumps(loaded_config, sort_keys=True).encode()
+            new_fp = hashlib.sha1(b).hexdigest()[:12]
+        last_fp = getattr(self.state_manager, "_config_fingerprint", None)
+        if (
+            loaded_config
+            and not force_setup
+            and new_fp
+            and last_fp == new_fp
+            and getattr(self.state_manager, "_config_valid", False)
+        ):
+            # Fast path: config unchanged, already validated
+            self.state_manager.session.user_config = loaded_config
+            self.state_manager.session.current_model = loaded_config["default_model"]
+            return
+        # Save current config fingerprint for next run
+        self.state_manager._config_fingerprint = new_fp
 
         # Handle CLI configuration if provided
         if self.cli_config and any(self.cli_config.values()):
@@ -50,9 +71,7 @@ class ConfigSetup(BaseSetup):
         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
-            )
+            self.state_manager.session.user_config = self._merge_with_defaults(loaded_config)
         else:
             if force_setup:
                 await ui.muted("Running setup process, resetting config")
@@ -64,13 +83,18 @@ class ConfigSetup(BaseSetup):
             else:
                 # No config found - show CLI usage instead of onboarding
                 from tunacode.ui.console import console
+
                 console.print("\n[bold red]No configuration found![/bold red]")
                 console.print("\n[bold]Quick Setup:[/bold]")
                 console.print("Configure TunaCode using CLI flags:")
                 console.print("\n[blue]Examples:[/blue]")
                 console.print("  [green]tunacode --model 'openai:gpt-4' --key 'your-key'[/green]")
-                console.print("  [green]tunacode --model 'anthropic:claude-3-opus' --key 'your-key'[/green]")
-                console.print("  [green]tunacode --model 'openrouter:anthropic/claude-3.5-sonnet' --key 'your-key' --baseurl 'https://openrouter.ai/api/v1'[/green]")
+                console.print(
+                    "  [green]tunacode --model 'anthropic:claude-3-opus' --key 'your-key'[/green]"
+                )
+                console.print(
+                    "  [green]tunacode --model 'openrouter:anthropic/claude-3.5-sonnet' --key 'your-key' --baseurl 'https://openrouter.ai/api/v1'[/green]"
+                )
                 console.print("\n[yellow]Run 'tunacode --help' for more options[/yellow]\n")
                 raise SystemExit(0)
 
@@ -84,23 +108,24 @@ class ConfigSetup(BaseSetup):
 
         # No model validation - trust user's model choice
 
-        self.state_manager.session.current_model = (
-            self.state_manager.session.user_config["default_model"]
-        )
+        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
+        valid = True
         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
-
-        # No model validation - trust user input
-
-        return True
+            valid = False
+        elif not self.state_manager.session.user_config.get("default_model"):
+            valid = False
+        # Cache result for fastpath
+        if valid:
+            setattr(self.state_manager, "_config_valid", True)
+        else:
+            setattr(self.state_manager, "_config_valid", False)
+        return valid
 
     def _merge_with_defaults(self, loaded_config: UserConfig) -> UserConfig:
         """Merge loaded config with defaults to ensure all required keys exist."""
@@ -119,9 +144,7 @@ class ConfigSetup(BaseSetup):
 
     async def _onboarding(self):
         """Run the onboarding process for new users."""
-        initial_config = json.dumps(
-            self.state_manager.session.user_config, sort_keys=True
-        )
+        initial_config = json.dumps(self.state_manager.session.user_config, sort_keys=True)
 
         await self._step1_api_keys()
 
@@ -134,15 +157,11 @@ class ConfigSetup(BaseSetup):
                 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
-            )
+            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"]
-                    )
+                    await ui.panel("Finished", message, top=0, border_style=UI_COLORS["success"])
                 else:
                     await ui.error("Failed to save configuration.")
         else:
@@ -194,8 +213,10 @@ class ConfigSetup(BaseSetup):
     async def _step2_default_model_simple(self):
         """Simple model selection - just enter model name."""
         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")
-        
+        await ui.muted(
+            "Examples: openai:gpt-4.1, anthropic:claude-3-opus, google-gla:gemini-2.0-flash"
+        )
+
         while True:
             model_name = await ui.input(
                 "step2",
@@ -203,14 +224,14 @@ class ConfigSetup(BaseSetup):
                 state_manager=self.state_manager,
             )
             model_name = model_name.strip()
-            
+
             # 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("You can always change it later with /model")
                 continue
-            
+
             # No validation - user is responsible for correct model names
             self.state_manager.session.user_config["default_model"] = model_name
             await ui.warning("Model set without validation - verify the model name is correct")
@@ -224,26 +245,38 @@ class ConfigSetup(BaseSetup):
             self.state_manager.session.user_config = self._merge_with_defaults(loaded_config)
         else:
             self.state_manager.session.user_config = DEFAULT_USER_CONFIG.copy()
-        
+
         # Apply CLI overrides
         if self.cli_config.get("key"):
             # Determine which API key to set based on the model or baseurl
             if self.cli_config.get("baseurl") and "openrouter" in self.cli_config["baseurl"]:
-                self.state_manager.session.user_config["env"]["OPENROUTER_API_KEY"] = self.cli_config["key"]
+                self.state_manager.session.user_config["env"]["OPENROUTER_API_KEY"] = (
+                    self.cli_config["key"]
+                )
             elif self.cli_config.get("model"):
                 if "claude" in self.cli_config["model"] or "anthropic" in self.cli_config["model"]:
-                    self.state_manager.session.user_config["env"]["ANTHROPIC_API_KEY"] = self.cli_config["key"]
+                    self.state_manager.session.user_config["env"]["ANTHROPIC_API_KEY"] = (
+                        self.cli_config["key"]
+                    )
                 elif "gpt" in self.cli_config["model"] or "openai" in self.cli_config["model"]:
-                    self.state_manager.session.user_config["env"]["OPENAI_API_KEY"] = self.cli_config["key"]
+                    self.state_manager.session.user_config["env"]["OPENAI_API_KEY"] = (
+                        self.cli_config["key"]
+                    )
                 elif "gemini" in self.cli_config["model"]:
-                    self.state_manager.session.user_config["env"]["GEMINI_API_KEY"] = self.cli_config["key"]
+                    self.state_manager.session.user_config["env"]["GEMINI_API_KEY"] = (
+                        self.cli_config["key"]
+                    )
                 else:
                     # Default to OpenRouter for unknown models
-                    self.state_manager.session.user_config["env"]["OPENROUTER_API_KEY"] = self.cli_config["key"]
-        
+                    self.state_manager.session.user_config["env"]["OPENROUTER_API_KEY"] = (
+                        self.cli_config["key"]
+                    )
+
         if self.cli_config.get("baseurl"):
-            self.state_manager.session.user_config["env"]["OPENAI_BASE_URL"] = self.cli_config["baseurl"]
-        
+            self.state_manager.session.user_config["env"]["OPENAI_BASE_URL"] = self.cli_config[
+                "baseurl"
+            ]
+
         if self.cli_config.get("model"):
             model = self.cli_config["model"]
             # Require provider prefix
@@ -253,12 +286,14 @@ class ConfigSetup(BaseSetup):
                     "Format: provider:model-name\n"
                     "Examples: openai:gpt-4.1, anthropic:claude-3-opus"
                 )
-            
+
             self.state_manager.session.user_config["default_model"] = model
-        
+
         # Set current model
-        self.state_manager.session.current_model = self.state_manager.session.user_config["default_model"]
-        
+        self.state_manager.session.current_model = self.state_manager.session.user_config[
+            "default_model"
+        ]
+
         # Save the configuration
         if user_configuration.save_config(self.state_manager):
             await ui.warning("Model set without validation - verify the model name is correct")

tunacode/core/setup/coordinator.py

@@ -23,24 +23,31 @@ class SetupCoordinator:
         self.setup_steps.append(step)
 
     async def run_setup(self, force_setup: bool = False) -> None:
-        """Run all registered setup steps in order."""
+        """Run all registered setup steps concurrently if possible."""
+        # Run should_run checks sequentially (they may depend on order)
+        steps_to_run = []
         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
+                    steps_to_run.append(step)
             except Exception as e:
-                await ui.error(f"Setup failed at step '{step.name}': {str(e)}")
+                await ui.error(
+                    f"Setup failed at step '{getattr(step, 'name', repr(step))}': {str(e)}"
+                )
                 raise
+        # Run all .execute(force_setup) in parallel where possible (independent steps)
+        from asyncio import gather
+
+        try:
+            await gather(*(step.execute(force_setup) for step in steps_to_run))
+            # Now validate all sequentially: if any fail, raise error
+            for step in steps_to_run:
+                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 error: {str(e)}")
+            raise
 
     def clear_steps(self) -> None:
         """Clear all registered setup steps."""