tunacode-cli 0.0.4__py3-none-any.whl → 0.0.6__py3-none-any.whl

tunacode/cli/commands.py

@@ -6,7 +6,6 @@ from enum import Enum
 from typing import Any, Dict, List, Optional, Type
 
 from .. import utils
-from ..configuration.models import ModelRegistry
 from ..exceptions import ValidationError
 from ..services.undo_service import perform_undo
 from ..types import CommandArgs, CommandContext, CommandResult, ProcessRequestCallback
@@ -260,7 +259,6 @@ class UndoCommand(SimpleCommand):
                 await ui.muted("   • File operations will still work, but can't be undone")
 
 
-
 class BranchCommand(SimpleCommand):
     """Create and switch to a new git branch."""
 
@@ -388,46 +386,106 @@ class ModelCommand(SimpleCommand):
         super().__init__(
             CommandSpec(
                 name="model",
-                aliases=["/model"],
-                description="List models or select a model (e.g., /model 3 or /model 3 default)",
+                aliases=["/model", "/m"],
+                description="List and select AI models interactively",
                 category=CommandCategory.MODEL,
             )
         )
 
     async def execute(self, args: CommandArgs, context: CommandContext) -> Optional[str]:
+        from tunacode.cli.model_selector import ModelSelector
+
+        selector = ModelSelector()
+
         if not args:
-            # No arguments - list models
-            await ui.models(context.state_manager)
+            # No arguments - show enhanced model list
+            await self._show_model_list(selector, context.state_manager)
             return None
 
-        # Parse model index
-        try:
-            model_index = int(args[0])
-        except ValueError:
-            await ui.error(f"Invalid model index: {args[0]}")
-            return None
+        # Find model by query (index, name, or fuzzy match)
+        query = args[0]
+        model_info = selector.find_model(query)
 
-        # Get model list
-        model_registry = ModelRegistry()
-        models = list(model_registry.list_models().keys())
-        if model_index < 0 or model_index >= len(models):
-            await ui.error(f"Model index {model_index} out of range")
+        if not model_info:
+            # Try to provide helpful suggestions
+            await ui.error(f"Model '{query}' not found")
+            await ui.muted(
+                "Try: /model (to list all), or use a number 0-18, "
+                "or model name like 'opus' or 'gpt-4'"
+            )
             return None
 
         # Set the model
-        model = models[model_index]
-        context.state_manager.session.current_model = model
+        context.state_manager.session.current_model = model_info.id
 
         # Check if setting as default
         if len(args) > 1 and args[1] == "default":
-            utils.user_configuration.set_default_model(model, context.state_manager)
-            await ui.muted("Updating default model")
+            utils.user_configuration.set_default_model(model_info.id, context.state_manager)
+            await ui.success(
+                f"Set default model: {model_info.display_name} {model_info.provider.value[2]}"
+            )
             return "restart"
         else:
-            # Show success message with the new model
-            await ui.success(f"Switched to model: {model}")
+            # Show success message with model details
+            cost_emoji = selector.get_cost_emoji(model_info.cost_tier)
+            await ui.success(
+                f"Switched to: {model_info.display_name} "
+                f"{model_info.provider.value[2]} {cost_emoji}\n"
+                f"  → {model_info.description}"
+            )
             return None
 
+    async def _show_model_list(self, selector, state_manager) -> None:
+        """Show enhanced model list grouped by provider."""
+        from rich.table import Table
+        from rich.text import Text
+
+        # Create table
+        table = Table(show_header=True, box=None, padding=(0, 2))
+        table.add_column("ID", style="dim", width=3)
+        table.add_column("Model", style="bold")
+        table.add_column("Short", style="cyan")
+        table.add_column("Description", style="dim")
+        table.add_column("Cost", justify="center", width=4)
+
+        # Current model
+        current_model = state_manager.session.current_model if state_manager else None
+
+        # Add models grouped by provider
+        model_index = 0
+        grouped = selector.get_models_by_provider()
+
+        for provider in [p for p in grouped if grouped[p]]:  # Only show providers with models
+            # Add provider header
+            table.add_row(
+                "",
+                Text(f"{provider.value[2]} {provider.value[1]}", style="bold magenta"),
+                "",
+                "",
+                "",
+            )
+
+            # Add models for this provider
+            for model in grouped[provider]:
+                is_current = model.id == current_model
+                style = "bold green" if is_current else ""
+
+                table.add_row(
+                    str(model_index),
+                    Text(model.display_name + (" ← current" if is_current else ""), style=style),
+                    model.short_name,
+                    model.description,
+                    selector.get_cost_emoji(model.cost_tier),
+                )
+                model_index += 1
+
+        # Show the table
+        await ui.panel("Available Models", table, border_style="cyan")
+
+        # Show usage hints
+        await ui.muted("\n💡 Usage: /model <number|name> [default]")
+        await ui.muted("   Examples: /model 3, /model opus, /model gpt-4 default")
+
 
 @dataclass
 class CommandDependencies:
@@ -488,8 +546,7 @@ class CommandRegistry:
         category_commands = self._categories[command.category]
         # Remove any existing instance of this command class
         self._categories[command.category] = [
-            cmd for cmd in category_commands 
-            if cmd.__class__ != command.__class__
+            cmd for cmd in category_commands if cmd.__class__ != command.__class__
         ]
         # Add the new instance
         self._categories[command.category].append(command)
@@ -533,7 +590,7 @@ class CommandRegistry:
         # Only update if callback has changed
         if self._factory.dependencies.process_request_callback == callback:
             return
-            
+
         self._factory.update_dependencies(process_request_callback=callback)
 
         # Re-register CompactCommand with new dependency if already registered
@@ -568,10 +625,10 @@ class CommandRegistry:
         if command_name in self._commands:
             command = self._commands[command_name]
             return await command.execute(args, context)
-        
+
         # Try partial matching
         matches = self.find_matching_commands(command_name)
-        
+
         if not matches:
             raise ValidationError(f"Unknown command: {command_name}")
         elif len(matches) == 1:
@@ -581,16 +638,17 @@ class CommandRegistry:
         else:
             # Ambiguous - show possibilities
             raise ValidationError(
-                f"Ambiguous command '{command_name}'. Did you mean: {', '.join(sorted(set(matches)))}?"
+                f"Ambiguous command '{command_name}'. Did you mean: "
+                f"{', '.join(sorted(set(matches)))}?"
             )
 
     def find_matching_commands(self, partial_command: str) -> List[str]:
         """
         Find all commands that start with the given partial command.
-        
+
         Args:
             partial_command: The partial command to match
-            
+
         Returns:
             List of matching command names
         """
@@ -608,11 +666,11 @@ class CommandRegistry:
             return False
 
         command_name = parts[0].lower()
-        
+
         # Check exact match first
         if command_name in self._commands:
             return True
-            
+
         # Check partial match
         return len(self.find_matching_commands(command_name)) > 0
 

tunacode/cli/model_selector.py

