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

tunacode/cli/commands/__init__.py

@@ -29,7 +29,6 @@ from .implementations import (
     ParseToolsCommand,
     RefreshConfigCommand,
     ThoughtsCommand,
-    TodoCommand,
     UpdateCommand,
     YoloCommand,
 )
@@ -63,6 +62,5 @@ __all__ = [
     "UpdateCommand",
     "ModelCommand",
     "InitCommand",
-    "TodoCommand",
     "CommandReloadCommand",
 ]

tunacode/cli/commands/implementations/__init__.py

@@ -20,7 +20,6 @@ from .system import (
     StreamingCommand,
     UpdateCommand,
 )
-from .todo import TodoCommand
 
 __all__ = [
     # System commands
@@ -44,6 +43,4 @@ __all__ = [
     "ModelCommand",
     # Conversation commands
     "CompactCommand",
-    # Todo commands
-    "TodoCommand",
 ]

tunacode/cli/commands/implementations/debug.py

@@ -122,7 +122,7 @@ class FixCommand(SimpleCommand):
     )
 
     async def execute(self, args: List[str], context: CommandContext) -> None:
-        from tunacode.core.agents.main import patch_tool_messages
+        from tunacode.core.agents import patch_tool_messages
 
         # Count current messages
         before_count = len(context.state_manager.session.messages)
@@ -152,7 +152,7 @@ class ParseToolsCommand(SimpleCommand):
     )
 
     async def execute(self, args: List[str], context: CommandContext) -> None:
-        from tunacode.core.agents.main import extract_and_execute_tool_calls
+        from tunacode.core.agents import extract_and_execute_tool_calls
 
         # Find the last model response in messages
         messages = context.state_manager.session.messages

tunacode/cli/commands/implementations/development.py

@@ -49,27 +49,29 @@ class BranchCommand(SimpleCommand):
 
 
 class InitCommand(SimpleCommand):
-    """Creates or updates TUNACODE.md with project-specific context."""
+    """Creates or updates AGENTS.md with project-specific context."""
 
     spec = CommandSpec(
         name="/init",
         aliases=[],
-        description="Analyze codebase and create/update TUNACODE.md file",
+        description="Analyze codebase and create/update AGENTS.md file",
         category=CommandCategory.DEVELOPMENT,
     )
 
     async def execute(self, args, context: CommandContext) -> CommandResult:
         """Execute the init command."""
         # Minimal implementation to make test pass
-        prompt = """Please analyze this codebase and create a TUNACODE.md file containing:
+        prompt = """Please analyze this codebase and create a AGENTS.md file containing:
 1. Build/lint/test commands - especially for running a single test
-2. Code style guidelines including imports, formatting, types, naming conventions, error handling, etc.
+2. Code style guidelines including imports, formatting, types, naming conventions,
+   error handling, etc.
 
-The file you create will be given to agentic coding agents (such as yourself) that operate in this repository.
+The file you create will be given to agentic coding agents (such as yourself)
+that operate in this repository.
 Make it about 20 lines long.
-If there's already a TUNACODE.md, improve it.
-If there are Cursor rules (in .cursor/rules/ or .cursorrules) or Copilot rules (in .github/copilot-instructions.md),
-make sure to include them."""
+If there's already a AGENTS.md, improve it.
+If there are Cursor rules (in .cursor/rules/ or .cursorrules) or Copilot rules
+(in .github/copilot-instructions.md), make sure to include them."""
 
         # Call the agent to analyze and create/update the file
         if context.process_request:

tunacode/cli/commands/implementations/model.py

@@ -1,61 +1,389 @@
 """Model management commands for TunaCode CLI."""
 
-from typing import Optional
+from typing import Dict, List, Optional
 
-from .... import utils
 from ....exceptions import ConfigurationError
 from ....types import CommandArgs, CommandContext
 from ....ui import console as ui
+from ....ui.model_selector import select_model_interactive
+from ....utils import user_configuration
+from ....utils.models_registry import ModelInfo, ModelsRegistry
 from ..base import CommandCategory, CommandSpec, SimpleCommand
 
 
 class ModelCommand(SimpleCommand):
