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

tunacode/cli/commands/__init__.py

@@ -18,6 +18,7 @@ from .base import Command, CommandCategory, CommandSpec, SimpleCommand
 from .implementations import (
     BranchCommand,
     ClearCommand,
+    CommandReloadCommand,
     CompactCommand,
     DumpCommand,
     FixCommand,
@@ -28,7 +29,6 @@ from .implementations import (
     ParseToolsCommand,
     RefreshConfigCommand,
     ThoughtsCommand,
-    TodoCommand,
     UpdateCommand,
     YoloCommand,
 )
@@ -62,5 +62,5 @@ __all__ = [
     "UpdateCommand",
     "ModelCommand",
     "InitCommand",
-    "TodoCommand",
+    "CommandReloadCommand",
 ]

tunacode/cli/commands/implementations/__init__.py

@@ -1,6 +1,7 @@
 """Command implementations for TunaCode CLI."""
 
 # Import all command classes for easy access
+from .command_reload import CommandReloadCommand
 from .conversation import CompactCommand
 from .debug import (
     DumpCommand,
@@ -19,7 +20,6 @@ from .system import (
     StreamingCommand,
     UpdateCommand,
 )
-from .todo import TodoCommand
 
 __all__ = [
     # System commands
@@ -28,6 +28,7 @@ __all__ = [
     "RefreshConfigCommand",
     "StreamingCommand",
     "UpdateCommand",
+    "CommandReloadCommand",
     # Debug commands
     "YoloCommand",
     "DumpCommand",
@@ -42,6 +43,4 @@ __all__ = [
     "ModelCommand",
     # Conversation commands
     "CompactCommand",
-    # Todo commands
-    "TodoCommand",
 ]

tunacode/cli/commands/implementations/command_reload.py

@@ -0,0 +1,48 @@
+"""Command reload implementation."""
+
+from pathlib import Path
+from typing import List
+
+from ....types import CommandContext
+from ....ui import console as ui
+from ..base import CommandCategory, CommandSpec, SimpleCommand
+
+
+class CommandReloadCommand(SimpleCommand):
+    """Reload slash commands to discover new commands."""
+
+    spec = CommandSpec(
+        name="command-reload",
+        aliases=["/command-reload"],
+        description="Reload slash commands to discover newly added commands",
+        category=CommandCategory.DEVELOPMENT,
+    )
+
+    def __init__(self, command_registry=None):
+        self._command_registry = command_registry
+
+    async def execute(self, args: List[str], context: CommandContext) -> None:
+        # Check if any command directories exist
+        command_dirs = [
+            Path(".tunacode/commands"),
+            Path(".claude/commands"),
+            Path.home() / ".tunacode/commands",
+            Path.home() / ".claude/commands",
+        ]
+
+        dirs_exist = any(cmd_dir.exists() for cmd_dir in command_dirs)
+
+        if not dirs_exist:
+            await ui.info("No commands directory found")
+            return
+
+        # Reload commands using registry
+        if self._command_registry:
+            try:
+                self._command_registry.reload_slash_commands()
+                await ui.success("Commands reloaded")
+                return
+            except Exception as e:
+                await ui.error(f"Reload failed: {e}")
+        else:
+            await ui.error("Command registry not available")

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/quickstart.py

@@ -0,0 +1,43 @@
+"""
+Module: tunacode.cli.commands.implementations.quickstart
+
+QuickStart command implementation for interactive tutorial system.
+Provides guided introduction to TunaCode for new users.
+"""
+
+import logging
+
+from tunacode.types import CommandContext, CommandResult
+
+from ..base import CommandCategory, CommandSpec, SimpleCommand
+
+logger = logging.getLogger(__name__)
+
+
+class QuickStartCommand(SimpleCommand):
+    """Interactive quickstart tutorial command."""
+
+    spec = CommandSpec(
+        name="quickstart",
+        aliases=["/quickstart", "/qs"],
+        description="Interactive tutorial for getting started with TunaCode",
+        category=CommandCategory.SYSTEM,
+    )
+
+    async def execute(self, _args: list[str], context: CommandContext) -> CommandResult:
+        """Execute the quickstart tutorial."""
+        try:
+            from ....tutorial import TutorialManager
+        except ImportError:
+            await context.ui.error("Tutorial system is not available")
+            return
+
+        tutorial_manager = TutorialManager(context.state_manager)
+
+        # Always run tutorial when explicitly requested
+        success = await tutorial_manager.run_tutorial()
+
+        if success:
+            await context.ui.success("✅ Tutorial completed successfully!")
+        else:
+            await context.ui.info("Tutorial was cancelled or interrupted")