@@ -0,0 +1,178 @@
+"""Interactive model selector with modern UI."""
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import Dict, List, Optional
+
+from tunacode.configuration.models import ModelRegistry
+from tunacode.types import ModelName
+
+
+class ModelProvider(Enum):
+    """Model providers with their display names."""
+
+    ANTHROPIC = ("anthropic", "Anthropic", "🤖")
+    OPENAI = ("openai", "OpenAI", "🧠")
+    GOOGLE = ("google-gla", "Google", "🌐")
+    OPENROUTER = ("openrouter", "OpenRouter", "🚀")
+
+
+@dataclass
+class ModelInfo:
+    """Enhanced model information."""
+
+    id: ModelName
+    provider: ModelProvider
+    display_name: str
+    short_name: str
+    description: str
+    cost_tier: str  # low, medium, high, premium
+
+
+class ModelSelector:
+    """Enhanced model selection with categorization and search."""
+
+    def __init__(self):
+        self.registry = ModelRegistry()
+        self.models = self._build_model_info()
+
+    def _build_model_info(self) -> List[ModelInfo]:
+        """Build enhanced model information with metadata."""
+        models = []
+
+        # Model metadata mapping
+        model_metadata = {
+            # Anthropic models
+            "anthropic:claude-opus-4-20250514": (
+                "Claude Opus 4",
+                "opus-4",
+                "Most capable Claude model",
+                "high",
+            ),
+            "anthropic:claude-sonnet-4-20250514": (
+                "Claude Sonnet 4",
+                "sonnet-4",
+                "Balanced performance",
+                "medium",
+            ),
+            "anthropic:claude-3-7-sonnet-latest": (
+                "Claude 3.7 Sonnet",
+                "sonnet-3.7",
+                "Previous generation",
+                "medium",
+            ),
+            # Google models
+            "google-gla:gemini-2.0-flash": (
+                "Gemini 2.0 Flash",
+                "flash-2.0",
+                "Fast and efficient",
+                "low",
+            ),
+            "google-gla:gemini-2.5-flash-preview-05-20": (
+                "Gemini 2.5 Flash",
+                "flash-2.5",
+                "Latest preview",
+                "low",
+            ),
+            "google-gla:gemini-2.5-pro-preview-05-06": (
+                "Gemini 2.5 Pro",
+                "pro-2.5",
+                "Most capable Gemini",
+                "medium",
+            ),
+            # OpenAI models
+            "openai:gpt-4.1": ("GPT-4.1", "gpt-4.1", "Latest GPT-4", "medium"),
+            "openai:gpt-4.1-mini": ("GPT-4.1 Mini", "4.1-mini", "Efficient GPT-4", "low"),
+            "openai:gpt-4.1-nano": ("GPT-4.1 Nano", "4.1-nano", "Smallest GPT-4", "low"),
+            "openai:gpt-4o": ("GPT-4o", "gpt-4o", "Optimized GPT-4", "medium"),
+            "openai:o3": ("O3", "o3", "Advanced reasoning", "premium"),
+            "openai:o3-mini": ("O3 Mini", "o3-mini", "Efficient reasoning", "high"),
+            # OpenRouter models
+            "openrouter:mistralai/devstral-small": (
+                "Devstral Small",
+                "devstral",
+                "Code-focused",
+                "low",
+            ),
+            "openrouter:codex-mini-latest": ("Codex Mini", "codex", "Code completion", "medium"),
+            "openrouter:o4-mini-high": ("O4 Mini High", "o4-high", "Enhanced O4", "high"),
+            "openrouter:o3": ("O3 (OpenRouter)", "o3-or", "O3 via OpenRouter", "premium"),
+            "openrouter:o4-mini": ("O4 Mini", "o4-mini", "Standard O4", "high"),
+            "openrouter:openai/gpt-4.1": (
+                "GPT-4.1 (OR)",
+                "gpt-4.1-or",
+                "GPT-4.1 via OpenRouter",
+                "medium",
+            ),
+            "openrouter:openai/gpt-4.1-mini": (
+                "GPT-4.1 Mini (OR)",
+                "4.1-mini-or",
+                "GPT-4.1 Mini via OpenRouter",
+                "low",
+            ),
+        }
+
+        for model_id in self.registry.list_model_ids():
+            provider = self._get_provider(model_id)
+            if provider and model_id in model_metadata:
+                display_name, short_name, description, cost_tier = model_metadata[model_id]
+                models.append(
+                    ModelInfo(
+                        id=model_id,
+                        provider=provider,
+                        display_name=display_name,
+                        short_name=short_name,
+                        description=description,
+                        cost_tier=cost_tier,
+                    )
+                )
+
+        return models
+
+    def _get_provider(self, model_id: str) -> Optional[ModelProvider]:
+        """Get provider from model ID."""
+        for provider in ModelProvider:
+            if model_id.startswith(provider.value[0]):
+                return provider
+        return None
+
+    def get_models_by_provider(self) -> Dict[ModelProvider, List[ModelInfo]]:
+        """Group models by provider."""
+        grouped = {provider: [] for provider in ModelProvider}
+        for model in self.models:
+            if model.provider:
+                grouped[model.provider].append(model)
+        return grouped
+
+    def find_model(self, query: str) -> Optional[ModelInfo]:
+        """Find model by index, name, or fuzzy match."""
+        query = query.lower().strip()
+
+        # Try as index first
+        try:
+            index = int(query)
+            if 0 <= index < len(self.models):
+                return self.models[index]
+        except ValueError:
+            pass
+
+        # Exact match on ID
+        for model in self.models:
+            if model.id.lower() == query:
+                return model
+
+        # Match on short name
+        for model in self.models:
+            if model.short_name.lower() == query:
+                return model
+
+        # Fuzzy match on display name or short name
+        for model in self.models:
+            if query in model.display_name.lower() or query in model.short_name.lower():
+                return model
+
+        return None
+
+    def get_cost_emoji(self, cost_tier: str) -> str:
+        """Get emoji representation of cost tier."""
+        return {"low": "💚", "medium": "💛", "high": "🧡", "premium": "❤️"}.get(cost_tier, "⚪")

tunacode/cli/repl.py

@@ -10,7 +10,6 @@ from asyncio.exceptions import CancelledError
 
 from prompt_toolkit.application import run_in_terminal
 from prompt_toolkit.application.current import get_app
