tunacode-cli 0.0.35__py3-none-any.whl → 0.0.37__py3-none-any.whl

tunacode/cli/commands/implementations/system.py

@@ -0,0 +1,216 @@
+"""System-level commands for TunaCode CLI."""
+
+import shutil
+import subprocess
+import sys
+from typing import List
+
+from ....types import CommandContext
+from ....ui import console as ui
+from ..base import CommandCategory, CommandSpec, SimpleCommand
+
+
+class HelpCommand(SimpleCommand):
+    """Show help information."""
+
+    spec = CommandSpec(
+        name="help",
+        aliases=["/help"],
+        description="Show help information",
+        category=CommandCategory.SYSTEM,
+    )
+
+    def __init__(self, command_registry=None):
+        self._command_registry = command_registry
+
+    async def execute(self, args: List[str], context: CommandContext) -> None:
+        await ui.help(self._command_registry)
+
+
+class ClearCommand(SimpleCommand):
+    """Clear screen and message history."""
+
+    spec = CommandSpec(
+        name="clear",
+        aliases=["/clear"],
+        description="Clear the screen and message history",
+        category=CommandCategory.NAVIGATION,
+    )
+
+    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
+
+        patch_tool_messages("Conversation cleared", context.state_manager)
+
+        await ui.clear()
+        context.state_manager.session.messages = []
+        context.state_manager.session.files_in_context.clear()
+        await ui.success("Message history and file context cleared")
+
+
+class RefreshConfigCommand(SimpleCommand):
+    """Refresh configuration from defaults."""
+
+    spec = CommandSpec(
+        name="refresh",
+        aliases=["/refresh"],
+        description="Refresh configuration from defaults (useful after updates)",
+        category=CommandCategory.SYSTEM,
+    )
+
+    async def execute(self, args: List[str], context: CommandContext) -> None:
+        from tunacode.configuration.defaults import DEFAULT_USER_CONFIG
+
+        # Update current session config with latest defaults
+        for key, value in DEFAULT_USER_CONFIG.items():
+            if key not in context.state_manager.session.user_config:
+                context.state_manager.session.user_config[key] = value
+            elif isinstance(value, dict):
+                # Merge dict values, preserving user overrides
+                for subkey, subvalue in value.items():
+                    if subkey not in context.state_manager.session.user_config[key]:
+                        context.state_manager.session.user_config[key][subkey] = subvalue
+
+        # Show updated max_iterations
+        max_iterations = context.state_manager.session.user_config.get("settings", {}).get(
+            "max_iterations", 20
+        )
+        await ui.success(f"Configuration refreshed - max iterations: {max_iterations}")
+
+
+class UpdateCommand(SimpleCommand):
+    """Update TunaCode to the latest version."""
+
+    spec = CommandSpec(
+        name="update",
+        aliases=["/update"],
+        description="Update TunaCode to the latest version",
+        category=CommandCategory.SYSTEM,
+    )
+
+    async def execute(self, args: List[str], context: CommandContext) -> None:
+        await ui.info("Checking for TunaCode updates...")
+
+        # Detect installation method
+        installation_method = None
+
+        # Check if installed via pipx
+        if shutil.which("pipx"):
+            try:
+                result = subprocess.run(
+                    ["pipx", "list"], capture_output=True, text=True, timeout=10
+                )
+                pipx_installed = "tunacode" in result.stdout.lower()
+                if pipx_installed:
+                    installation_method = "pipx"
+            except (subprocess.TimeoutExpired, subprocess.CalledProcessError):
+                pass
+
+        # Check if installed via pip
+        if not installation_method:
+            try:
+                result = subprocess.run(
+                    [sys.executable, "-m", "pip", "show", "tunacode-cli"],
+                    capture_output=True,
+                    text=True,
+                    timeout=10,
+                )
+                if result.returncode == 0:
+                    installation_method = "pip"
+            except (subprocess.TimeoutExpired, subprocess.CalledProcessError):
+                pass
+
+        if not installation_method:
+            await ui.error("Could not detect TunaCode installation method")
+            await ui.muted("Manual update options:")
+            await ui.muted("  pipx: pipx upgrade tunacode")
+            await ui.muted("  pip:  pip install --upgrade tunacode-cli")
+            return
+
+        # Perform update based on detected method
+        try:
+            if installation_method == "pipx":
+                await ui.info("Updating via pipx...")
+                result = subprocess.run(
+                    ["pipx", "upgrade", "tunacode"],
+                    capture_output=True,
+                    text=True,
+                    timeout=60,
+                )
+            else:  # pip
+                await ui.info("Updating via pip...")
+                result = subprocess.run(
+                    [
+                        sys.executable,
+                        "-m",
+                        "pip",
+                        "install",
+                        "--upgrade",
+                        "tunacode-cli",
+                    ],
+                    capture_output=True,
+                    text=True,
+                    timeout=60,
+                )
+
+            if result.returncode == 0:
+                await ui.success("TunaCode updated successfully!")
+                await ui.muted("Restart TunaCode to use the new version")
+
+                # Show update output if available
+                if result.stdout.strip():
+                    output_lines = result.stdout.strip().split("\n")
+                    for line in output_lines[-5:]:  # Show last 5 lines
+                        if line.strip():
+                            await ui.muted(f"  {line}")
+            else:
+                await ui.error("Update failed")
+                if result.stderr:
+                    await ui.muted(f"Error: {result.stderr.strip()}")
+
+        except subprocess.TimeoutExpired:
+            await ui.error("Update timed out")
+        except subprocess.CalledProcessError as e:
+            await ui.error(f"Update failed: {e}")
+        except FileNotFoundError:
+            await ui.error(f"Could not find {installation_method} executable")
+
+
+class StreamingCommand(SimpleCommand):
+    """Toggle streaming display on/off."""
+
+    spec = CommandSpec(
+        name="streaming",
+        aliases=["/streaming"],
+        description="Toggle streaming display on/off",
+        category=CommandCategory.SYSTEM,
+    )
+
+    async def execute(self, args: List[str], context: CommandContext) -> None:
+        current_setting = context.state_manager.session.user_config.get("settings", {}).get(
+            "enable_streaming", True
+        )
+
+        if args and args[0].lower() in ["on", "true", "1", "enable", "enabled"]:
+            new_setting = True
+        elif args and args[0].lower() in ["off", "false", "0", "disable", "disabled"]:
+            new_setting = False
+        else:
+            # Toggle current setting
+            new_setting = not current_setting
+
+        # Update the configuration
+        if "settings" not in context.state_manager.session.user_config:
+            context.state_manager.session.user_config["settings"] = {}
+        context.state_manager.session.user_config["settings"]["enable_streaming"] = new_setting
+
+        status = "enabled" if new_setting else "disabled"
+        await ui.success(f"Streaming display {status}")
+
+        if new_setting:
+            await ui.muted(
+                "Responses will be displayed progressively as they are generated (default)"
+            )
+        else:
+            await ui.muted("Responses will be displayed all at once after completion")