-    """Manage model selection."""
+    """Manage model selection with models.dev integration."""
 
     spec = CommandSpec(
         name="model",
         aliases=["/model"],
-        description="Switch model (e.g., /model gpt-4 or /model openai:gpt-4)",
+        description="Switch model with interactive selection or search",
         category=CommandCategory.MODEL,
     )
 
+    def __init__(self):
+        """Initialize the model command."""
+        super().__init__()
+        self.registry = ModelsRegistry()
+        self._registry_loaded = False
+
+    async def _ensure_registry(self) -> bool:
+        """Ensure the models registry is loaded."""
+        if not self._registry_loaded:
+            self._registry_loaded = await self.registry.load()
+        return self._registry_loaded
+
     async def execute(self, args: CommandArgs, context: CommandContext) -> Optional[str]:
-        # No arguments - show current model
+        # Handle special flags
+        if args and args[0] in ["--list", "-l"]:
+            return await self._list_models()
+
+        if args and args[0] in ["--info", "-i"]:
+            if len(args) < 2:
+                await ui.error("Usage: /model --info <model-id>")
+                return None
+            return await self._show_model_info(args[1])
+
+        # No arguments - show interactive selector
         if not args:
-            current_model = context.state_manager.session.current_model
-            await ui.info(f"Current model: {current_model}")
-            await ui.muted("Usage: /model <provider:model-name> [default]")
-            await ui.muted("Example: /model openai:gpt-4.1")
+            return await self._interactive_select(context)
+
+        # Single argument - could be search query or model ID
+        model_query = args[0]
+
+        # Check for flags
+        if model_query in ["--search", "-s"]:
+            search_query = " ".join(args[1:]) if len(args) > 1 else ""
+            return await self._interactive_select(context, search_query)
+
+        # Direct model specification
+        return await self._set_model(model_query, args[1:], context)
+
+    async def _interactive_select(
+        self, context: CommandContext, initial_query: str = ""
+    ) -> Optional[str]:
+        """Show interactive model selector."""
+        await self._ensure_registry()
+
+        # Show current model
+        current_model = context.state_manager.session.current_model
+        await ui.info(f"Current model: {current_model}")
+
+        # Check if we have models loaded
+        if not self.registry.models:
+            await ui.error("No models available. Try /model --list to see if models can be loaded.")
             return None
 
-        # Get the model name from args
-        model_name = args[0]
+        # For now, use a simple text-based approach instead of complex UI
+        # This avoids prompt_toolkit compatibility issues
+        if initial_query:
+            models = self.registry.search_models(initial_query)
+            if not models:
+                await ui.error(f"No models found matching '{initial_query}'")
+                return None
+        else:
+            # Show popular models for quick selection
+            popular_searches = ["gpt", "claude", "gemini"]
+            await ui.info("Popular model searches:")
+            for search in popular_searches:
+                models = self.registry.search_models(search)[:3]  # Top 3
+                if models:
+                    await ui.info(f"\n{search.upper()} models:")
+                    for model in models:
+                        await ui.muted(f"  • {model.full_id} - {model.name}")
 
-        # 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(
-                "Examples: openai:gpt-4.1, anthropic:claude-3-opus, google-gla:gemini-2.0-flash"
-            )
+            await ui.info("\nUsage:")
+            await ui.muted("  /model <search-term>  - Search for models")
+            await ui.muted("  /model --list         - Show all models")
+            await ui.muted("  /model --info <id>    - Show model details")
+            await ui.muted("  /model <provider:id>  - Set model directly")
+            return None
+
+        # Show search results
+        if len(models) == 1:
+            # Auto-select single result
+            model = models[0]
+            context.state_manager.session.current_model = model.full_id
+            # Persist selection to config by default
+            try:
+                user_configuration.set_default_model(model.full_id, context.state_manager)
+                await ui.success(
+                    f"Switched to model: {model.full_id} - {model.name} (saved as default)"
+                )
+            except ConfigurationError as e:
+                await ui.error(str(e))
+                await ui.warning("Model switched for this session only; failed to save default.")
             return None
 
