tunacode-cli 0.0.75__py3-none-any.whl → 0.0.76.1__py3-none-any.whl

tunacode/core/setup/config_setup.py

@@ -11,12 +11,16 @@ 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.setup.config_wizard import ConfigWizard
 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.api_key_validation import validate_api_key_for_model
+from tunacode.utils.api_key_validation import (
+    get_required_api_key_for_model,
+    validate_api_key_for_model,
+)
 from tunacode.utils.text_utils import key_to_title
 
 
@@ -105,14 +109,17 @@ class ConfigSetup(BaseSetup):
                     raise
 
                 if wizard_mode:
-                    await self._wizard_onboarding()
+                    wizard = ConfigWizard(self.state_manager, self.model_registry, self.config_file)
+                    await wizard.run_onboarding()
                 else:
                     await self._onboarding()
             else:
-                # No config found - show CLI usage instead of onboarding
+                # No config found - show CLI usage and continue with safe defaults (no crash)
                 from tunacode.ui.console import console
 
-                console.print("\n[bold red]No configuration found![/bold red]")
+                console.print(
+                    "\n[bold yellow]No configuration found — using safe defaults.[/bold yellow]"
+                )
                 console.print("\n[bold]Quick Setup:[/bold]")
                 console.print("Configure TunaCode using CLI flags:")
                 console.print("\n[blue]Examples:[/blue]")
@@ -127,16 +134,19 @@ class ConfigSetup(BaseSetup):
                 console.print("\n[yellow]Run 'tunacode --help' for more options[/yellow]\n")
                 console.print("\n[cyan]Or use --wizard for guided setup[/cyan]\n")
 
-                raise ConfigurationError(
-                    "No configuration found. Please use CLI flags to configure or --wizard for guided setup."
-                )
+                # Initialize in-memory defaults so we don't crash
+                self.state_manager.session.user_config = DEFAULT_USER_CONFIG.copy()
+                # Mark config as not fully validated for the fast path
+                setattr(self.state_manager, "_config_valid", False)
 
         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."
-                )
+            # Gracefully apply default model instead of crashing
+            self.state_manager.session.user_config["default_model"] = DEFAULT_USER_CONFIG[
+                "default_model"
+            ]
+            await ui.warning(
+                "No default model set in config; applying safe default "
+                f"'{self.state_manager.session.user_config['default_model']}'."
             )
 
         # Validate API key exists for the selected model
@@ -145,10 +155,42 @@ class ConfigSetup(BaseSetup):
             model, self.state_manager.session.user_config
         )
         if not is_valid:
-            raise ConfigurationError(error_msg)
+            # Try to pick a fallback model based on whichever provider has a key configured
+            fallback = self._pick_fallback_model(self.state_manager.session.user_config)
+            if fallback and fallback != model:
+                await ui.warning(
+                    "API key missing for selected model; switching to configured provider: "
+                    f"'{fallback}'."
+                )
+                self.state_manager.session.user_config["default_model"] = fallback
+                model = fallback
+            else:
+                # No suitable fallback; continue without crashing but mark invalid
+                await ui.warning(
+                    (error_msg or "API key missing for model")
+                    + "\nContinuing without provider initialization; run 'tunacode --setup' later."
+                )
+                setattr(self.state_manager, "_config_valid", False)
 
         self.state_manager.session.current_model = model
 
+    def _pick_fallback_model(self, user_config: UserConfig) -> str | None:
+        """Select a reasonable fallback model based on configured API keys."""
+        env = (user_config or {}).get("env", {})
+
+        # Preference order: OpenAI → Anthropic → Google → OpenRouter
+        if env.get("OPENAI_API_KEY", "").strip():
+            return "openai:gpt-4o"
+        if env.get("ANTHROPIC_API_KEY", "").strip():
+            return "anthropic:claude-sonnet-4"
+        if env.get("GEMINI_API_KEY", "").strip():
+            return "google:gemini-2.5-flash"
+        if env.get("OPENROUTER_API_KEY", "").strip():
+            # Use the project default when OpenRouter is configured
+            return DEFAULT_USER_CONFIG.get("default_model", "openrouter:openai/gpt-4.1")
+
+        return None
+
     async def validate(self) -> bool:
         """Validate that configuration is properly set up."""
         # Check that we have a user config
@@ -168,6 +210,18 @@ class ConfigSetup(BaseSetup):
                 # Store error message for later use
                 setattr(self.state_manager, "_config_error", error_msg)
 
