minion-code 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

minion_code/commands/__init__.py

@@ -5,31 +5,73 @@ Command system for MinionCode TUI
 
 This module provides a command system similar to Claude Code or Gemini CLI,
 where commands are prefixed with '/' and each command is implemented in a separate file.
+
+Command Types:
+- LOCAL: Direct execution, returns result immediately (e.g., /clear, /help)
+- LOCAL_JSX: Requires UI interaction, returns a component (e.g., /config, /model)
+- PROMPT: Replaces user input and sends to LLM (e.g., /bug, custom .md commands)
 """
 
 import importlib
 import pkgutil
-from typing import Dict, Type, Optional
+from typing import Dict, Type, Optional, Union
 from abc import ABC, abstractmethod
+from enum import Enum
+
+
+class CommandType(Enum):
+    """Types of commands based on execution flow."""
+
+    LOCAL = "local"  # Direct execution, returns result
+    LOCAL_JSX = "local_jsx"  # Requires UI interaction
+    PROMPT = "prompt"  # Replaces user input, sends to LLM
 
 
 class BaseCommand(ABC):
     """Base class for all commands."""
-    
+
     name: str = ""
     description: str = ""
     usage: str = ""
     aliases: list = []
-    
-    def __init__(self, console, agent=None):
-        self.console = console
+    command_type: CommandType = CommandType.LOCAL  # Default to LOCAL
+    is_skill: bool = False  # Whether this is a skill (affects display)
+
+    def __init__(self, output, agent=None):
+        """
+        Initialize command.
+
+        Args:
+            output: OutputAdapter instance for UI output (RichAdapter or TextualAdapter)
+            agent: Optional agent instance
+        """
+        self.output = output
         self.agent = agent
-    
+
+        # Backward compatibility: expose console attribute for Rich adapter
+        # This allows old code using self.console to still work
+        if hasattr(output, "console"):
+            self.console = output.console
+
     @abstractmethod
     async def execute(self, args: str) -> None:
         """Execute the command with given arguments."""
         pass
-    
+
+    async def get_prompt(self, args: str) -> str:
+        """
+        Get the expanded prompt for PROMPT type commands.
+        Override this method for PROMPT type commands.
+
+        Args:
+            args: Command arguments from user input
+
+        Returns:
+            Expanded prompt string to send to LLM
+        """
+        # Default implementation just returns the args
+        return args
+
     def get_help(self) -> str:
         """Get help text for this command."""
         return f"**/{self.name}** - {self.description}\n\nUsage: {self.usage}"
@@ -37,54 +79,119 @@ class BaseCommand(ABC):
 
 class CommandRegistry:
     """Registry for managing commands."""
-    
+
     def __init__(self):
         self.commands: Dict[str, Type[BaseCommand]] = {}
+        self._skills_loaded = False
         self._load_commands()
-    
+
     def _load_commands(self):
         """Dynamically load all command modules."""
         import os
+
         commands_dir = os.path.dirname(__file__)
-        
+
         for filename in os.listdir(commands_dir):
-            if filename.endswith('_command.py') and not filename.startswith('_'):
+            if filename.endswith("_command.py") and not filename.startswith("_"):
+                # Skip skill_command.py as it's loaded dynamically
+                if filename == "skill_command.py":
+                    continue
+
                 modname = filename[:-3]  # Remove .py extension
                 try:
-                    module = importlib.import_module(f'minion_code.commands.{modname}')
-                    
+                    module = importlib.import_module(f"minion_code.commands.{modname}")
+
                     # Look for command classes in the module
                     for attr_name in dir(module):
                         attr = getattr(module, attr_name)
-                        if (isinstance(attr, type) and 
-                            issubclass(attr, BaseCommand) and 
-                            attr != BaseCommand and
-                            hasattr(attr, 'name') and attr.name):
-                            
+                        if (
+                            isinstance(attr, type)
+                            and issubclass(attr, BaseCommand)
+                            and attr != BaseCommand
+                            and hasattr(attr, "name")
+                            and attr.name
+                        ):
+
                             self.commands[attr.name] = attr
-                            
+
                             # Register aliases
-                            for alias in getattr(attr, 'aliases', []):
+                            for alias in getattr(attr, "aliases", []):
                                 self.commands[alias] = attr
-                                
+
                 except ImportError as e:
                     print(f"Failed to load command module {modname}: {e}")
-    
+
+    def _load_skills(self):
+        """Load skills as commands."""
+        if self._skills_loaded:
+            return
+
+        try:
+            from minion_code.skills.skill_loader import load_skills
+            from minion_code.commands.skill_command import create_skill_command
+
+            registry = load_skills()
+            for skill in registry.list_all():
+                # Create a command class for each skill
+                skill_cmd_class = create_skill_command(skill)
+                self.commands[skill.name] = skill_cmd_class
+
+            self._skills_loaded = True
+        except ImportError as e:
+            print(f"Failed to load skills: {e}")
+
     def get_command(self, name: str) -> Optional[Type[BaseCommand]]:
         """Get a command class by name."""
+        # Try to load skills if command not found
+        if name not in self.commands and not self._skills_loaded:
+            self._load_skills()
         return self.commands.get(name)
-    
+
     def list_commands(self) -> Dict[str, Type[BaseCommand]]:
-        """List all available commands."""
-        # Return only primary commands (not aliases)
-        return {name: cmd for name, cmd in self.commands.items() 
-                if cmd.name == name}
-    
+        """List all available commands (excluding skills)."""
+        # Return only primary commands (not aliases, not skills)
+        return {
+            name: cmd
+            for name, cmd in self.commands.items()
+            if cmd.name == name and not getattr(cmd, "is_skill", False)
+        }
+
+    def list_skills(self) -> Dict[str, Type[BaseCommand]]:
+        """List all available skills as commands."""
+        # Ensure skills are loaded
+        if not self._skills_loaded:
+            self._load_skills()
+        return {
+            name: cmd
+            for name, cmd in self.commands.items()
+            if cmd.name == name and getattr(cmd, "is_skill", False)
+        }
+
+    def list_all(self) -> Dict[str, Type[BaseCommand]]:
+        """List all available commands and skills."""
+        if not self._skills_loaded:
+            self._load_skills()
+        return {name: cmd for name, cmd in self.commands.items() if cmd.name == name}
+
     def reload_commands(self):
         """Reload all commands."""
         self.commands.clear()
+        self._skills_loaded = False
         self._load_commands()
 
+    def reload_skills(self):
+        """Reload skills only."""
+        # Remove existing skill commands
+        skills_to_remove = [
+            name
+            for name, cmd in self.commands.items()
+            if getattr(cmd, "is_skill", False)
+        ]
+        for name in skills_to_remove:
+            del self.commands[name]
+        self._skills_loaded = False
+        self._load_skills()
+
 
 # Global command registry
-command_registry = CommandRegistry()
+command_registry = CommandRegistry()

minion_code/commands/clear_command.py

@@ -4,67 +4,40 @@
 Clear command - Clear conversation history
 """
 