-        # No validation - user is responsible for correct model names
-        await ui.warning("Model set without validation - verify the model name is correct")
+        # Show multiple results
+        await ui.info(f"Found {len(models)} models:")
+        for i, model in enumerate(models[:10], 1):  # Show top 10
+            details = []
+            if model.cost.input is not None:
+                details.append(f"${model.cost.input}/{model.cost.output}")
+            if model.limits.context:
+                details.append(f"{model.limits.context // 1000}k")
+            detail_str = f" ({', '.join(details)})" if details else ""
 
-        # Set the model
-        context.state_manager.session.current_model = model_name
+            await ui.info(f"{i:2d}. {model.full_id} - {model.name}{detail_str}")
 
-        # Check if setting as default
-        if len(args) > 1 and args[1] == "default":
+        if len(models) > 10:
+            await ui.muted(f"... and {len(models) - 10} more")
+
+        await ui.muted("Use '/model <provider:model-id>' to select a specific model")
+        return None
+
+    async def _set_model(
+        self, model_name: str, extra_args: CommandArgs, context: CommandContext
+    ) -> Optional[str]:
+        """Set model directly or by search."""
+        # Load registry for validation
+        await self._ensure_registry()
+
+        # Check if it's a direct model ID
+        if ":" in model_name:
+            # Validate against registry if loaded
+            if self._registry_loaded:
+                model_info = self.registry.get_model(model_name)
+                if not model_info:
+                    # Search for similar models
+                    similar = self.registry.search_models(model_name.split(":")[-1])
+                    if similar:
+                        await ui.warning(f"Model '{model_name}' not found in registry")
+                        await ui.muted("Did you mean one of these?")
+                        for model in similar[:5]:
+                            await ui.muted(f"  • {model.full_id} - {model.name}")
+                        return None
+                    else:
+                        await ui.warning("Model not found in registry - setting anyway")
+                else:
+                    # Show model info
+                    await ui.info(f"Selected: {model_info.name}")
+                    if model_info.cost.input is not None:
+                        await ui.muted(f"  Pricing: {model_info.cost.format_cost()}")
+                    if model_info.limits.context:
+                        await ui.muted(f"  Limits: {model_info.limits.format_limits()}")
+
+            # Set the model
+            context.state_manager.session.current_model = model_name
+
+            # Check if setting as default (preserve existing behavior)
+            if extra_args and extra_args[0] == "default":
+                try:
+                    user_configuration.set_default_model(model_name, context.state_manager)
+                    await ui.muted("Updating default model")
+                    return "restart"
+                except ConfigurationError as e:
+                    await ui.error(str(e))
+                    return None
+
+            # Persist selection to config by default (auto-persist)
+            try:
+                user_configuration.set_default_model(model_name, context.state_manager)
+                await ui.success(f"Switched to model: {model_name} (saved as default)")
+            except ConfigurationError as e:
+                await ui.error(str(e))
+                await ui.warning("Model switched for this session only; failed to save default.")
+            return None
+
+        # No colon - treat as search query
+        models = self.registry.search_models(model_name)
+
+        if not models:
+            await ui.error(f"No models found matching '{model_name}'")
+            await ui.muted("Try /model --list to see all available models")
+            return None
+
+        if len(models) == 1:
+            # Single match - use it
+            model = models[0]
+            context.state_manager.session.current_model = model.full_id
+            # Persist selection to config by default
             try:
-                utils.user_configuration.set_default_model(model_name, context.state_manager)
-                await ui.muted("Updating default model")
-                return "restart"
+                user_configuration.set_default_model(model.full_id, context.state_manager)
+                await ui.success(
+                    f"Switched to model: {model.full_id} - {model.name} (saved as default)"
+                )
             except ConfigurationError as e:
                 await ui.error(str(e))