+                # Provide actionable guidance for manual setup
+                required_key, provider_name = get_required_api_key_for_model(model)
+                setup_hint = (
+                    f"Missing API key for {provider_name}.\n"
+                    f"Either run 'tunacode --wizard' (recommended) or add it manually to: {self.config_file}\n\n"
+                    "Example snippet (add under 'env'):\n"
+                    '  "env": {\n'
+                    f'    "{required_key or "PROVIDER_API_KEY"}": "your-key-here"\n'
+                    "  }\n"
+                )
+                await ui.error(setup_hint)
+
         # Cache result for fastpath
         if valid:
             setattr(self.state_manager, "_config_valid", True)
@@ -373,214 +427,3 @@ class ConfigSetup(BaseSetup):
             await ui.success(f"Configuration saved to: {self.config_file}")
         except ConfigurationError as e:
             await ui.error(str(e))
-
-    async def _wizard_onboarding(self):
-        """Run enhanced wizard-style onboarding process for new users."""
-        initial_config = json.dumps(self.state_manager.session.user_config, sort_keys=True)
-
-        # Welcome message with provider guidance
-        await ui.panel(
-            "Welcome to TunaCode Setup Wizard!",
-            "This guided setup will help you configure TunaCode in under 5 minutes.\n"
-            "We'll help you choose a provider, set up your API keys, and configure your preferred model.",
-            border_style=UI_COLORS["primary"],
-        )
-
-        # Step 1: Provider selection with detailed guidance
-        await self._wizard_step1_provider_selection()
-
-        # Step 2: API key setup with provider-specific guidance
-        await self._wizard_step2_api_key_setup()
-
-        # Step 3: Model selection with smart recommendations
-        await self._wizard_step3_model_selection()
-
-        # Step 4: Optional settings configuration
-        await self._wizard_step4_optional_settings()
-
-        # Save configuration and finish
-        current_config = json.dumps(self.state_manager.session.user_config, sort_keys=True)
-        if initial_config != current_config:
-            try:
-                user_configuration.save_config(self.state_manager)
-                await ui.panel(
-                    "Setup Complete!",
-                    f"Configuration saved to: [bold]{self.config_file}[/bold]\n\n"
-                    "You're ready to start using TunaCode!\n"
-                    "Use [green]/quickstart[/green] anytime for a tutorial.",
-                    border_style=UI_COLORS["success"],
-                )
-            except ConfigurationError as e:
-                await ui.error(str(e))
-
-    async def _wizard_step1_provider_selection(self):
-        """Wizard step 1: Provider selection with detailed explanations."""
-        provider_info = {
-            "1": {
-                "name": "OpenRouter",
-                "description": "Access to multiple models (GPT-4, Claude, Gemini, etc.)",
-                "signup": "https://openrouter.ai/",
-                "key_name": "OPENROUTER_API_KEY",
-            },
-            "2": {
-                "name": "OpenAI",
-                "description": "GPT-4 models",
-                "signup": "https://platform.openai.com/signup",
-                "key_name": "OPENAI_API_KEY",
-            },
-            "3": {
-                "name": "Anthropic",
-                "description": "Claude-3 models",
-                "signup": "https://console.anthropic.com/",
-                "key_name": "ANTHROPIC_API_KEY",
-            },
-            "4": {
-                "name": "Google",
-                "description": "Gemini models",
-                "signup": "https://ai.google.dev/",
-                "key_name": "GEMINI_API_KEY",
-            },
-        }
-
-        message = "Choose your AI provider:\n\n"
-        for key, info in provider_info.items():
-            message += f"  {key} - {info['name']}: {info['description']}\n"
-
-        await ui.panel("Provider Selection", message, border_style=UI_COLORS["primary"])
-
-        while True:
-            choice = await ui.input(
-                "wizard_provider",
-                pretext="  Choose provider (1-4): ",
-                state_manager=self.state_manager,
-            )
-
-            if choice.strip() in provider_info:
-                selected = provider_info[choice.strip()]
-                self._wizard_selected_provider = selected
-
-                await ui.success(f"Selected: {selected['name']}")
-                await ui.info(f"Sign up at: {selected['signup']}")
-                break
-            else:
-                await ui.error("Please enter 1, 2, 3, or 4")
-
-    async def _wizard_step2_api_key_setup(self):
-        """Wizard step 2: API key setup with provider-specific guidance."""
-        provider = self._wizard_selected_provider
-
-        message = f"Enter your {provider['name']} API key:\n\n"
-        message += f"Get your key from: {provider['signup']}\n"
-        message += "Your key will be stored securely in your local config"
-
-        await ui.panel(f"{provider['name']} API Key", message, border_style=UI_COLORS["primary"])
-
-        while True:
-            api_key = await ui.input(
-                "wizard_api_key",
-                pretext=f"  {provider['name']} API Key: ",
-                is_password=True,
-                state_manager=self.state_manager,
-            )
-
-            if api_key.strip():
-                # Ensure env dict exists
-                if "env" not in self.state_manager.session.user_config:
-                    self.state_manager.session.user_config["env"] = {}
-
-                self.state_manager.session.user_config["env"][provider["key_name"]] = (
-                    api_key.strip()
-                )
-                await ui.success("API key saved successfully!")
-                break
-            else:
-                await ui.error("API key cannot be empty")
-
-    async def _wizard_step3_model_selection(self):
-        """Wizard step 3: Model selection with smart recommendations."""
-        provider = self._wizard_selected_provider
-
-        # Provide smart recommendations based on provider
-        recommendations = {
-            "OpenAI": [
-                ("openai:gpt-4o", "GPT-4o flagship multimodal model (recommended)"),
-                ("openai:gpt-4.1", "Latest GPT-4.1 with enhanced coding"),
-                ("openai:o3", "Advanced reasoning model for complex tasks"),
-            ],
-            "Anthropic": [
-                ("anthropic:claude-sonnet-4", "Claude Sonnet 4 latest generation (recommended)"),
-                ("anthropic:claude-opus-4.1", "Most capable Claude with extended thinking"),
-                ("anthropic:claude-3.5-sonnet", "Claude 3.5 Sonnet proven performance"),
-            ],
-            "OpenRouter": [
-                (
-                    "openrouter:anthropic/claude-sonnet-4",
-                    "Claude Sonnet 4 via OpenRouter (recommended)",
-                ),
-                ("openrouter:openai/gpt-4.1", "GPT-4.1 via OpenRouter"),
-                ("openrouter:google/gemini-2.5-flash", "Google Gemini 2.5 Flash latest"),
-            ],
-            "Google": [
-                (
-                    "google:gemini-2.5-pro",
-                    "Gemini 2.5 Pro with thinking capabilities (recommended)",
-                ),
-                ("google:gemini-2.5-flash", "Gemini 2.5 Flash best price-performance"),
-                ("google:gemini-2.0-flash", "Gemini 2.0 Flash with native tool use"),
-            ],
-        }
-
-        models = recommendations.get(provider["name"], [])
-        message = f"Choose your default {provider['name']} model:\n\n"
-
-        for i, (model_id, description) in enumerate(models, 1):
-            message += f"  {i} - {description}\n"
-
-        message += "\nYou can change this later with [green]/model[/green]"
-
-        await ui.panel("Model Selection", message, border_style=UI_COLORS["primary"])
-
-        while True:
-            choice = await ui.input(
-                "wizard_model",
-                pretext=f"  Choose model (1-{len(models)}): ",
-                state_manager=self.state_manager,
-            )
-
-            try:
-                index = int(choice.strip()) - 1
-                if 0 <= index < len(models):
-                    selected_model = models[index][0]
-                    self.state_manager.session.user_config["default_model"] = selected_model
-                    await ui.success(f"Selected: {selected_model}")
-                    break
-                else:
-                    await ui.error(f"Please enter a number between 1 and {len(models)}")
-            except ValueError:
-                await ui.error("Please enter a valid number")
-
-    async def _wizard_step4_optional_settings(self):
-        """Wizard step 4: Optional settings configuration."""
-        message = "Configure optional settings:\n\n"
-        message += "• Tutorial: Enable interactive tutorial for new users\n"
-        message += "\nSkip this step to use recommended defaults"
-
-        await ui.panel("Optional Settings", message, border_style=UI_COLORS["primary"])
-
-        # Ask about tutorial
-        tutorial_choice = await ui.input(
-            "wizard_tutorial",
-            pretext="  Enable tutorial for new users? [Y/n]: ",
-            state_manager=self.state_manager,
-        )
-
-        enable_tutorial = tutorial_choice.strip().lower() not in ["n", "no", "false"]
-
-        if "settings" not in self.state_manager.session.user_config:
-            self.state_manager.session.user_config["settings"] = {}
-
-        self.state_manager.session.user_config["settings"]["enable_tutorial"] = enable_tutorial
-
-        # Streaming is always enabled - no user choice needed
-
-        await ui.info("Optional settings configured!")