-from pydantic_ai.exceptions import UnexpectedModelBehavior
 
 from tunacode.configuration.settings import ApplicationSettings
 from tunacode.core.agents import main as agent
@@ -183,15 +182,17 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
         await ui.muted("Request cancelled")
     except UserAbortError:
         await ui.muted("Operation aborted.")
-    except UnexpectedModelBehavior as e:
-        error_message = str(e)
-        await ui.muted(error_message)
-        patch_tool_messages(error_message, state_manager)
     except Exception as e:
-        # Wrap unexpected exceptions in AgentError for better tracking
-        agent_error = AgentError(f"Agent processing failed: {str(e)}")
-        agent_error.__cause__ = e  # Preserve the original exception chain
-        await ui.error(str(e))
+        # Check if this is a model behavior error from tinyAgent
+        if "model" in str(e).lower() or "unexpected" in str(e).lower():
+            error_message = str(e)
+            await ui.muted(error_message)
+            patch_tool_messages(error_message, state_manager)
+        else:
+            # Wrap unexpected exceptions in AgentError for better tracking
+            agent_error = AgentError(f"Agent processing failed: {str(e)}")
+            agent_error.__cause__ = e  # Preserve the original exception chain
+            await ui.error(str(e))
     finally:
         await ui.spinner(False, state_manager.session.spinner, state_manager)
         state_manager.session.current_task = None
@@ -214,7 +215,7 @@ async def repl(state_manager: StateManager):
     await ui.line()
     await ui.success("ready to hack...")
     await ui.line()
-    
+
     instance = agent.get_or_create_agent(state_manager.session.current_model, state_manager)
 
     async with instance.run_mcp_servers():

tunacode/configuration/models.py

@@ -10,8 +10,18 @@ from tunacode.types import ModelRegistry as ModelRegistryType
 
 
 class ModelRegistry:
+    _instance = None
+    _models_cache = None
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(ModelRegistry, cls).__new__(cls)
+        return cls._instance
+
     def __init__(self):
