tunacode-cli 0.0.8__py3-none-any.whl → 0.0.10__py3-none-any.whl

tunacode/cli/commands.py

@@ -6,8 +6,8 @@ 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
 from ..ui import console as ui
 
@@ -232,32 +232,6 @@ class HelpCommand(SimpleCommand):
         await ui.help(self._command_registry)
 
 
-class UndoCommand(SimpleCommand):
-    """Undo the last file operation."""
-
-    def __init__(self):
-        super().__init__(
-            CommandSpec(
-                name="undo",
-                aliases=["/undo"],
-                description="Undo the last file operation",
-                category=CommandCategory.DEVELOPMENT,
-            )
-        )
-
-    async def execute(self, args: List[str], context: CommandContext) -> None:
-        success, message = perform_undo(context.state_manager)
-        if success:
-            await ui.success(message)
-        else:
-            # Provide more helpful information when undo fails
-            await ui.warning(message)
-            if "not in a git repository" in message.lower():
-                await ui.muted("💡 To enable undo functionality:")
-                await ui.muted("   • Run 'git init' to initialize a git repository")
-                await ui.muted("   • Or work in a directory that's already a git repository")
-                await ui.muted("   • File operations will still work, but can't be undone")
-
 
 class BranchCommand(SimpleCommand):
     """Create and switch to a new git branch."""
@@ -305,50 +279,6 @@ class BranchCommand(SimpleCommand):
             await ui.error("Git executable not found")
 
 
-class InitCommand(SimpleCommand):
-    """Analyse the repository and generate TUNACODE.md."""
-
-    def __init__(self):
-        super().__init__(
-            CommandSpec(
-                name="init",
-                aliases=["/init"],
-                description="Analyse the repo and create TUNACODE.md",
-                category=CommandCategory.DEVELOPMENT,
-            )
-        )
-
-    async def execute(self, args: List[str], context: CommandContext) -> None:
-        import json
-        from pathlib import Path
-
-        from .. import context as ctx
-
-        await ui.info("Gathering repository context")
-        data = await ctx.get_context()
-
-        prompt = (
-            "Using the following repository context, summarise build commands "
-            "and coding conventions. Return markdown for a TUNACODE.md file.\n\n"
-            + json.dumps(data, indent=2)
-        )
-
-        process_request = context.process_request
-        content = ""
-        if process_request:
-            res = await process_request(prompt, context.state_manager, output=False)
-            try:
-                content = res.result.output
-            except Exception:
-                content = ""
-
-        if not content:
-            content = "# TUNACODE\n\n" + json.dumps(data, indent=2)
-
-        Path("TUNACODE.md").write_text(content, encoding="utf-8")
-        await ui.success("TUNACODE.md written")
-
-
 class CompactCommand(SimpleCommand):
     """Compact conversation context."""
 
@@ -386,106 +316,47 @@ class ModelCommand(SimpleCommand):
         super().__init__(
             CommandSpec(
                 name="model",
-                aliases=["/model", "/m"],
-                description="List and select AI models interactively",
+                aliases=["/model"],
+                description="Switch model (e.g., /model gpt-4 or /model openai:gpt-4)",
                 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 - show enhanced model list
-            await self._show_model_list(selector, context.state_manager)
+            # No arguments - show current model
+            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 None
 
-        # Find model by query (index, name, or fuzzy match)
-        query = args[0]
-        model_info = selector.find_model(query)
-
-        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'"
-            )
+        # Get the model name from args
+        model_name = args[0]
+        
+        # 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")
             return None
+        
+        # No validation - user is responsible for correct model names
+        await ui.warning("Model set without validation - verify the model name is correct")
 
         # Set the model
-        context.state_manager.session.current_model = model_info.id
+        context.state_manager.session.current_model = model_name
 
         # Check if setting as default
         if len(args) > 1 and args[1] == "default":
-            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]}"
-            )
+            utils.user_configuration.set_default_model(model_name, context.state_manager)
+            await ui.muted("Updating default model")
             return "restart"
         else:
-            # 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}"
-            )
+            # Show success message with the new model
+            await ui.success(f"Switched to model: {model_name}")
             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:
@@ -546,7 +417,8 @@ 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)
@@ -567,9 +439,7 @@ class CommandRegistry:
             DumpCommand,
             ClearCommand,
             HelpCommand,
-            UndoCommand,
             BranchCommand,
-            InitCommand,
             # TunaCodeCommand,  # TODO: Temporarily disabled
             CompactCommand,
             ModelCommand,