tunacode/cli/commands/registry.py

@@ -0,0 +1,236 @@
+"""Command registry and factory for TunaCode CLI commands."""
+
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, Type
+
+from ...exceptions import ValidationError
+from ...types import CommandArgs, CommandContext, ProcessRequestCallback
+from .base import Command, CommandCategory
+
+# Import all command implementations
+from .implementations.conversation import CompactCommand
+from .implementations.debug import (
+    DumpCommand,
+    FixCommand,
+    IterationsCommand,
+    ParseToolsCommand,
+    ThoughtsCommand,
+    YoloCommand,
+)
+from .implementations.development import BranchCommand, InitCommand
+from .implementations.model import ModelCommand
+from .implementations.system import (
+    ClearCommand,
+    HelpCommand,
+    RefreshConfigCommand,
+    StreamingCommand,
+    UpdateCommand,
+)
+
+
+@dataclass
+class CommandDependencies:
+    """Container for command dependencies."""
+
+    process_request_callback: Optional[ProcessRequestCallback] = None
+    command_registry: Optional[Any] = None  # Reference to the registry itself
+
+
+class CommandFactory:
+    """Factory for creating commands with proper dependency injection."""
+
+    def __init__(self, dependencies: Optional[CommandDependencies] = None):
+        self.dependencies = dependencies or CommandDependencies()
+
+    def create_command(self, command_class: Type[Command]) -> Command:
+        """Create a command instance with proper dependencies."""
+        # Special handling for commands that need dependencies
+        if command_class == CompactCommand:
+            return CompactCommand(self.dependencies.process_request_callback)
+        elif command_class == HelpCommand:
+            return HelpCommand(self.dependencies.command_registry)
+
+        # Default creation for commands without dependencies
+        return command_class()
+
+    def update_dependencies(self, **kwargs) -> None:
+        """Update factory dependencies."""
+        for key, value in kwargs.items():
+            if hasattr(self.dependencies, key):
+                setattr(self.dependencies, key, value)
+
+
+class CommandRegistry:
+    """Registry for managing commands with auto-discovery and categories."""
+
+    def __init__(self, factory: Optional[CommandFactory] = None):
+        self._commands: Dict[str, Command] = {}
+        self._categories: Dict[CommandCategory, List[Command]] = {
+            category: [] for category in CommandCategory
+        }
+        self._factory = factory or CommandFactory()
+        self._discovered = False
+
+        # Set registry reference in factory dependencies
+        self._factory.update_dependencies(command_registry=self)
+
+    def register(self, command: Command) -> None:
+        """Register a command and its aliases."""
+        # Register by primary name
+        self._commands[command.name] = command
+
+        # Register all aliases
+        for alias in command.aliases:
+            self._commands[alias.lower()] = command
+
+        # Add to category (remove existing instance first to prevent duplicates)
+        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__
+        ]
+        # Add the new instance
+        self._categories[command.category].append(command)
+
+    def register_command_class(self, command_class: Type[Command]) -> None:
+        """Register a command class using the factory."""
+        command = self._factory.create_command(command_class)
+        self.register(command)
+
+    def discover_commands(self) -> None:
+        """Auto-discover and register all command classes."""
+        if self._discovered:
+            return
+
+        # List of all command classes to register
+        command_classes = [
+            YoloCommand,
+            DumpCommand,
+            ThoughtsCommand,
+            IterationsCommand,
+            ClearCommand,
+            FixCommand,
+            ParseToolsCommand,
+            RefreshConfigCommand,
+            StreamingCommand,
+            UpdateCommand,
+            HelpCommand,
+            BranchCommand,
+            CompactCommand,
+            ModelCommand,
+            InitCommand,
+        ]
+
+        # Register all discovered commands
+        for command_class in command_classes:
+            self.register_command_class(command_class)
+
+        self._discovered = True
+
+    def register_all_default_commands(self) -> None:
+        """Register all default commands (backward compatibility)."""
+        self.discover_commands()
+
+    def set_process_request_callback(self, callback: ProcessRequestCallback) -> None:
+        """Set the process_request callback for commands that need it."""
+        # 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
+        if "compact" in self._commands:
+            self.register_command_class(CompactCommand)
+
+    async def execute(self, command_text: str, context: CommandContext) -> Any:
+        """
+        Execute a command.
+
+        Args:
+            command_text: The full command text
+            context: Execution context
+
+        Returns:
+            Command-specific return value, or None if command not found
+
+        Raises:
+            ValidationError: If command is not found or empty
+        """
+        # Ensure commands are discovered
+        self.discover_commands()
+
+        parts = command_text.split()
+        if not parts:
+            raise ValidationError("Empty command")
+
+        command_name = parts[0].lower()
+        args = parts[1:]
+
+        # First try exact match
+        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:
+            # Unambiguous match
+            command = self._commands[matches[0]]
+            return await command.execute(args, context)
+        else:
+            # Ambiguous - show possibilities
+            matches_str = ", ".join(sorted(set(matches)))
+            raise ValidationError(
+                f"Ambiguous command '{command_name}'. Did you mean: {matches_str}?"
+            )
+
+    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
+        """
+        self.discover_commands()
+        partial = partial_command.lower()
+        return [cmd for cmd in self._commands.keys() if cmd.startswith(partial)]
+
+    def is_command(self, text: str) -> bool:
+        """Check if text starts with a registered command (supports partial matching)."""
+        if not text:
+            return False
+
+        parts = text.split()
+        if not parts:
+            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
+
+    def get_command_names(self) -> CommandArgs:
+        """Get all registered command names (including aliases)."""
+        self.discover_commands()
+        return sorted(self._commands.keys())
+
+    def get_commands_by_category(self, category: CommandCategory) -> List[Command]:
+        """Get all commands in a specific category."""
+        self.discover_commands()
+        return self._categories.get(category, [])
+
+    def get_all_categories(self) -> Dict[CommandCategory, List[Command]]:
+        """Get all commands organized by category."""
+        self.discover_commands()
+        return self._categories.copy()

tunacode/cli/repl.py

@@ -70,8 +70,9 @@ async def _tool_confirm(tool_call, node, state_manager: StateManager):
             await _tool_ui.log_mcp(title, args)
         return
 
-    # Stop spinner during user interaction
-    state_manager.session.spinner.stop()
+    # Stop spinner during user interaction (only if not streaming)
+    if not state_manager.session.is_streaming_active and state_manager.session.spinner:
+        state_manager.session.spinner.stop()
 
     # Create confirmation request
     request = tool_handler.create_confirmation_request(tool_call.tool_name, args)
@@ -84,7 +85,10 @@ async def _tool_confirm(tool_call, node, state_manager: StateManager):
         raise UserAbortError("User aborted.")
 
     await ui.line()  # Add line after user input
-    state_manager.session.spinner.start()
+
+    # Restart spinner (only if not streaming)
+    if not state_manager.session.is_streaming_active and state_manager.session.spinner:
+        state_manager.session.spinner.start()
 
 
 async def _tool_handler(part, node, state_manager: StateManager):
@@ -96,7 +100,19 @@ async def _tool_handler(part, node, state_manager: StateManager):
     if tool_handler.should_confirm(part.tool_name):
         await ui.info(f"Tool({part.tool_name})")
 
-    state_manager.session.spinner.stop()
+    # Stop spinner only if not streaming
+    if not state_manager.session.is_streaming_active and state_manager.session.spinner:
+        state_manager.session.spinner.stop()
+
+    # Track if we need to stop/restart streaming panel
+    streaming_panel = None
+    if state_manager.session.is_streaming_active and hasattr(
+        state_manager.session, "streaming_panel"
+    ):
+        streaming_panel = state_manager.session.streaming_panel
+        # Stop the streaming panel to prevent UI interference during confirmation
+        if streaming_panel and tool_handler.should_confirm(part.tool_name):
+            await streaming_panel.stop()
 
     try:
         args = _parse_args(part.args)
@@ -128,7 +144,13 @@ async def _tool_handler(part, node, state_manager: StateManager):
         patch_tool_messages("Operation aborted by user.", state_manager)
         raise
     finally:
-        state_manager.session.spinner.start()
+        # Restart streaming panel if it was stopped
+        if streaming_panel and tool_handler.should_confirm(part.tool_name):
+            await streaming_panel.start()
+
+        # Restart spinner only if not streaming
+        if not state_manager.session.is_streaming_active and state_manager.session.spinner:
+            state_manager.session.spinner.start()
 
 
 # Initialize command registry
@@ -195,38 +217,77 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
             await ui.error(str(e))
             return
 
-        # Use normal agent processing
-        res = await agent.process_request(
-            state_manager.session.current_model,
-            text,
-            state_manager,
-            tool_callback=tool_callback_with_state,
+        # Check if streaming is enabled (default: True for better UX)
+        enable_streaming = state_manager.session.user_config.get("settings", {}).get(
+            "enable_streaming", True
         )
+
+        if enable_streaming:
+            # Stop spinner before starting streaming display (Rich.Live conflict)
+            await ui.spinner(False, state_manager.session.spinner, state_manager)
+
+            # Mark that streaming is active to prevent spinner conflicts
+            state_manager.session.is_streaming_active = True
+
+            # Use streaming agent processing
+            streaming_panel = ui.StreamingAgentPanel()
+            await streaming_panel.start()
+
+            # Store streaming panel reference in session for tool handler access
+            state_manager.session.streaming_panel = streaming_panel
+
+            try:
+
+                async def streaming_callback(content: str):
+                    await streaming_panel.update(content)
+
+                res = await agent.process_request(
+                    state_manager.session.current_model,
+                    text,
+                    state_manager,
+                    tool_callback=tool_callback_with_state,
+                    streaming_callback=streaming_callback,
+                )
+            finally:
+                await streaming_panel.stop()
+                # Clear streaming panel reference
+                state_manager.session.streaming_panel = None
+                # Mark streaming as inactive
+                state_manager.session.is_streaming_active = False
+                # Don't restart spinner - it will be stopped in the outer finally block anyway
+        else:
+            # Use normal agent processing
+            res = await agent.process_request(
+                state_manager.session.current_model,
+                text,
+                state_manager,
+                tool_callback=tool_callback_with_state,
+            )
         if output:
             if state_manager.session.show_thoughts:
                 new_msgs = state_manager.session.messages[start_idx:]
                 for msg in new_msgs:
                     if isinstance(msg, dict) and "thought" in msg:
                         await ui.muted(f"THOUGHT: {msg['thought']}")
-            # Check if result exists and has output
-            if hasattr(res, "result") and res.result is not None and hasattr(res.result, "output"):
-                await ui.agent(res.result.output)
-                # Always show files in context after agent response
-                if state_manager.session.files_in_context:
-                    # Extract just filenames from full paths for readability
-                    filenames = [
-                        Path(f).name for f in sorted(state_manager.session.files_in_context)
-                    ]
-                    await ui.muted(f"\nFiles in context: {', '.join(filenames)}")
-            else:
-                # Fallback: show that the request was processed
-                await ui.muted("Request completed")
-                # Show files in context even for empty responses
-                if state_manager.session.files_in_context:
-                    filenames = [
-                        Path(f).name for f in sorted(state_manager.session.files_in_context)
-                    ]
-                    await ui.muted(f"Files in context: {', '.join(filenames)}")
+
+            # Only display result if not streaming (streaming already showed content)
+            if not enable_streaming:
+                # Check if result exists and has output
+                if (
+                    hasattr(res, "result")
+                    and res.result is not None
+                    and hasattr(res.result, "output")
+                ):
+                    await ui.agent(res.result.output)
+                else:
+                    # Fallback: show that the request was processed
+                    await ui.muted("Request completed")
+
+            # Always show files in context after agent response
+            if state_manager.session.files_in_context:
+                # Extract just filenames from full paths for readability
+                filenames = [Path(f).name for f in sorted(state_manager.session.files_in_context)]
+                await ui.muted(f"\nFiles in context: {', '.join(filenames)}")
     except CancelledError:
         await ui.muted("Request cancelled")
     except UserAbortError:

tunacode/configuration/settings.py

@@ -7,8 +7,15 @@ Handles configuration paths, model registries, and application metadata.
 
 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.35"
+APP_VERSION = "0.0.37"
 
 # File patterns
 GUIDE_FILE_PATTERN = "{name}.md"