tunacode-cli 0.0.70__py3-none-any.whl → 0.0.78.6__py3-none-any.whl

tunacode/core/agents/utils.py

@@ -3,9 +3,8 @@ import importlib
 import json
 import logging
 import os
-import re
 from collections.abc import Iterator
-from datetime import datetime, timezone
+from datetime import datetime
 from typing import Any
 
 from tunacode.constants import (
@@ -14,13 +13,12 @@ from tunacode.constants import (
     JSON_PARSE_MAX_RETRIES,
     READ_ONLY_TOOLS,
 )
+
+# Re-export tool parsing functions from agent_components for backward compatibility
 from tunacode.exceptions import ToolBatchingJSONError
 from tunacode.types import (
-    ErrorMessage,
     StateManager,
     ToolCallback,
-    ToolCallId,
-    ToolName,
 )
 from tunacode.ui import console as ui
 from tunacode.utils.retry import retry_json_parse_async
@@ -271,123 +269,32 @@ async def parse_json_tool_calls(
 
 async def extract_and_execute_tool_calls(
     text: str, tool_callback: ToolCallback | None, state_manager: StateManager
-):
-    """Extract tool calls from text content and execute them.
-    Supports multiple formats for maximum compatibility.
+) -> int:
     """
-    if not tool_callback:
-        return
-
-    # 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)
-    remaining_text = re.sub(code_block_pattern, "", text)
-
-    for match in code_matches:
-        try:
-            # Use retry logic for JSON parsing in code blocks
-            tool_data = await retry_json_parse_async(
-                match,
-                max_retries=JSON_PARSE_MAX_RETRIES,
-                base_delay=JSON_PARSE_BASE_DELAY,
-                max_delay=JSON_PARSE_MAX_DELAY,
-            )
-            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_node = MockNode()
-
-                await tool_callback(mock_call, mock_node)
-
-                if state_manager.session.show_thoughts:
-                    await ui.muted(f"FALLBACK: Executed {tool_data['tool']} from code block")
-
-        except json.JSONDecodeError as e:
-            # After all retries failed
-            logger.error(
-                f"Code block JSON parsing failed after {JSON_PARSE_MAX_RETRIES} retries: {e}"
-            )
-            if state_manager.session.show_thoughts:
-                await ui.error(
-                    f"Failed to parse code block tool JSON after {JSON_PARSE_MAX_RETRIES} retries"
-                )
-            # Raise custom exception for better error handling
-            raise ToolBatchingJSONError(
-                json_content=match,
-                retry_count=JSON_PARSE_MAX_RETRIES,
-                original_error=e,
-            ) from e
-        except (KeyError, Exception) as e:
-            if state_manager.session.show_thoughts:
-                await ui.error(f"Error parsing code block tool call: {e!s}")
-
-    # Format 1: {"tool": "name", "args": {...}}
-    await parse_json_tool_calls(remaining_text, tool_callback, state_manager)
-
-
-def patch_tool_messages(
-    error_message: ErrorMessage = "Tool operation failed",
-    state_manager: StateManager = None,
-):
-    """Find any tool calls without responses and add synthetic error responses for them.
-    Takes an error message to use in the synthesized tool response.
+    Extract tool calls from text content and execute them.
+    Supports multiple formats for maximum compatibility.
+    Uses the enhanced parse_json_tool_calls with retry logic.
 
-    Ignores tools that have corresponding retry prompts as the model is already
-    addressing them.
+    Returns:
+        int: Number of tools successfully executed
     """
-    if state_manager is None:
-        raise ValueError("state_manager is required for patch_tool_messages")
-
-    messages = state_manager.session.messages
-
-    if not messages:
-        return
-
-    # Map tool calls to their tool returns
-    tool_calls: dict[ToolCallId, ToolName] = {}  # tool_call_id -> tool_name
-    tool_returns: set[ToolCallId] = set()  # set of tool_call_ids with returns
-    retry_prompts: set[ToolCallId] = set()  # set of tool_call_ids with retry prompts
-
-    for message in messages:
-        if hasattr(message, "parts"):
-            for part in message.parts:
-                if (
-                    hasattr(part, "part_kind")
-                    and hasattr(part, "tool_call_id")
-                    and part.tool_call_id
-                ):
-                    if part.part_kind == "tool-call":
-                        tool_calls[part.tool_call_id] = part.tool_name
-                    elif part.part_kind == "tool-return":
-                        tool_returns.add(part.tool_call_id)
-                    elif part.part_kind == "retry-prompt":
-                        retry_prompts.add(part.tool_call_id)
-
-    # Identify orphaned tools (those without responses and not being retried)
-    for tool_call_id, tool_name in list(tool_calls.items()):
-        if tool_call_id not in tool_returns and tool_call_id not in retry_prompts:
-            # Import ModelRequest and ToolReturnPart lazily
-            model_request_cls, tool_return_part_cls, _ = get_model_messages()
-            messages.append(
-                model_request_cls(
-                    parts=[
-                        tool_return_part_cls(
-                            tool_name=tool_name,
-                            content=error_message,
-                            tool_call_id=tool_call_id,
-                            timestamp=datetime.now(timezone.utc),
-                            part_kind="tool-return",
-                        )
-                    ],
-                    kind="request",
-                )
-            )
+    if not tool_callback:
+        return 0
+
+    tools_executed = 0
+
+    # Use the enhanced parse_json_tool_calls with retry logic
+    # We need to handle this differently since our parse_json_tool_calls doesn't return a count
+    try:
+        await parse_json_tool_calls(text, tool_callback, state_manager)
+        # If we get here without error, at least one tool was likely executed
+        # For simplicity, we'll assume 1 tool was executed if no error occurred
+        tools_executed = 1
+    except ToolBatchingJSONError:
+        # Re-raise the error for proper test handling
+        raise
+    except Exception:
+        # Other exceptions mean 0 tools executed
+        tools_executed = 0
+
+    return tools_executed

tunacode/core/setup/__init__.py

@@ -3,7 +3,6 @@ from .base import BaseSetup
 from .config_setup import ConfigSetup
 from .coordinator import SetupCoordinator
 from .environment_setup import EnvironmentSetup
-from .git_safety_setup import GitSafetySetup
 from .template_setup import TemplateSetup
 
 __all__ = [
@@ -11,7 +10,6 @@ __all__ = [
     "SetupCoordinator",
     "ConfigSetup",
     "EnvironmentSetup",
-    "GitSafetySetup",
     "AgentSetup",
     "TemplateSetup",
 ]

tunacode/core/setup/config_setup.py

@@ -11,11 +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 (
+    get_required_api_key_for_model,
+    validate_api_key_for_model,
+)
 from tunacode.utils.text_utils import key_to_title
 
 
@@ -51,7 +56,8 @@ class ConfigSetup(BaseSetup):
         # Initialize first-time user settings if needed
         user_configuration.initialize_first_time_user(self.state_manager)
 
-        # Fast path: if config fingerprint matches last loaded and config is already present, skip reprocessing
+        # 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()
@@ -104,14 +110,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]")
@@ -126,23 +135,62 @@ 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']}'."
             )
 
-        # No model validation - trust user's model choice
+        # Validate API key exists for the selected model
+        model = self.state_manager.session.user_config["default_model"]
+        is_valid, error_msg = validate_api_key_for_model(
+            model, self.state_manager.session.user_config
+        )
+        if not is_valid:
+            # 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 = self.state_manager.session.user_config[
-            "default_model"
-        ]
+        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."""
@@ -152,6 +200,30 @@ class ConfigSetup(BaseSetup):
             valid = False
         elif not self.state_manager.session.user_config.get("default_model"):
             valid = False
+        else:
+            # Validate API key exists for the selected model
+            model = self.state_manager.session.user_config.get("default_model")
+            is_valid, error_msg = validate_api_key_for_model(
+                model, self.state_manager.session.user_config
+            )
+            if not is_valid:
+                valid = False
+                # 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: "
+                    f"{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)
@@ -357,214 +429,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!")