+                await ui.warning("Model switched for this session only; failed to save default.")
+            return None
+
+        # Multiple matches - show interactive selector with results
+        await ui.info(f"Found {len(models)} models matching '{model_name}'")
+        selected_model = await select_model_interactive(self.registry, model_name)
+
+        if selected_model:
+            context.state_manager.session.current_model = selected_model
+            # Persist selection to config by default
+            try:
+                user_configuration.set_default_model(selected_model, context.state_manager)
+                await ui.success(f"Switched to model: {selected_model} (saved as default)")
+            except ConfigurationError as e:
+                await ui.error(str(e))
+                await ui.warning("Model switched for this session only; failed to save default.")
+        else:
+            await ui.info("Model selection cancelled")
+
+        return None
+
+    async def _list_models(self) -> Optional[str]:
+        """List all available models."""
+        await self._ensure_registry()
+
+        if not self.registry.models:
+            await ui.error("No models available")
+            return None
+
+        # Group by provider
+        providers: Dict[str, List[ModelInfo]] = {}
+        for model in self.registry.models.values():
+            if model.provider not in providers:
+                providers[model.provider] = []
+            providers[model.provider].append(model)
+
+        # Display models
+        await ui.info(f"Available models ({len(self.registry.models)} total):")
+
+        for provider_id in sorted(providers.keys()):
+            provider_info = self.registry.providers.get(provider_id)
+            provider_name = provider_info.name if provider_info else provider_id
+
+            await ui.print(f"\n{provider_name}:")
+
+            for model in sorted(providers[provider_id], key=lambda m: m.name):
+                line = f"  • {model.id}"
+                if model.cost.input is not None:
+                    line += f" (${model.cost.input}/{model.cost.output})"
+                if model.limits.context:
+                    line += f" [{model.limits.context // 1000}k]"
+                await ui.muted(line)
+
+        return None
+
+    async def _show_model_info(self, model_id: str) -> Optional[str]:
+        """Show detailed information about a model."""
+        await self._ensure_registry()
+
+        model = self.registry.get_model(model_id)
+        if not model:
+            # Try to find similar models or routing options
+            base_name = self.registry._extract_base_model_name(model_id)
+            variants = self.registry.get_model_variants(base_name)
+            if variants:
+                await ui.warning(f"Model '{model_id}' not found directly")
+                await ui.info(f"Found routing options for '{base_name}':")
+
+                # Sort variants by cost (FREE first)
+                sorted_variants = sorted(
+                    variants,
+                    key=lambda m: (
+                        0 if m.cost.input == 0 else 1,  # FREE first
+                        m.cost.input or float("inf"),  # Then by cost
+                        m.provider,  # Then by provider name
+                    ),
+                )
+
+                for variant in sorted_variants:
+                    cost_display = (
+                        "FREE"
+                        if variant.cost.input == 0
+                        else f"${variant.cost.input}/{variant.cost.output}"
+                    )
+                    provider_name = self._get_provider_display_name(variant.provider)
+
+                    await ui.muted(f"  • {variant.full_id} - {provider_name} ({cost_display})")
+
+                await ui.muted(
+                    "\nUse '/model <provider:model-id>' to select a specific routing option"
+                )
                 return None
+            else:
+                await ui.error(f"Model '{model_id}' not found")
+                return None
+
+        # Display model information
+        await ui.info(f"{model.name}")
+        await ui.muted(f"ID: {model.full_id}")
+
+        # Show routing alternatives for this base model
+        base_name = self.registry._extract_base_model_name(model)
+        variants = self.registry.get_model_variants(base_name)
+        if len(variants) > 1:
+            await ui.print("\nRouting Options:")
+
+            # Sort variants by cost (FREE first)
+            sorted_variants = sorted(
+                variants,
+                key=lambda m: (
+                    0 if m.cost.input == 0 else 1,  # FREE first
+                    m.cost.input or float("inf"),  # Then by cost
+                    m.provider,  # Then by provider name
+                ),
+            )
+
+            for variant in sorted_variants:
+                cost_display = (
+                    "FREE"
+                    if variant.cost.input == 0
+                    else f"${variant.cost.input}/{variant.cost.output}"
+                )
+                provider_name = self._get_provider_display_name(variant.provider)
+
+                # Highlight current selection
+                prefix = "→ " if variant.full_id == model.full_id else "  "
+                free_indicator = " ⭐" if variant.cost.input == 0 else ""
+
+                await ui.muted(
+                    f"{prefix}{variant.full_id} - {provider_name} ({cost_display}){free_indicator}"
+                )
+
+        if model.cost.input is not None:
+            await ui.print("\nPricing:")
+            await ui.muted(f"  Input: ${model.cost.input} per 1M tokens")
+            await ui.muted(f"  Output: ${model.cost.output} per 1M tokens")
+
+        if model.limits.context or model.limits.output:
+            await ui.print("\nLimits:")
+            if model.limits.context:
+                await ui.muted(f"  Context: {model.limits.context:,} tokens")
+            if model.limits.output:
+                await ui.muted(f"  Output: {model.limits.output:,} tokens")
+
+        caps = []
+        if model.capabilities.attachment:
+            caps.append("Attachments")
+        if model.capabilities.reasoning:
+            caps.append("Reasoning")
+        if model.capabilities.tool_call:
+            caps.append("Tool calling")
+
+        if caps:
+            await ui.print("\nCapabilities:")
+            for cap in caps:
+                await ui.muted(f"  ✓ {cap}")
+
+        if model.capabilities.knowledge:
+            await ui.print(f"\nKnowledge cutoff: {model.capabilities.knowledge}")
 