tunacode/core/setup/config_wizard.py

@@ -0,0 +1,229 @@
+"""Module: tunacode.core.setup.config_wizard
+
+Wizard-style onboarding helpers extracted from ConfigSetup to reduce file size
+and keep responsibilities focused.
+"""
+
+import json
+from pathlib import Path
+from typing import Dict, Optional
+
+from tunacode.constants import UI_COLORS
+from tunacode.exceptions import ConfigurationError
+from tunacode.ui import console as ui
+from tunacode.utils import user_configuration
+
+
+class ConfigWizard:
+    """Encapsulates the interactive configuration wizard flow."""
+
+    def __init__(self, state_manager, model_registry, config_file: Path):
+        self.state_manager = state_manager
+        self.model_registry = model_registry
+        self.config_file = config_file
+        self._wizard_selected_provider: Optional[Dict[str, str]] = None
+
+    async def run_onboarding(self) -> None:
+        """Run enhanced wizard-style onboarding process for new users."""
+        initial_config = json.dumps(self.state_manager.session.user_config, sort_keys=True)
+
+        # Welcome message with provider guidance
+        await ui.panel(
+            "Welcome to TunaCode Setup Wizard!",
+            "This guided setup will help you configure TunaCode in under 5 minutes.\n"
+            "We'll help you choose a provider, set up your API keys, and configure your preferred model.",
+            border_style=UI_COLORS["primary"],
+        )
+
+        # Steps
+        await self._step1_provider_selection()
+        await self._step2_api_key_setup()
+        await self._step3_model_selection()
+        await self._step4_optional_settings()
+
+        # Save configuration and finish
+        current_config = json.dumps(self.state_manager.session.user_config, sort_keys=True)
+        if initial_config != current_config:
+            try:
+                user_configuration.save_config(self.state_manager)
+                await ui.panel(
+                    "Setup Complete!",
+                    f"Configuration saved to: [bold]{self.config_file}[/bold]\n\n"
+                    "You're ready to start using TunaCode!\n"
+                    "Use [green]/quickstart[/green] anytime for a tutorial.",
+                    border_style=UI_COLORS["success"],
+                )
+            except ConfigurationError as e:
+                await ui.error(str(e))
+
+    async def _step1_provider_selection(self) -> None:
+        """Wizard step 1: Provider selection with detailed explanations."""
+        provider_info = {
+            "1": {
+                "name": "OpenRouter",
+                "description": "Access to multiple models (GPT-4, Claude, Gemini, etc.)",
+                "signup": "https://openrouter.ai/",
+                "key_name": "OPENROUTER_API_KEY",
+            },
+            "2": {
+                "name": "OpenAI",
+                "description": "GPT-4 models",
+                "signup": "https://platform.openai.com/signup",
+                "key_name": "OPENAI_API_KEY",
+            },
+            "3": {
+                "name": "Anthropic",
+                "description": "Claude-3 models",
+                "signup": "https://console.anthropic.com/",
+                "key_name": "ANTHROPIC_API_KEY",
+            },
+            "4": {
+                "name": "Google",
+                "description": "Gemini models",
+                "signup": "https://ai.google.dev/",
+                "key_name": "GEMINI_API_KEY",
+            },
+        }
+
+        message = "Choose your AI provider:\n\n"
+        for key, info in provider_info.items():
+            message += f"  {key} - {info['name']}: {info['description']}\n"
+
+        await ui.panel("Provider Selection", message, border_style=UI_COLORS["primary"])
+
+        while True:
+            choice = await ui.input(
+                "wizard_provider",
+                pretext="  Choose provider (1-4): ",
+                state_manager=self.state_manager,
+            )
+
+            if choice.strip() in provider_info:
+                selected = provider_info[choice.strip()]
+                self._wizard_selected_provider = selected
+
+                await ui.success(f"Selected: {selected['name']}")
+                await ui.info(f"Sign up at: {selected['signup']}")
+                break
+            else:
+                await ui.error("Please enter 1, 2, 3, or 4")
+
+    async def _step2_api_key_setup(self) -> None:
+        """Wizard step 2: API key setup with provider-specific guidance."""
+        provider = self._wizard_selected_provider
+
+        message = f"Enter your {provider['name']} API key:\n\n"
+        message += f"Get your key from: {provider['signup']}\n"
+        message += "Your key will be stored securely in your local config"
+
+        await ui.panel(f"{provider['name']} API Key", message, border_style=UI_COLORS["primary"])
+
+        while True:
+            api_key = await ui.input(
+                "wizard_api_key",
+                pretext=f"  {provider['name']} API Key: ",
+                is_password=True,
+                state_manager=self.state_manager,
+            )
+
+            if api_key.strip():
+                # Ensure env dict exists
+                if "env" not in self.state_manager.session.user_config:
+                    self.state_manager.session.user_config["env"] = {}
+
+                self.state_manager.session.user_config["env"][provider["key_name"]] = (
+                    api_key.strip()
+                )
+                await ui.success("API key saved successfully!")
+                break
+            else:
+                await ui.error("API key cannot be empty")
+
+    async def _step3_model_selection(self) -> None:
+        """Wizard step 3: Model selection with smart recommendations."""
+        provider = self._wizard_selected_provider
+
+        # Provide smart recommendations based on provider
+        recommendations = {
+            "OpenAI": [
+                ("openai:gpt-4o", "GPT-4o flagship multimodal model (recommended)"),
+                ("openai:gpt-4.1", "Latest GPT-4.1 with enhanced coding"),
+                ("openai:o3", "Advanced reasoning model for complex tasks"),
+            ],
+            "Anthropic": [
+                ("anthropic:claude-sonnet-4", "Claude Sonnet 4 latest generation (recommended)"),
+                ("anthropic:claude-opus-4.1", "Most capable Claude with extended thinking"),
+                ("anthropic:claude-3.5-sonnet", "Claude 3.5 Sonnet proven performance"),
+            ],
+            "OpenRouter": [
+                (
+                    "openrouter:anthropic/claude-sonnet-4",
+                    "Claude Sonnet 4 via OpenRouter (recommended)",
+                ),
+                ("openrouter:openai/gpt-4.1", "GPT-4.1 via OpenRouter"),
+                ("openrouter:google/gemini-2.5-flash", "Google Gemini 2.5 Flash latest"),
+            ],
+            "Google": [
+                (
+                    "google:gemini-2.5-pro",
+                    "Gemini 2.5 Pro with thinking capabilities (recommended)",
+                ),
+                ("google:gemini-2.5-flash", "Gemini 2.5 Flash best price-performance"),
+                ("google:gemini-2.0-flash", "Gemini 2.0 Flash with native tool use"),
+            ],
+        }
+
+        models = recommendations.get(provider["name"], [])
+        message = f"Choose your default {provider['name']} model:\n\n"
+
+        for i, (model_id, description) in enumerate(models, 1):
+            message += f"  {i} - {description}\n"
+
+        message += "\nYou can change this later with [green]/model[/green]"
+
+        await ui.panel("Model Selection", message, border_style=UI_COLORS["primary"])
+
+        while True:
+            choice = await ui.input(
+                "wizard_model",
+                pretext=f"  Choose model (1-{len(models)}): ",
+                state_manager=self.state_manager,
+            )
+
+            try:
+                index = int(choice.strip()) - 1
+                if 0 <= index < len(models):
+                    selected_model = models[index][0]
+                    self.state_manager.session.user_config["default_model"] = selected_model
+                    await ui.success(f"Selected: {selected_model}")
+                    break
+                else:
+                    await ui.error(f"Please enter a number between 1 and {len(models)}")
+            except ValueError:
+                await ui.error("Please enter a valid number")
+
+    async def _step4_optional_settings(self) -> None:
+        """Wizard step 4: Optional settings configuration."""
+        message = "Configure optional settings:\n\n"
+        message += "• Tutorial: Enable interactive tutorial for new users\n"
+        message += "\nSkip this step to use recommended defaults"
+
+        await ui.panel("Optional Settings", message, border_style=UI_COLORS["primary"])
+
+        # Ask about tutorial
+        tutorial_choice = await ui.input(
+            "wizard_tutorial",
+            pretext="  Enable tutorial for new users? [Y/n]: ",
+            state_manager=self.state_manager,
+        )
+
+        enable_tutorial = tutorial_choice.strip().lower() not in ["n", "no", "false"]
+
+        if "settings" not in self.state_manager.session.user_config:
+            self.state_manager.session.user_config["settings"] = {}
+
+        self.state_manager.session.user_config["settings"]["enable_tutorial"] = enable_tutorial
+
+        # Streaming is always enabled - no user choice needed
+
+        await ui.info("Optional settings configured!")

tunacode/core/state.py

@@ -10,6 +10,7 @@ import uuid
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any, Optional
 
+from tunacode.configuration.defaults import DEFAULT_USER_CONFIG
 from tunacode.types import (
     DeviceId,
     InputSessions,
@@ -39,7 +40,8 @@ class SessionState:
     )  # Keep as dict[str, Any] for agent instances
     messages: MessageHistory = field(default_factory=list)
     total_cost: float = 0.0
-    current_model: ModelName = "openai:gpt-4o"
+    # Keep session default in sync with configuration default
+    current_model: ModelName = DEFAULT_USER_CONFIG["default_model"]
     spinner: Optional[Any] = None
     tool_ignore: list[ToolName] = field(default_factory=list)
     yolo: bool = False