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

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."""

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,30 @@ 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"
+                    border_style="yellow",
                 )
                 return
 
@@ -103,57 +94,52 @@ 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"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(
                     "⚠️  Working Without Safety Branch",
                     "You've chosen to work directly on your current branch.\n"
                     "TunaCode will modify files in place. Make sure you have backups!",
-                    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)
@@ -164,24 +150,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/state.py

@@ -8,15 +8,8 @@ import uuid
 from dataclasses import dataclass, field
 from typing import Any, Optional
 
-from tunacode.types import (
-    DeviceId,
-    InputSessions,
-    MessageHistory,
-    ModelName,
-    SessionId,
-    ToolName,
-    UserConfig,
-)
+from tunacode.types import (DeviceId, InputSessions, MessageHistory, ModelName, SessionId, ToolName,
+                            UserConfig)
 
 
 @dataclass

tunacode/exceptions.py

@@ -77,8 +77,6 @@ class MCPError(ServiceError):
         super().__init__(f"MCP server '{server_name}' error: {message}")
 
 
-
-
 class GitOperationError(ServiceError):
     """Raised when Git operations fail."""