@@ -590,7 +460,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
@@ -625,10 +495,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:
@@ -638,17 +508,16 @@ class CommandRegistry:
         else:
             # Ambiguous - show possibilities
             raise ValidationError(
-                f"Ambiguous command '{command_name}'. Did you mean: "
-                f"{', '.join(sorted(set(matches)))}?"
+                f"Ambiguous command '{command_name}'. Did you mean: {', '.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
         """
@@ -666,11 +535,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/main.py

@@ -6,8 +6,6 @@ Manages application startup, version checking, and REPL initialization.
 """
 
 import asyncio
-import os
-from pathlib import Path
 
 import typer
 
@@ -19,43 +17,21 @@ from tunacode.ui import console as ui
 from tunacode.utils.system import check_for_updates
 
 app_settings = ApplicationSettings()
+app = typer.Typer(help=app_settings.name)
 state_manager = StateManager()
 
 
+@app.command()
 def main(
     version: bool = typer.Option(False, "--version", "-v", help="Show version and exit."),
     run_setup: bool = typer.Option(False, "--setup", help="Run setup process."),
-    update: bool = typer.Option(False, "--update", "--upgrade", help="Update TunaCode to the latest version."),
-    model: str = typer.Option(None, "--model", "-m", help="Set the model to use (e.g., 'openai:gpt-4o', 'openrouter:anthropic/claude-3.5-sonnet')."),
-    base_url: str = typer.Option(None, "--base-url", help="Override the API base URL for OpenAI-compatible endpoints (e.g., 'https://openrouter.ai/api/v1')."),
+    baseurl: str = typer.Option(None, "--baseurl", help="API base URL (e.g., https://openrouter.ai/api/v1)"),
+    model: str = typer.Option(None, "--model", help="Default model to use (e.g., openai/gpt-4)"),
+    key: str = typer.Option(None, "--key", help="API key for the provider"),
 ):
-    """TunaCode - Your agentic CLI developer."""
-    # Load .env file if it exists
-    env_file = Path(".env")
-    if env_file.exists():
-        try:
-            from dotenv import load_dotenv
-            load_dotenv()
-        except ImportError:
-            # dotenv not installed, skip loading
-            pass
     if version:
         asyncio.run(ui.version())
         return
-    
-    if update:
-        from tunacode.utils.system import update_tunacode
-        asyncio.run(update_tunacode())
-        return
-
-    # Apply CLI overrides to state manager before setup
-    if model:
-        state_manager.session.model = model
-        state_manager.session.user_config["default_model"] = model
-    
-    if base_url:
-        import os
-        os.environ["OPENAI_BASE_URL"] = base_url
 
     asyncio.run(ui.banner())
 
@@ -63,20 +39,21 @@ def main(
     if has_update:
         asyncio.run(ui.show_update_message(latest_version))
 
+    # Pass CLI args to setup
+    cli_config = {}
+    if baseurl or model or key:
+        cli_config = {
+            "baseurl": baseurl,
+            "model": model,
+            "key": key
+        }
+
     try:
-        asyncio.run(setup(run_setup, state_manager))
+        asyncio.run(setup(run_setup, state_manager, cli_config))
         asyncio.run(repl(state_manager))
     except Exception as e:
         asyncio.run(ui.error(str(e)))
 
 
-app = typer.Typer(
-    name="tunacode",
-    help="TunaCode - Your agentic CLI developer",
-    add_completion=False,
-)
-
-app.command()(main)
-
 if __name__ == "__main__":
     app()

tunacode/cli/repl.py

@@ -10,6 +10,7 @@ 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
@@ -182,17 +183,15 @@ 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:
-        # 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))
+        # 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
@@ -207,15 +206,22 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
 async def repl(state_manager: StateManager):
     action = None
 
-    # Hacky startup message
-    await ui.warning("⚠️  tunaCode v0.1 - BETA SOFTWARE")
-    await ui.muted("→ All changes will be made on a new branch for safety")
-    await ui.muted("→ Use with caution! This tool can modify your codebase")
-    await ui.muted(f"→ Model loaded: {state_manager.session.current_model}")
+    # Professional startup information
+    await ui.info("TunaCode v0.1 - Beta Release")
+    await ui.muted("• Caution: This tool can modify your codebase")
+    await ui.muted(f"• Model: {state_manager.session.current_model}")
     await ui.line()
-    await ui.success("ready to hack...")
+    
+    # Important safety warning
+    await ui.warning("⚠️  IMPORTANT: The /undo command has been removed for safety reasons")
+    await ui.muted("• Always use git branches before making major changes")
+    await ui.muted("• Use '/branch <name>' to create a new branch for experiments")
+    await ui.muted("• Commit your work frequently to preserve changes")
     await ui.line()
-
+    
+    await ui.success("Ready to assist with your development")
+    await ui.line()
+    
     instance = agent.get_or_create_agent(state_manager.session.current_model, state_manager)
 
     async with instance.run_mcp_servers():
@@ -249,4 +255,4 @@ async def repl(state_manager: StateManager):
     if action == "restart":
         await repl(state_manager)
     else:
-        await ui.info("Thanks for all the fish.")
+        await ui.info("Session ended. Happy coding!")

tunacode/configuration/defaults.py

@@ -10,7 +10,7 @@ from tunacode.constants import GUIDE_FILE_NAME, TOOL_READ_FILE
 from tunacode.types import UserConfig
 
 DEFAULT_USER_CONFIG: UserConfig = {
-    "default_model": "openrouter:openai/gpt-4.1",
+    "default_model": "openai:gpt-4.1",
     "env": {
         "ANTHROPIC_API_KEY": "",
         "GEMINI_API_KEY": "",

tunacode/configuration/models.py

@@ -10,18 +10,8 @@ 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):
-        if ModelRegistry._models_cache is None:
-            ModelRegistry._models_cache = self._load_default_models()
-        self._models = ModelRegistry._models_cache
+        self._models = self._load_default_models()
 
     def _load_default_models(self) -> ModelRegistryType:
         return {
@@ -82,6 +72,9 @@ class ModelRegistry:
             "openrouter:openai/gpt-4.1-mini": ModelConfig(
                 pricing=ModelPricing(input=0.40, cached_input=0.20, output=1.60)
             ),
+            "openrouter:openai/gpt-4.1-nano": ModelConfig(
+                pricing=ModelPricing(input=0.10, cached_input=0.05, output=0.40)
+            ),
         }
 
     def get_model(self, name: ModelName) -> ModelConfig:

tunacode/configuration/settings.py

@@ -1,5 +1,5 @@
 """
-Module: sidekick.configuration.settings
+Module: tunacode.configuration.settings
 
 Application settings management for the Sidekick CLI.
 Manages application paths, tool configurations, and runtime settings.
@@ -7,8 +7,15 @@ Manages application paths, tool configurations, and runtime settings.
 
 from pathlib import Path
 
-from tunacode.constants import (APP_NAME, APP_VERSION, CONFIG_FILE_NAME, TOOL_READ_FILE,
-                                TOOL_RUN_COMMAND, TOOL_UPDATE_FILE, TOOL_WRITE_FILE)
+from tunacode.constants import (
+    APP_NAME,
+    APP_VERSION,
+    CONFIG_FILE_NAME,
+    TOOL_READ_FILE,
+    TOOL_RUN_COMMAND,
+    TOOL_UPDATE_FILE,
+    TOOL_WRITE_FILE,
+)
 from tunacode.types import ConfigFile, ConfigPath, ToolName
 
 

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.0.8"
+APP_VERSION = "0.8.21"
 
 # File patterns
 GUIDE_FILE_PATTERN = "{name}.md"
@@ -72,13 +72,13 @@ UI_COLORS = {
     "primary": "#00d7ff",  # Bright cyan
     "secondary": "#64748b",  # Slate gray
     "accent": "#7c3aed",  # Purple accent
-    "success": "#10b981",  # Emerald green
+    "success": "#22c55e",  # Modern 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": "#475569",  # Stronger slate border
 }
 
 # UI text and formatting
@@ -103,7 +103,9 @@ ERROR_INVALID_PROVIDER = "Invalid provider number"
 ERROR_FILE_NOT_FOUND = "Error: File not found at '{filepath}'."
 ERROR_FILE_TOO_LARGE = "Error: File '{filepath}' is too large (> 100KB)."
 ERROR_FILE_DECODE = "Error reading file '{filepath}': Could not decode using UTF-8."
-ERROR_FILE_DECODE_DETAILS = "It might be a binary file or use a different encoding. {error}"
+ERROR_FILE_DECODE_DETAILS = (
+    "It might be a binary file or use a different encoding. {error}"
+)
 ERROR_COMMAND_NOT_FOUND = "Error: Command not found or failed to execute:"
 ERROR_COMMAND_EXECUTION = (
     "Error: Command not found or failed to execute: {command}. Details: {error}"

tunacode/context.py

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