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

tunacode/cli/commands/implementations/system.py

@@ -1,5 +1,6 @@
 """System-level commands for TunaCode CLI."""
 
+import os
 import shutil
 import subprocess
 import sys
@@ -39,7 +40,7 @@ class ClearCommand(SimpleCommand):
 
     async def execute(self, args: List[str], context: CommandContext) -> None:
         # Patch any orphaned tool calls before clearing
-        from tunacode.core.agents.main import patch_tool_messages
+        from tunacode.core.agents import patch_tool_messages
 
         patch_tool_messages("Conversation cleared", context.state_manager)
 
@@ -107,6 +108,56 @@ class UpdateCommand(SimpleCommand):
             except (subprocess.TimeoutExpired, subprocess.CalledProcessError):
                 pass
 
+        # Check if installed via venv (from install script)
+        if not installation_method:
+            venv_dir = os.path.expanduser("~/.tunacode-venv")
+            venv_tunacode = os.path.join(venv_dir, "bin", "tunacode")
+            venv_python = os.path.join(venv_dir, "bin", "python")
+
+            if os.path.exists(venv_tunacode) and os.path.exists(venv_python):
+                # Try UV first if available (UV-created venvs don't have pip module)
+                if shutil.which("uv"):
+                    try:
+                        result = subprocess.run(
+                            ["uv", "pip", "show", "--python", venv_python, "tunacode-cli"],
+                            capture_output=True,
+                            text=True,
+                            timeout=10,
+                        )
+                        if result.returncode == 0:
+                            installation_method = "venv"
+                    except (subprocess.TimeoutExpired, subprocess.CalledProcessError):
+                        pass
+
+                # Fall back to python -m pip for pip-created venvs
+                if not installation_method:
+                    try:
+                        result = subprocess.run(
+                            [venv_python, "-m", "pip", "show", "tunacode-cli"],
+                            capture_output=True,
+                            text=True,
+                            timeout=10,
+                        )
+                        if result.returncode == 0:
+                            installation_method = "venv"
+                    except (subprocess.TimeoutExpired, subprocess.CalledProcessError):
+                        pass
+
+        # Check if installed via uv tool
+        if not installation_method:
+            if shutil.which("uv"):
+                try:
+                    result = subprocess.run(
+                        ["uv", "tool", "list"],
+                        capture_output=True,
+                        text=True,
+                        timeout=10,
+                    )
+                    if result.returncode == 0 and "tunacode-cli" in result.stdout.lower():
+                        installation_method = "uv_tool"
+                except (subprocess.TimeoutExpired, subprocess.CalledProcessError):
+                    pass
+
         # Check if installed via pip
         if not installation_method:
             try:
@@ -124,8 +175,13 @@ class UpdateCommand(SimpleCommand):
         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")
+            await ui.muted("  pipx:    pipx upgrade tunacode")
+            await ui.muted("  pip:     pip install --upgrade tunacode-cli")
+            await ui.muted("  uv tool: uv tool upgrade tunacode-cli")
+            await ui.muted(
+                "  venv:    uv pip install --python ~/.tunacode-venv/bin/python "
+                "--upgrade tunacode-cli"
+            )
             return
 
         # Perform update based on detected method
@@ -138,6 +194,43 @@ class UpdateCommand(SimpleCommand):
                     text=True,
                     timeout=60,
                 )