-from rich.panel import Panel
-from rich.prompt import Confirm
-from minion_code.commands import BaseCommand
+from minion_code.commands import BaseCommand, CommandType
 
 
 class ClearCommand(BaseCommand):
     """Clear conversation history."""
-    
+
     name = "clear"
     description = "Clear the conversation history"
-    usage = "/clear [--force]"
+    usage = "/clear"
     aliases = ["c", "reset"]
-    
+    command_type = CommandType.LOCAL
+
     async def execute(self, args: str) -> None:
         """Execute the clear command."""
         if not self.agent:
-            error_panel = Panel(
-                "❌ [bold red]Agent not initialized[/bold red]",
-                title="[bold red]Error[/bold red]",
-                border_style="red"
+            self.output.panel(
+                "❌ Agent not initialized", title="Error", border_style="red"
             )
-            self.console.print(error_panel)
             return
-        
-        force = "--force" in args or "-f" in args
-        
+
         history = self.agent.get_conversation_history()
         if not history:
-            no_history_panel = Panel(
-                "📝 [italic]No conversation history to clear.[/italic]",
-                title="[bold blue]Info[/bold blue]",
-                border_style="blue"
+            self.output.panel(
+                "📝 No conversation history to clear.",
+                title="Info",
+                border_style="blue",
             )
-            self.console.print(no_history_panel)
             return
-        
-        # Confirm before clearing unless --force is used
-        if not force:
-            confirm_panel = Panel(
-                f"⚠️ [bold yellow]This will clear {len(history)} messages from history.[/bold yellow]\n"
-                "This action cannot be undone.",
-                title="[bold yellow]Confirm Clear[/bold yellow]",
-                border_style="yellow"
-            )
-            self.console.print(confirm_panel)
-            
-            if not Confirm.ask("Are you sure you want to clear the history?", console=self.console):
-                cancel_panel = Panel(
-                    "❌ [bold blue]Clear operation cancelled.[/bold blue]",
-                    title="[bold blue]Cancelled[/bold blue]",
-                    border_style="blue"
-                )
-                self.console.print(cancel_panel)
-                return
-        
-        # Clear the history
+
+        # Clear the history directly without confirmation
         self.agent.clear_conversation_history()
-        
-        success_panel = Panel(
-            f"🗑️ [bold green]Successfully cleared {len(history)} messages from history.[/bold green]",
-            title="[bold green]History Cleared[/bold green]",
-            border_style="green"
+
+        self.output.panel(
+            f"🗑️ Successfully cleared {len(history)} messages from history.",
+            title="History Cleared",
+            border_style="green",
         )
-        self.console.print(success_panel)

minion_code/commands/help_command.py

@@ -4,87 +4,71 @@
 Help command - Show available commands and their usage
 """
 
-from rich.table import Table
-from rich.panel import Panel
-from rich.markdown import Markdown
-from minion_code.commands import BaseCommand
+from minion_code.commands import BaseCommand, CommandType
 
 
 class HelpCommand(BaseCommand):
     """Show help information for commands."""
-    
+
     name = "help"
     description = "Show available commands and their usage"
     usage = "/help [command_name]"
     aliases = ["h", "?"]
-    
+    command_type = CommandType.LOCAL
+
     async def execute(self, args: str) -> None:
         """Execute the help command."""
         args = args.strip()
-        
+
         if args:
             # Show help for specific command
             await self._show_command_help(args)
         else:
             # Show general help
             await self._show_general_help()
-    
+
     async def _show_command_help(self, command_name: str) -> None:
         """Show help for a specific command."""
         from minion_code.commands import command_registry
-        
+
         command_class = command_registry.get_command(command_name)
         if not command_class:
-            error_panel = Panel(
-                f"❌ [bold red]Command '/{command_name}' not found[/bold red]",
-                title="[bold red]Error[/bold red]",
-                border_style="red"
+            self.output.panel(
+                f"❌ Command '/{command_name}' not found",
+                title="Error",
+                border_style="red",
             )
-            self.console.print(error_panel)
             return
-        
+
         # Create temporary command instance to get help
-        temp_command = command_class(self.console, self.agent)
+        temp_command = command_class(self.output, self.agent)
         help_text = temp_command.get_help()
-        
-        help_panel = Panel(
-            Markdown(help_text),
-            title=f"[bold blue]Help: /{command_name}[/bold blue]",
-            border_style="blue"
+
+        self.output.panel(
+            help_text, title=f"Help: /{command_name}", border_style="blue"
         )
-        self.console.print(help_panel)
-    
+
     async def _show_general_help(self) -> None:
         """Show general help with all commands."""
         from minion_code.commands import command_registry
-        
+
         commands = command_registry.list_commands()
-        
-        help_table = Table(
-            title="📚 Available Commands", 
-            show_header=True, 
-            header_style="bold blue"
-        )
-        help_table.add_column("Command", style="cyan", no_wrap=True)
-        help_table.add_column("Description", style="white")
-        help_table.add_column("Aliases", style="yellow")
-        
+
+        # Prepare table data
+        headers = ["Command", "Description", "Aliases"]
+        rows = []
+
         for name, command_class in sorted(commands.items()):
             aliases = ", ".join(f"/{alias}" for alias in command_class.aliases)
-            help_table.add_row(
-                f"/{name}",
-                command_class.description,
-                aliases or "-"
-            )
-        
-        self.console.print(help_table)
-        
+            rows.append([f"/{name}", command_class.description, aliases or "-"])
+
+        self.output.table(headers, rows, title="📚 Available Commands")
+
         # Show usage info
-        usage_panel = Panel(
-            "💡 [italic]Commands must start with '/' (e.g., /help, /tools)[/italic]\n"
-            "💬 [italic]Regular messages are sent to the AI agent[/italic]\n"
-            "🔍 [italic]Use '/help <command>' for detailed help on a specific command[/italic]",
-            title="[bold green]Usage Tips[/bold green]",
-            border_style="green"
+        self.output.panel(
+            "💡 Commands must start with '/' (e.g., /help, /tools)\n"
+            "💬 Regular messages are sent to the AI agent\n"
+            "🔍 Use '/help <command>' for detailed help on a specific command",
+            title="Usage Tips",
+            border_style="green",
         )
-        self.console.print(usage_panel)

minion_code/commands/history_command.py

@@ -4,30 +4,26 @@
 History command - Show conversation history
 """
 
-from rich.panel import Panel
-from rich.table import Table
-from minion_code.commands import BaseCommand
+from minion_code.commands import BaseCommand, CommandType
 
 
 class HistoryCommand(BaseCommand):
     """Show conversation history."""
-    
+
     name = "history"
     description = "Show conversation history with the agent"
     usage = "/history [count]"
     aliases = ["hist", "h"]
-    
+    command_type = CommandType.LOCAL
+
     async def execute(self, args: str) -> None:
         """Execute the history command."""
         if not self.agent:
-            error_panel = Panel(
-                "❌ [bold red]Agent not initialized[/bold red]",
-                title="[bold red]Error[/bold red]",
-                border_style="red"
+            self.output.panel(
+                "❌ Agent not initialized", title="Error", border_style="red"
             )
-            self.console.print(error_panel)
             return
-        
+
         # Parse count argument
         count = 5  # default
         if args.strip():
@@ -36,69 +32,55 @@ class HistoryCommand(BaseCommand):
                 if count <= 0:
                     count = 5
             except ValueError:
-                error_panel = Panel(
-                    f"❌ [bold red]Invalid count: '{args.strip()}'. Using default (5)[/bold red]",
-                    title="[bold red]Warning[/bold red]",
-                    border_style="yellow"
+                self.output.panel(
+                    f"❌ Invalid count: '{args.strip()}'. Using default (5)",
+                    title="Warning",
+                    border_style="yellow",
                 )
-                self.console.print(error_panel)
-        
+
         history = self.agent.get_conversation_history()
         if not history:
-            no_history_panel = Panel(
-                "📝 [italic]No conversation history yet.[/italic]",
-                title="[bold blue]History[/bold blue]",
-                border_style="blue"
+            self.output.panel(
+                "📝 No conversation history yet.", title="History", border_style="blue"
             )
-            self.console.print(no_history_panel)
             return
-        
+
         # Show header
-        header_panel = Panel(
-            f"📝 [bold blue]Conversation History (showing last {min(count, len(history))} of {len(history)} messages)[/bold blue]",
-            border_style="blue"
+        self.output.panel(
+            f"📝 Conversation History (showing last {min(count, len(history))} of {len(history)} messages)",
+            border_style="blue",
         )
-        self.console.print(header_panel)
-        
+
         # Show recent messages
         recent_history = history[-count:] if count < len(history) else history
-        
+
         for i, entry in enumerate(recent_history, 1):
             message_num = len(history) - len(recent_history) + i
-            
+
             # User message
-            user_msg = entry['user_message']
+            user_msg = entry["user_message"]
             if len(user_msg) > 150:
                 user_msg = user_msg[:150] + "..."
-            
-            user_panel = Panel(
-                user_msg,
-                title=f"👤 [bold cyan]You (#{message_num})[/bold cyan]",
-                border_style="cyan"
+
+            self.output.panel(
+                user_msg, title=f"👤 You (#{message_num})", border_style="cyan"
             )
-            self.console.print(user_panel)
-            
+
             # Agent response
-            agent_msg = entry['agent_response']
+            agent_msg = entry["agent_response"]
             if len(agent_msg) > 200:
                 agent_msg = agent_msg[:200] + "..."
-            
-            agent_panel = Panel(
-                agent_msg,
-                title="🤖 [bold green]Agent[/bold green]",
-                border_style="green"
-            )
-            self.console.print(agent_panel)
-            
+
+            self.output.panel(agent_msg, title="🤖 Agent", border_style="green")
+
             if i < len(recent_history):  # Don't add spacing after last message
-                self.console.print()
-        
+                self.output.text("")
+
         # Show summary if there are more messages
         if len(history) > count:
-            summary_panel = Panel(
-                f"💡 [italic]Showing {count} most recent messages. "
-                f"Use '/history {len(history)}' to see all {len(history)} messages.[/italic]",
-                title="[bold yellow]Note[/bold yellow]",
-                border_style="yellow"
+            self.output.panel(
+                f"💡 Showing {count} most recent messages. "
+                f"Use '/history {len(history)}' to see all {len(history)} messages.",
+                title="Note",
+                border_style="yellow",
             )
-            self.console.print(summary_panel)