tunacode-cli 0.0.66__py3-none-any.whl → 0.0.68__py3-none-any.whl

tunacode/cli/commands/__init__.py

@@ -18,6 +18,7 @@ from .base import Command, CommandCategory, CommandSpec, SimpleCommand
 from .implementations import (
     BranchCommand,
     ClearCommand,
+    CommandReloadCommand,
     CompactCommand,
     DumpCommand,
     FixCommand,
@@ -63,4 +64,5 @@ __all__ = [
     "ModelCommand",
     "InitCommand",
     "TodoCommand",
+    "CommandReloadCommand",
 ]

tunacode/cli/commands/implementations/__init__.py

@@ -1,6 +1,7 @@
 """Command implementations for TunaCode CLI."""
 
 # Import all command classes for easy access
+from .command_reload import CommandReloadCommand
 from .conversation import CompactCommand
 from .debug import (
     DumpCommand,
@@ -28,6 +29,7 @@ __all__ = [
     "RefreshConfigCommand",
     "StreamingCommand",
     "UpdateCommand",
+    "CommandReloadCommand",
     # Debug commands
     "YoloCommand",
     "DumpCommand",

tunacode/cli/commands/implementations/command_reload.py

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

tunacode/cli/commands/implementations/quickstart.py

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

tunacode/cli/commands/implementations/system.py

@@ -143,6 +143,21 @@ class UpdateCommand(SimpleCommand):
                     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:
@@ -160,10 +175,11 @@ 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"
+                "  venv:    uv pip install --python ~/.tunacode-venv/bin/python --upgrade tunacode-cli"
             )
             return
 
@@ -206,6 +222,14 @@ class UpdateCommand(SimpleCommand):
                         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/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,
@@ -24,6 +27,7 @@ from .implementations.debug import (
 from .implementations.development import BranchCommand, InitCommand
 from .implementations.model import ModelCommand
 from .implementations.plan import ExitPlanCommand, PlanCommand
+from .implementations.quickstart import QuickStartCommand
 from .implementations.system import (
     ClearCommand,
     HelpCommand,
@@ -35,6 +39,8 @@ from .implementations.template import TemplateCommand
 from .implementations.todo import TodoCommand
 from .template_shortcut import TemplateShortcutCommand
 
+logger = logging.getLogger(__name__)
+
 
 @dataclass
 class CommandDependencies:
@@ -57,6 +63,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()
@@ -80,6 +88,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)
 
@@ -111,6 +124,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,
@@ -130,15 +154,69 @@ class CommandRegistry:
             InitCommand,
             TemplateCommand,
             TodoCommand,
+            CommandReloadCommand,
             PlanCommand,  # Add plan command
             ExitPlanCommand,  # Add exit plan command
+            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)."""
@@ -269,3 +347,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"