-        self._models = self._load_default_models()
+        if ModelRegistry._models_cache is None:
+            ModelRegistry._models_cache = self._load_default_models()
+        self._models = ModelRegistry._models_cache
 
     def _load_default_models(self) -> ModelRegistryType:
         return {

tunacode/constants.py

@@ -7,7 +7,7 @@ Centralizes all magic strings, UI text, error messages, and application constant
 
 # Application info
 APP_NAME = "TunaCode"
-APP_VERSION = "0.5.1"
+APP_VERSION = "0.1.0"
 
 # File patterns
 GUIDE_FILE_PATTERN = "{name}.md"
@@ -63,22 +63,22 @@ COMMAND_CATEGORIES = {
 }
 
 # System paths
-SIDEKICK_HOME_DIR = ".tunacode"
+TUNACODE_HOME_DIR = ".tunacode"
 SESSIONS_SUBDIR = "sessions"
 DEVICE_ID_FILE = "device_id"
 
 # UI colors - Modern sleek color scheme
 UI_COLORS = {
-    "primary": "#00d7ff",      # Bright cyan
-    "secondary": "#64748b",   # Slate gray
-    "accent": "#7c3aed",      # Purple accent
-    "success": "#10b981",     # Emerald green
-    "warning": "#f59e0b",     # Amber
-    "error": "#ef4444",       # Red
-    "muted": "#94a3b8",       # Light slate
-    "file_ref": "#00d7ff",    # Bright cyan
+    "primary": "#00d7ff",  # Bright cyan
+    "secondary": "#64748b",  # Slate gray
+    "accent": "#7c3aed",  # Purple accent
+    "success": "#10b981",  # Emerald green
+    "warning": "#f59e0b",  # Amber
+    "error": "#ef4444",  # Red
+    "muted": "#94a3b8",  # Light slate
+    "file_ref": "#00d7ff",  # Bright cyan
     "background": "#0f172a",  # Dark slate
-    "border": "#334155",      # Slate border
+    "border": "#334155",  # Slate border
 }
 
 # UI text and formatting

tunacode/context.py

@@ -1,11 +1,9 @@
-import json
-import os
 import subprocess
 from pathlib import Path
 from typing import Dict, List
 
-from tunacode.utils.system import list_cwd
 from tunacode.utils.ripgrep import ripgrep
+from tunacode.utils.system import list_cwd
 
 
 async def get_git_status() -> Dict[str, object]:

tunacode/core/agents/main.py

@@ -2,49 +2,28 @@
 
 Main agent functionality and coordination for the Sidekick CLI.
 Provides agent creation, message processing, and tool call management.
+Now using tinyAgent instead of pydantic-ai.
 """
 
-from datetime import datetime, timezone
 from typing import Optional
 
-from pydantic_ai import Agent, Tool
-from pydantic_ai.messages import ModelRequest, ToolReturnPart
-
 from tunacode.core.state import StateManager
-from tunacode.services.mcp import get_mcp_servers
-from tunacode.tools.read_file import read_file
-from tunacode.tools.run_command import run_command
-from tunacode.tools.update_file import update_file
-from tunacode.tools.write_file import write_file
-from tunacode.types import (AgentRun, ErrorMessage, ModelName, PydanticAgent, ToolCallback,
-                            ToolCallId, ToolName)
-
-
-async def _process_node(node, tool_callback: Optional[ToolCallback], state_manager: StateManager):
-    if hasattr(node, "request"):
-        state_manager.session.messages.append(node.request)
-
-    if hasattr(node, "model_response"):
-        state_manager.session.messages.append(node.model_response)
-        for part in node.model_response.parts:
-            if part.part_kind == "tool-call" and tool_callback:
-                await tool_callback(part, node)
-
-
-def get_or_create_agent(model: ModelName, state_manager: StateManager) -> PydanticAgent:
-    if model not in state_manager.session.agents:
-        max_retries = state_manager.session.user_config["settings"]["max_retries"]
-        state_manager.session.agents[model] = Agent(
-            model=model,
-            tools=[
-                Tool(read_file, max_retries=max_retries),
-                Tool(run_command, max_retries=max_retries),
-                Tool(update_file, max_retries=max_retries),
-                Tool(write_file, max_retries=max_retries),
-            ],
-            mcp_servers=get_mcp_servers(state_manager),
-        )
-    return state_manager.session.agents[model]
+from tunacode.types import AgentRun, ErrorMessage, ModelName, ToolCallback
+
+# Import tinyAgent implementation
+from .tinyagent_main import get_or_create_react_agent
+from .tinyagent_main import patch_tool_messages as tinyagent_patch_tool_messages
+from .tinyagent_main import process_request_with_tinyagent
+
+# Wrapper functions for backward compatibility with pydantic-ai interface
+
+
+def get_or_create_agent(model: ModelName, state_manager: StateManager):
+    """
+    Wrapper for backward compatibility.
+    Returns the ReactAgent instance from tinyAgent.
+    """
+    return get_or_create_react_agent(model, state_manager)
 
 
 def patch_tool_messages(
@@ -52,57 +31,10 @@ def patch_tool_messages(
     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.
-
-    Ignores tools that have corresponding retry prompts as the model is already
-    addressing them.
+    Wrapper for backward compatibility.
+    TinyAgent handles tool errors internally, so this is mostly a no-op.
     """
-    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:
-            messages.append(
-                ModelRequest(
-                    parts=[
-                        ToolReturnPart(
-                            tool_name=tool_name,
-                            content=error_message,
-                            tool_call_id=tool_call_id,
-                            timestamp=datetime.now(timezone.utc),
-                            part_kind="tool-return",
-                        )
-                    ],
-                    kind="request",
-                )
-            )
+    tinyagent_patch_tool_messages(error_message, state_manager)
 
 
 async def process_request(
@@ -111,9 +43,35 @@ async def process_request(
     state_manager: StateManager,
     tool_callback: Optional[ToolCallback] = None,
 ) -> AgentRun:
-    agent = get_or_create_agent(model, state_manager)
-    mh = state_manager.session.messages.copy()
-    async with agent.iter(message, message_history=mh) as agent_run:
-        async for node in agent_run:
-            await _process_node(node, tool_callback, state_manager)
-        return agent_run
+    """
+    Process a request using tinyAgent.
+    Returns a result that mimics the pydantic-ai AgentRun structure.
+    """
+    result = await process_request_with_tinyagent(model, message, state_manager, tool_callback)
+
+    # Create a mock AgentRun object for compatibility
+    class MockAgentRun:
+        def __init__(self, result_dict):
+            self._result = result_dict
+
+        @property
+        def result(self):
+            class MockResult:
+                def __init__(self, content):
+                    self._content = content
+
+                @property
+                def output(self):
+                    return self._content
+
+            return MockResult(self._result.get("result", ""))
+
+        @property
+        def messages(self):
+            return state_manager.session.messages
+
+        @property
+        def model(self):
+            return self._result.get("model", model)
+
+    return MockAgentRun(result)