tunacode-cli 0.0.67__py3-none-any.whl → 0.0.69__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/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"

tunacode/cli/commands/slash/loader.py

@@ -0,0 +1,134 @@
+"""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 {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)