-        # Show success message with the new model
-        await ui.success(f"Switched to model: {model_name}")
         return None
+
+    def _get_provider_display_name(self, provider: str) -> str:
+        """Get a user-friendly provider display name."""
+        provider_names = {
+            "openai": "OpenAI Direct",
+            "anthropic": "Anthropic Direct",
+            "google": "Google Direct",
+            "google-gla": "Google Labs",
+            "openrouter": "OpenRouter",
+            "github-models": "GitHub Models (FREE)",
+            "azure": "Azure OpenAI",
+            "fastrouter": "FastRouter",
+            "requesty": "Requesty",
+            "cloudflare-workers-ai": "Cloudflare",
+            "amazon-bedrock": "AWS Bedrock",
+            "chutes": "Chutes AI",
+            "deepinfra": "DeepInfra",
+            "venice": "Venice AI",
+        }
+        return provider_names.get(provider, provider.title())

tunacode/cli/commands/implementations/system.py

@@ -40,7 +40,7 @@ class ClearCommand(SimpleCommand):
 
     async def execute(self, args: List[str], context: CommandContext) -> None:
         # Patch any orphaned tool calls before clearing
-        from tunacode.core.agents.main import patch_tool_messages
+        from tunacode.core.agents import patch_tool_messages
 
         patch_tool_messages("Conversation cleared", context.state_manager)
 
@@ -179,7 +179,8 @@ class UpdateCommand(SimpleCommand):
             await ui.muted("  pip:     pip install --upgrade tunacode-cli")
             await ui.muted("  uv tool: uv tool upgrade tunacode-cli")
             await ui.muted(
-                "  venv:    uv pip install --python ~/.tunacode-venv/bin/python --upgrade tunacode-cli"
+                "  venv:    uv pip install --python ~/.tunacode-venv/bin/python "
+                "--upgrade tunacode-cli"
             )
             return
 

tunacode/cli/commands/implementations/template.py

@@ -121,8 +121,6 @@ class TemplateCommand(SimpleCommand):
         await ui.muted('  "allowed_tools": ["read_file", "grep", "list_dir", "run_command"]')
         await ui.muted("}")
 
-        # TODO: Implement interactive creation when proper input handling is available
-
     async def _clear_template(self, context: CommandContext) -> None:
         """Clear the currently active template."""
         if hasattr(context.state_manager, "tool_handler") and context.state_manager.tool_handler:

tunacode/cli/commands/registry.py

@@ -26,7 +26,6 @@ from .implementations.debug import (
 )
 from .implementations.development import BranchCommand, InitCommand
 from .implementations.model import ModelCommand