+            elif installation_method == "venv":
+                venv_dir = os.path.expanduser("~/.tunacode-venv")
+                venv_python = os.path.join(venv_dir, "bin", "python")
+
+                # Check if uv is available (same logic as install script)
+                if shutil.which("uv"):
+                    await ui.info("Updating via UV in venv...")
+                    result = subprocess.run(
+                        [
+                            "uv",
+                            "pip",
+                            "install",
+                            "--python",
+                            venv_python,
+                            "--upgrade",
+                            "tunacode-cli",
+                        ],
+                        capture_output=True,
+                        text=True,
+                        timeout=60,
+                    )
+                else:
+                    await ui.info("Updating via pip in venv...")
+                    result = subprocess.run(
+                        [venv_python, "-m", "pip", "install", "--upgrade", "tunacode-cli"],
+                        capture_output=True,
+                        text=True,
+                        timeout=60,
+                    )
+            elif installation_method == "uv_tool":
+                await ui.info("Updating via UV tool...")
+                result = subprocess.run(
+                    ["uv", "tool", "upgrade", "tunacode-cli"],
+                    capture_output=True,
+                    text=True,
+                    timeout=60,
+                )
             else:  # pip
                 await ui.info("Updating via pip...")
                 result = subprocess.run(

tunacode/cli/commands/implementations/template.py

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

tunacode/cli/commands/registry.py

@@ -3,7 +3,9 @@
 CLAUDE_ANCHOR[command-registry]: Central command registration and execution
 """
 
+import logging
 from dataclasses import dataclass
+from pathlib import Path
 from typing import Any, Dict, List, Optional, Type
 
 from ...exceptions import ValidationError
@@ -12,6 +14,7 @@ from ...types import CommandArgs, CommandContext, ProcessRequestCallback
 from .base import Command, CommandCategory
 
 # Import all command implementations
+from .implementations.command_reload import CommandReloadCommand
 from .implementations.conversation import CompactCommand
 from .implementations.debug import (
     DumpCommand,
@@ -23,6 +26,7 @@ from .implementations.debug import (
 )
 from .implementations.development import BranchCommand, InitCommand
 from .implementations.model import ModelCommand
+from .implementations.quickstart import QuickStartCommand
 from .implementations.system import (
     ClearCommand,
     HelpCommand,
@@ -31,9 +35,10 @@ from .implementations.system import (
     UpdateCommand,
 )
 from .implementations.template import TemplateCommand
-from .implementations.todo import TodoCommand
 from .template_shortcut import TemplateShortcutCommand
 
+logger = logging.getLogger(__name__)
+
 
 @dataclass
 class CommandDependencies:
@@ -56,6 +61,8 @@ class CommandFactory:
             return CompactCommand(self.dependencies.process_request_callback)
         elif command_class == HelpCommand:
             return HelpCommand(self.dependencies.command_registry)
+        elif command_class == CommandReloadCommand:
+            return CommandReloadCommand(self.dependencies.command_registry)
 
         # Default creation for commands without dependencies
         return command_class()
@@ -79,6 +86,11 @@ class CommandRegistry:
         self._discovered = False
         self._shortcuts_loaded = False
 
+        # Slash command support
+        self._slash_loader: Optional[Any] = None  # SlashCommandLoader
+        self._slash_discovery_result: Optional[Any] = None  # CommandDiscoveryResult
+        self._slash_enabled: bool = True  # Feature flag
+
         # Set registry reference in factory dependencies
         self._factory.update_dependencies(command_registry=self)
 
@@ -110,6 +122,17 @@ class CommandRegistry:
         if self._discovered:
             return
 
+        # Step 1: Discover built-in commands
+        self._discover_builtin_commands()
+
+        # Step 2: Discover slash commands (if enabled)
+        if self._slash_enabled:
+            self._discover_slash_commands()
+
+        self._discovered = True
+
+    def _discover_builtin_commands(self) -> None:
+        """Discover and register built-in command classes."""
         # List of all command classes to register
         command_classes = [
             YoloCommand,
@@ -128,14 +151,67 @@ class CommandRegistry:
             ModelCommand,
             InitCommand,
             TemplateCommand,
-            TodoCommand,
+            CommandReloadCommand,
+            QuickStartCommand,  # Add quickstart command
         ]
 
         # Register all discovered commands
         for command_class in command_classes:
             self.register_command_class(command_class)  # type: ignore[arg-type]
 
-        self._discovered = True
+    def _discover_slash_commands(self) -> None:
+        """Discover and register markdown-based slash commands."""
+        try:
+            if not self._slash_loader:
+                # Dynamic import to avoid circular dependency
+                from .slash.loader import SlashCommandLoader
+
+                project_root = Path.cwd()
+                user_home = Path.home()
+                self._slash_loader = SlashCommandLoader(project_root, user_home)
+
+            self._slash_discovery_result = self._slash_loader.discover_commands()
+
+            # Register all discovered commands
+            registered_count = 0
+            for command_name, command in self._slash_discovery_result.commands.items():
+                try:
+                    self.register(command)
+                    registered_count += 1
+                except Exception as e:
+                    logger.warning(f"Failed to register slash command '{command_name}': {e}")
+
+            # Log discovery summary
+            if registered_count > 0:
+                logger.info(f"Registered {registered_count} slash commands")
+
+            # Report conflicts and errors
+            self._report_slash_command_issues()
+
+        except Exception as e:
+            logger.error(f"Slash command discovery failed: {e}")
+            # Don't fail the entire system if slash commands can't load
+
+    def _report_slash_command_issues(self) -> None:
+        """Report conflicts and errors from slash command discovery."""
+        if not self._slash_discovery_result:
+            return
+
+        # Report conflicts
+        if self._slash_discovery_result.conflicts:
+            logger.info(f"Resolved {len(self._slash_discovery_result.conflicts)} command conflicts")
+            for cmd_name, conflicting_paths in self._slash_discovery_result.conflicts:
+                logger.debug(
+                    f"  {cmd_name}: {conflicting_paths[1]} overrode {conflicting_paths[0]}"
+                )
+
+        # Report errors (limit to first 3 for brevity)
+        if self._slash_discovery_result.errors:
+            logger.warning(
+                f"Failed to load {len(self._slash_discovery_result.errors)} command files"
+            )
+            for path, error in self._slash_discovery_result.errors[:3]:
+                logger.warning(f"  {path}: {str(error)[:100]}...")
 
     def register_all_default_commands(self) -> None:
         """Register all default commands (backward compatibility)."""
@@ -222,7 +298,7 @@ class CommandRegistry:
 
     def find_matching_commands(self, partial_command: str) -> List[str]:
         """
-        Find all commands that start with the given partial command.
+        Find commands matching the given partial command.
 
         Args:
             partial_command: The partial command to match
@@ -232,7 +308,13 @@ class CommandRegistry:
         """
         self.discover_commands()
         partial = partial_command.lower()
-        return [cmd for cmd in self._commands.keys() if cmd.startswith(partial)]
+
+        # CLAUDE_ANCHOR[key=86cc1a41] Prefix-only command matching after removing fuzzy fallback
+        prefix_matches = [cmd for cmd in self._commands.keys() if cmd.startswith(partial)]
+        if prefix_matches:
+            return prefix_matches
+
+        return []
 
     def is_command(self, text: str) -> bool:
         """Check if text starts with a registered command (supports partial matching)."""
@@ -266,3 +348,55 @@ class CommandRegistry:
         """Get all commands organized by category."""
         self.discover_commands()
         return self._categories.copy()
+
+    # Slash command utilities
+    def get_slash_commands(self) -> Dict[str, Command]:
+        """Get all registered slash commands."""
+        slash_commands = {}
+        for name, command in self._commands.items():
+            # Duck typing for SlashCommand - check if it has file_path attribute
+            if hasattr(command, "file_path") and hasattr(command, "namespace"):
+                slash_commands[name] = command
+        return slash_commands
+
+    def reload_slash_commands(self) -> int:
+        """Reload slash commands (useful for development)."""
+        if not self._slash_enabled:
+            return 0
+
+        slash_commands = self.get_slash_commands()
+        for cmd_name in list(slash_commands.keys()):
+            if cmd_name in self._commands:
+                del self._commands[cmd_name]
+                # Also remove from category
+                for category_commands in self._categories.values():
+                    category_commands[:] = [
+                        cmd
+                        for cmd in category_commands
+                        if not (hasattr(cmd, "file_path") and cmd.name == cmd_name)
+                    ]
+
+        # Rediscover slash commands
+        self._slash_loader = None
+        self._slash_discovery_result = None
+        self._discover_slash_commands()
+
+        return len(self.get_slash_commands())
+
+    def enable_slash_commands(self, enabled: bool = True) -> None:
+        """Enable or disable slash command discovery."""
+        self._slash_enabled = enabled
+
+    def get_slash_command_stats(self) -> Dict[str, Any]:
+        """Get detailed statistics about slash command discovery."""
+        if not self._slash_discovery_result:
+            return {"enabled": self._slash_enabled, "discovered": False}
+
+        return {
+            "enabled": self._slash_enabled,
+            "discovered": True,
+            "stats": self._slash_discovery_result.stats,
+            "conflicts": len(self._slash_discovery_result.conflicts),
+            "errors": len(self._slash_discovery_result.errors),
+            "registered_commands": len(self.get_slash_commands()),
+        }

tunacode/cli/commands/slash/__init__.py

@@ -0,0 +1,32 @@
+"""Slash command system for TunaCode.
+
+This module provides extensible markdown-based custom commands that can be
+created by users and shared across teams.
+"""
+
+# Only export the main classes that external code needs
+from .types import (
+    CommandDiscoveryResult,
+    CommandSource,
+    ContextInjectionResult,
+    SecurityLevel,
+    SecurityViolation,
+    SlashCommandMetadata,
+    ValidationResult,
+)
+
+__all__ = [
+    "CommandSource",
+    "SlashCommandMetadata",
+    "CommandDiscoveryResult",
+    "ContextInjectionResult",
+    "SecurityLevel",
+    "SecurityViolation",
+    "ValidationResult",
+]
+
+# Other classes can be imported directly when needed:
+# from .command import SlashCommand
+# from .loader import SlashCommandLoader
+# from .processor import MarkdownTemplateProcessor
+# from .validator import CommandValidator

tunacode/cli/commands/slash/command.py

@@ -0,0 +1,157 @@
+"""SlashCommand implementation for markdown-based commands."""
+
+import logging
+from pathlib import Path
+from typing import TYPE_CHECKING, List, Optional
+
+from ..base import Command, CommandCategory
+from .processor import MarkdownTemplateProcessor
+from .types import SlashCommandMetadata
+
+if TYPE_CHECKING:
+    from ....types import CommandArgs, CommandContext, CommandResult
+
+logger = logging.getLogger(__name__)
+
+
+class SlashCommand(Command):
+    """Markdown-based slash command implementation."""
+
+    def __init__(self, file_path: Path, namespace: str, command_parts: List[str]):
+        self.file_path = file_path
+        self.namespace = namespace  # "project" or "user"
+        self.command_parts = command_parts  # ["test", "unit"] for test:unit
+        self._metadata: Optional[SlashCommandMetadata] = None
+        self._content: Optional[str] = None
+        self._loaded = False
+
+    def _lazy_load(self) -> None:
+        """Load content and metadata on first access."""
+        if self._loaded:
+            return
+
+        try:
+            content = self.file_path.read_text(encoding="utf-8")
+            processor = MarkdownTemplateProcessor()
+            frontmatter, markdown = processor.parse_frontmatter(content)
+
+            self._content = markdown
+            self._metadata = SlashCommandMetadata(
+                description=frontmatter.get("description", "Custom command")
+                if frontmatter
+                else "Custom command",
+                allowed_tools=frontmatter.get("allowed-tools") if frontmatter else None,
+                timeout=frontmatter.get("timeout") if frontmatter else None,
+                parameters=frontmatter.get("parameters", {}) if frontmatter else {},
+            )
+            self._loaded = True
+
+        except Exception as e:
+            logger.error(f"Failed to load slash command {self.file_path}: {e}")
+            self._metadata = SlashCommandMetadata(description=f"Error loading command: {str(e)}")
+            self._content = ""
+            self._loaded = True
+
+    @property
+    def name(self) -> str:
+        """The primary name of the command."""
+        return f"{self.namespace}:{':'.join(self.command_parts)}"
+
+    @property
+    def aliases(self) -> List[str]:
+        """Alternative names/aliases for the command."""
+        return [f"/{self.name}"]  # Slash prefix for invocation
+
+    @property
+    def description(self) -> str:
+        """Description of what the command does."""
+        self._lazy_load()
+        return self._metadata.description if self._metadata else "Custom command"
+
+    @property
+    def category(self) -> CommandCategory:
+        """Category this command belongs to."""
+        return CommandCategory.SYSTEM  # Could be made configurable
+
+    async def execute(self, args: "CommandArgs", context: "CommandContext") -> "CommandResult":
+        """Execute the slash command."""
+        self._lazy_load()
+
+        if not self._content:
+            return "Error: Could not load command content"
+
+        # Process template with context injection
+        max_context_size = 100_000
+        max_files = 50
+        if self._metadata and self._metadata.parameters:
+            max_context_size = int(self._metadata.parameters.get("max_context_size", 100_000))
+            max_files = int(self._metadata.parameters.get("max_files", 50))
+
+        processor = MarkdownTemplateProcessor(
+            max_context_size=max_context_size, max_files=max_files
+        )
+
+        injection_result = processor.process_template_with_context(self._content, args, context)
+
+        # Show warnings if any (import ui dynamically to avoid circular imports)
+        if injection_result.warnings:
+            try:
+                from ....ui import console as ui
+
+                for warning in injection_result.warnings:
+                    await ui.warning(f"Context injection: {warning}")
+            except ImportError:
+                # Fallback to logging if UI not available
+                for warning in injection_result.warnings:
+                    logger.warning(f"Context injection: {warning}")
+
+        # Show context stats for debugging (if enabled)
+        try:
+            if context.state_manager.session.show_thoughts:
+                from ....ui import console as ui
+
+                await ui.muted(
+                    f"Context: {len(injection_result.included_files)} files, "
+                    f"{injection_result.total_size} chars, "
+                    f"{len(injection_result.executed_commands)} commands"
+                )
+        except (ImportError, AttributeError):
+            pass  # Skip context stats if not available
+
+        # Apply tool restrictions if specified
+        if self._metadata and self._metadata.allowed_tools:
+            # Set tool handler restrictions similar to template system
+            if (
+                hasattr(context.state_manager, "tool_handler")
+                and context.state_manager.tool_handler
+            ):
+                # Store current restrictions and apply new ones
+                original_restrictions = getattr(
+                    context.state_manager.tool_handler, "allowed_tools", None
+                )
+                context.state_manager.tool_handler.allowed_tools = self._metadata.allowed_tools
+
+                try:
+                    # Execute with restrictions
+                    if context.process_request:
+                        result = await context.process_request(
+                            injection_result.processed_content, context.state_manager, True
+                        )
+                        return result
+                    else:
+                        return "Error: No process_request callback available"
+                finally:
+                    # Restore original restrictions
+                    context.state_manager.tool_handler.allowed_tools = original_restrictions
+        else:
+            # Execute without restrictions
+            if context.process_request:
+                result = await context.process_request(
+                    injection_result.processed_content, context.state_manager, True
+                )
+                return result
+            else:
+                return "Error: No process_request callback available"
+
+        # Default return if no metadata
+        return "Command executed"

tunacode/cli/commands/slash/loader.py

@@ -0,0 +1,135 @@
+"""SlashCommandLoader for discovering and loading markdown-based commands."""
+
+import logging
+from pathlib import Path
+from typing import Any, Dict, List, Tuple
+
+from .command import SlashCommand
+from .types import CommandDiscoveryResult, CommandSource
+
+logger = logging.getLogger(__name__)
+
+
+class SlashCommandLoader:
+    """Discovers and loads markdown-based slash commands with precedence rules."""
+
+    def __init__(self, project_root: Path, user_home: Path):
+        self.project_root = project_root
+        self.user_home = user_home
+        self.directories = self._build_directory_list()
+        self._cache: Dict[str, SlashCommand] = {}
+
+    def _build_directory_list(self) -> List[Tuple[Path, CommandSource, str]]:
+        """Build prioritized directory list with sources and namespaces."""
+        return [
+            (
+                self.project_root / ".tunacode" / "commands",
+                CommandSource.PROJECT_TUNACODE,
+                "project",
+            ),
+            (self.project_root / ".claude" / "commands", CommandSource.PROJECT_CLAUDE, "project"),
+            (self.user_home / ".tunacode" / "commands", CommandSource.USER_TUNACODE, "user"),
+            (self.user_home / ".claude" / "commands", CommandSource.USER_CLAUDE, "user"),
+        ]
+
+    def discover_commands(self) -> CommandDiscoveryResult:
+        """Main discovery method with conflict resolution."""
+        all_commands: Dict[str, Any] = {}
+        conflicts = []
+        errors = []
+        stats = {"scanned_dirs": 0, "found_files": 0, "loaded_commands": 0}
+
+        for directory, source, namespace in self.directories:
+            if not directory.exists():
+                continue
+
+            stats["scanned_dirs"] += 1
+
+            try:
+                dir_commands = self._scan_directory(directory, source, namespace)
+                stats["found_files"] += len(dir_commands)
+
+                # Handle conflicts with precedence
+                for cmd_name, cmd in dir_commands.items():
+                    if cmd_name in all_commands:
+                        existing_cmd = all_commands[cmd_name]
+                        # Lower source value = higher priority
+                        if (
+                            source.value < existing_cmd._metadata.source.value
+                            if existing_cmd._metadata
+                            else float("inf")
+                        ):
+                            conflicts.append((cmd_name, [existing_cmd.file_path, cmd.file_path]))
+                            all_commands[cmd_name] = cmd
+                            logger.info(f"Command '{cmd_name}' overridden by {source.name}")
+                    else:
+                        all_commands[cmd_name] = cmd
+
+                stats["loaded_commands"] += len(
+                    [c for c in dir_commands.values() if c.name in all_commands]
+                )
+
+            except Exception as e:
+                errors.append((directory, e))
+                logger.error(f"Error scanning {directory}: {e}")
+
+        logger.info(
+            f"Discovered {len(all_commands)} slash commands from "
+            f"{stats['scanned_dirs']} directories"
+        )
+        return CommandDiscoveryResult(all_commands, conflicts, errors, stats)
+
+    def _scan_directory(
+        self, directory: Path, source: CommandSource, namespace: str
+    ) -> Dict[str, SlashCommand]:
+        """Recursively scan directory for markdown files."""
+        commands = {}
+
+        for md_file in directory.rglob("*.md"):
+            try:
+                # Calculate command parts from file path
+                relative_path = md_file.relative_to(directory)
+                command_parts = list(relative_path.parts[:-1])  # Directories
+                command_parts.append(relative_path.stem)  # Filename without .md
+
+                # Create command
+                command = SlashCommand(md_file, namespace, command_parts)
+                # Set source in metadata (will be used for precedence)
+                if not hasattr(command, "_metadata") or command._metadata is None:
+                    from .types import SlashCommandMetadata
+
+                    command._metadata = SlashCommandMetadata(description="", source=source)
+                else:
+                    command._metadata.source = source
+
+                command_name = command.name
+                commands[command_name] = command
+
+            except Exception as e:
+                logger.warning(f"Failed to load command from {md_file}: {e}")
+
+        return commands
+
+    def reload_commands(self) -> CommandDiscoveryResult:
+        """Reload all commands (useful for development)."""
+        self._cache.clear()
+        return self.discover_commands()
+
+    def get_command_by_path(self, file_path: Path) -> SlashCommand:
+        """Get command for a specific file path."""
+        # Determine namespace and command parts from path
+        for directory, source, namespace in self.directories:
+            try:
+                if file_path.is_relative_to(directory):
+                    relative_path = file_path.relative_to(directory)
+                    command_parts = list(relative_path.parts[:-1])
+                    command_parts.append(relative_path.stem)
+
+                    command = SlashCommand(file_path, namespace, command_parts)
+                    return command
+            except (ValueError, AttributeError):
+                continue
+
+        # Fallback to project namespace if path not in known directories
+        parts = file_path.stem.split("_") if file_path.stem else ["unknown"]
+        return SlashCommand(file_path, "project", parts)