-from .implementations.plan import ExitPlanCommand, PlanCommand
 from .implementations.quickstart import QuickStartCommand
 from .implementations.system import (
     ClearCommand,
@@ -36,7 +35,6 @@ from .implementations.system import (
     UpdateCommand,
 )
 from .implementations.template import TemplateCommand
-from .implementations.todo import TodoCommand
 from .template_shortcut import TemplateShortcutCommand
 
 logger = logging.getLogger(__name__)
@@ -153,10 +151,7 @@ class CommandRegistry:
             ModelCommand,
             InitCommand,
             TemplateCommand,
-            TodoCommand,
             CommandReloadCommand,
-            PlanCommand,  # Add plan command
-            ExitPlanCommand,  # Add exit plan command
             QuickStartCommand,  # Add quickstart command
         ]
 
@@ -303,7 +298,7 @@ class CommandRegistry:
 
     def find_matching_commands(self, partial_command: str) -> List[str]:
         """
-        Find all commands that start with the given partial command.
+        Find commands matching the given partial command.
 
         Args:
             partial_command: The partial command to match
@@ -313,7 +308,13 @@ class CommandRegistry:
         """
         self.discover_commands()
         partial = partial_command.lower()
-        return [cmd for cmd in self._commands.keys() if cmd.startswith(partial)]
+
+        # CLAUDE_ANCHOR[key=86cc1a41] Prefix-only command matching after removing fuzzy fallback
+        prefix_matches = [cmd for cmd in self._commands.keys() if cmd.startswith(partial)]
+        if prefix_matches:
+            return prefix_matches
+
+        return []
 
     def is_command(self, text: str) -> bool:
         """Check if text starts with a registered command (supports partial matching)."""

tunacode/cli/commands/slash/loader.py

@@ -74,7 +74,8 @@ class SlashCommandLoader:
                 logger.error(f"Error scanning {directory}: {e}")
 
         logger.info(
-            f"Discovered {len(all_commands)} slash commands from {stats['scanned_dirs']} directories"
+            f"Discovered {len(all_commands)} slash commands from "
+            f"{stats['scanned_dirs']} directories"
         )
         return CommandDiscoveryResult(all_commands, conflicts, errors, stats)
 

tunacode/cli/commands/slash/validator.py

@@ -203,7 +203,8 @@ class CommandValidator:
                         violations.append(
                             SecurityViolation(
                                 type="invalid_subcommand",
-                                message=f"Subcommand '{subcommand}' not allowed for '{base_command}'",
+                                message=f"Subcommand '{subcommand}' not allowed "
+                                f"for '{base_command}'",
                                 command=command,
                                 severity="error",
                             )

tunacode/cli/main.py

@@ -16,6 +16,7 @@ from tunacode.core.tool_handler import ToolHandler
 from tunacode.exceptions import UserAbortError
 from tunacode.setup import setup
 from tunacode.ui import console as ui
+from tunacode.ui.config_dashboard import show_config_dashboard
 from tunacode.utils.system import check_for_updates
 
 app_settings = ApplicationSettings()
@@ -30,6 +31,9 @@ def main(
     wizard: bool = typer.Option(
         False, "--wizard", help="Run interactive setup wizard for guided configuration."
     ),
+    show_config: bool = typer.Option(
+        False, "--show-config", help="Show configuration dashboard and exit."
+    ),
     baseurl: str = typer.Option(
         None, "--baseurl", help="API base URL (e.g., https://openrouter.ai/api/v1)"
     ),
@@ -49,6 +53,11 @@ def main(
             await ui.version()
             return
 
+        if show_config:
+            await ui.banner()
+            show_config_dashboard()
+            return
+
         await ui.banner()
 
         # Start update check in background
@@ -77,7 +86,8 @@ def main(
             from tunacode.exceptions import ConfigurationError
 
             if isinstance(e, ConfigurationError):
-                # ConfigurationError already printed helpful message, just exit cleanly
+                # Display the configuration error message
+                await ui.error(str(e))
                 update_task.cancel()  # Cancel the update check
                 return
             import traceback
@@ -87,6 +97,14 @@ def main(
         has_update, latest_version = await update_task
         if has_update:
             await ui.update_available(latest_version)
+        else:
+            # Normal exit - cleanup MCP servers
+            try:
+                from tunacode.core.agents import cleanup_mcp_servers
+
+                await cleanup_mcp_servers()
+            except Exception:
+                pass  # Best effort cleanup
 
     asyncio.run(async_main())