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

minion_code/commands/model_command.py

@@ -0,0 +1,194 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Model command - View and configure the LLM model
+"""
+
+import json
+import yaml
+from pathlib import Path
+from typing import List, Optional
+from minion_code.commands import BaseCommand, CommandType
+
+
+class ModelCommand(BaseCommand):
+    """View or set the default LLM model."""
+
+    name = "model"
+    description = "View or set the default LLM model"
+    usage = "/model [model_name] or /model --clear or /model --list"
+    aliases = ["llm"]
+    command_type = CommandType.LOCAL
+
+    # Config file path
+    CONFIG_DIR = Path.home() / ".minion"
+    CONFIG_FILE = CONFIG_DIR / "minion-code.json"
+    MINION_CONFIG_FILE = CONFIG_DIR / "config.yaml"
+
+    def _load_config(self) -> dict:
+        """Load config from file."""
+        if self.CONFIG_FILE.exists():
+            try:
+                with open(self.CONFIG_FILE, "r") as f:
+                    return json.load(f)
+            except Exception:
+                pass
+        return {}
+
+    def _save_config(self, config: dict) -> None:
+        """Save config to file."""
+        self.CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+        with open(self.CONFIG_FILE, "w") as f:
+            json.dump(config, f, indent=2)
+
+    def _get_available_models(self) -> List[str]:
+        """Get list of available models from minion config.yaml.
+
+        Uses the same logic as minion's load_config():
+        1. First load user config (~/.minion/config.yaml)
+        2. Then load base config (MINION_ROOT/config/config.yaml) which OVERWRITES user config
+        """
+        config_dict = {}
+
+        # First load user config
+        if self.MINION_CONFIG_FILE.exists():
+            try:
+                with open(self.MINION_CONFIG_FILE, "r") as f:
+                    config_dict = yaml.safe_load(f) or {}
+            except Exception:
+                pass
+
+        # Then load base config (MINION_ROOT), which overwrites user config
+        try:
+            from minion.const import get_minion_root
+
+            minion_root = get_minion_root()
+            base_config_path = Path(minion_root) / "config" / "config.yaml"
+            if base_config_path.exists():
+                with open(base_config_path, "r") as f:
+                    base_config = yaml.safe_load(f) or {}
+                config_dict.update(base_config)  # Overwrite, same as minion
+        except Exception:
+            pass
+
+        models = list(config_dict.get("models", {}).keys())
+        return sorted(models)
+
+    def _update_agent_model(self, model_name: str) -> bool:
+        """Update the agent's model at runtime."""
+        if not self.agent:
+            return False
+
+        try:
+            from minion.types.llm_types import create_llm_from_model
+
+            # Create new LLM provider with the new model
+            new_llm = create_llm_from_model(model_name)
+            self.agent.llm = new_llm
+
+            # Update llms dict if it exists
+            if hasattr(self.agent, "llms"):
+                self.agent.llms["main"] = new_llm
+
+            return True
+        except Exception as e:
+            self.output.warning(f"Could not update runtime model: {e}")
+            return False
+
+    def _set_model(self, model_name: str) -> None:
+        """Set the model and update config."""
+        config = self._load_config()
+        config["model"] = model_name
+        self._save_config(config)
+
+        # Try to update the running agent's model
+        runtime_updated = self._update_agent_model(model_name)
+
+        if runtime_updated:
+            self.output.success(f"Model changed to: {model_name}")
+        else:
+            self.output.success(f"Default model set to: {model_name}")
+            self.output.warning("Restart session to use the new model.")
+
+        self.output.info(f"Config saved to: {self.CONFIG_FILE}")
+
+    async def execute(self, args: str) -> None:
+        """Execute the model command."""
+        args = args.strip()
+        config = self._load_config()
+
+        if args == "--clear" or args == "-c":
+            # Clear model setting
+            if "model" in config:
+                del config["model"]
+                self._save_config(config)
+                self.output.success("Model setting cleared. Will use default model.")
+            else:
+                self.output.info("No model setting to clear.")
+
+        elif args == "--list" or args == "-l":
+            # List available models
+            models = self._get_available_models()
+            if models:
+                self.output.info(f"Available models ({len(models)}):")
+                for model in models:
+                    self.output.text(f"  - {model}")
+            else:
+                self.output.warning("No models found in config.yaml")
+
+        elif args:
+            # Set model directly
+            self._set_model(args)
+
+        else:
+            # Interactive mode: show current model and let user choose
+            current_config_model = config.get("model")
+
+            # Get current agent model
+            current_agent_model = None
+            if self.agent:
+                current_agent_model = getattr(self.agent, "llm", None)
+
+            # Display current info
+            headers = ["Setting", "Value"]
+            rows = []
+
+            if current_agent_model:
+                rows.append(["Current Session Model", str(current_agent_model)])
+
+            if current_config_model:
+                rows.append(["Config File Model", current_config_model])
+            else:
+                rows.append(["Config File Model", "(not set - using default)"])
+
+            self.output.table(headers, rows, title="Model Configuration")
+
+            # Get available models and show selection
+            models = self._get_available_models()
+            if models:
+                # Add current model indicator
+                choices = []
+                for model in models:
+                    if model == current_config_model:
+                        choices.append(f"{model} (current)")
+                    else:
+                        choices.append(model)
+
+                # Ask user to select (returns index, -1 if cancelled)
+                selected_index = await self.output.choice(
+                    message="Select a model:", choices=choices, title="Available Models"
+                )
+
+                if selected_index >= 0 and selected_index < len(models):
+                    # Get the model name from original models list (without " (current)" suffix)
+                    model_name = models[selected_index]
+                    if model_name != current_config_model:
+                        self._set_model(model_name)
+                    else:
+                        self.output.info("Model unchanged.")
+            else:
+                # No models found, show usage hints
+                self.output.info("\nUsage:")
+                self.output.text("  /model <name>   - Set model (e.g., /model gpt-4o)")
+                self.output.text("  /model --list   - List available models")
+                self.output.text("  /model --clear  - Clear saved model setting")

minion_code/commands/quit_command.py

@@ -4,29 +4,26 @@
 Quit command - Exit the application
 """
 
-from rich.panel import Panel
-from minion_code.commands import BaseCommand
+from minion_code.commands import BaseCommand, CommandType
 
 
 class QuitCommand(BaseCommand):
     """Exit the application."""
-    
+
     name = "quit"
     description = "Exit the application"
     usage = "/quit"
     aliases = ["exit", "q", "bye"]
-    
+    command_type = CommandType.LOCAL
+
     async def execute(self, args: str) -> None:
         """Execute the quit command."""
-        goodbye_panel = Panel(
-            "👋 [bold yellow]Goodbye! Thanks for using MinionCode![/bold yellow]",
-            title="[bold red]Exit[/bold red]",
-            border_style="red"
+        self.output.panel(
+            "👋 Goodbye! Thanks for using MinionCode!", title="Exit", border_style="red"
         )
-        self.console.print(goodbye_panel)
-        
+
         # Set a flag that the TUI can check and cleanup resources
-        if hasattr(self, '_tui_instance'):
+        if hasattr(self, "_tui_instance"):
             self._tui_instance.running = False
             # Cleanup MCP resources
-            await self._tui_instance.cleanup()
+            await self._tui_instance.cleanup()

minion_code/commands/resume_command.py

@@ -0,0 +1,181 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Resume command - Resume a previous session
+"""
+
+import os
+from minion_code.commands import BaseCommand, CommandType
+from minion_code.utils.session_storage import (
+    list_sessions,
+    load_session,
+    get_latest_session_id,
+    SessionMetadata,
+)
+
+
+class ResumeCommand(BaseCommand):
+    """Resume a previous conversation session."""
+
+    name = "resume"
+    description = "Resume a previous session or list available sessions"
+    usage = "/resume [session_id] or /resume list"
+    aliases = ["r"]
+    command_type = CommandType.LOCAL
+
+    async def execute(self, args: str) -> None:
+        """Execute the resume command.
+
+        Args:
+            args: Optional session_id or 'list' to show available sessions
+        """
+        args = args.strip()
+        current_project = os.getcwd()
+
+        # /resume list - show available sessions
+        if args.lower() == "list" or args.lower() == "ls":
+            await self._list_sessions(current_project)
+            return
+
+        # /resume <session_id> - resume specific session
+        if args:
+            await self._resume_session(args)
+            return
+
+        # /resume (no args) - resume latest session for current project
+        latest_id = get_latest_session_id(project_path=current_project)
+        if latest_id:
+            await self._resume_session(latest_id)
+        else:
+            self.output.panel(
+                "No previous sessions found for this project.\n\n"
+                "Use `/resume list` to see all available sessions.",
+                title="No Sessions",
+                border_style="yellow",
+            )
+
+    async def _list_sessions(self, project_path: str) -> None:
+        """List available sessions."""
+        # Get sessions for current project
+        project_sessions = list_sessions(project_path=project_path, limit=10)
+
+        # Get all sessions
+        all_sessions = list_sessions(limit=20)
+
+        if not all_sessions:
+            self.output.panel(
+                "No saved sessions found.\n\n"
+                "Sessions are automatically saved during conversations.",
+                title="No Sessions",
+                border_style="yellow",
+            )
+            return
+
+        # Build output
+        lines = []
+
+        # Current project sessions
+        if project_sessions:
+            lines.append("**This Project:**")
+            lines.append("")
+            for session in project_sessions[:5]:
+                lines.append(self._format_session_line(session))
+            lines.append("")
+
+        # Other sessions
+        other_sessions = [s for s in all_sessions if s.project_path != project_path]
+        if other_sessions:
+            lines.append("**Other Projects:**")
+            lines.append("")
+            for session in other_sessions[:5]:
+                lines.append(self._format_session_line(session, show_path=True))
+            lines.append("")
+
+        lines.append("---")
+        lines.append("Use `/resume <id>` to restore a session")
+        lines.append("Use `/resume` to restore the latest session")
+
+        self.output.panel(
+            "\n".join(lines), title="Available Sessions", border_style="blue"
+        )
+
+    def _format_session_line(
+        self, session: SessionMetadata, show_path: bool = False
+    ) -> str:
+        """Format a session for display."""
+        # Parse timestamp for display
+        try:
+            from datetime import datetime
+
+            updated = datetime.fromisoformat(session.updated_at)
+            time_str = updated.strftime("%m/%d %H:%M")
+        except:
+            time_str = session.updated_at[:16]
+
+        title = session.title or "(no title)"
+        if len(title) > 40:
+            title = title[:40] + "..."
+
+        line = f"  `{session.session_id}` - {title} ({session.message_count} msgs, {time_str})"
+
+        if show_path:
+            # Show shortened path
+            path = session.project_path
+            home = os.path.expanduser("~")
+            if path.startswith(home):
+                path = "~" + path[len(home) :]
+            if len(path) > 30:
+                path = "..." + path[-27:]
+            line += f"\n    {path}"
+
+        return line
+
+    async def _resume_session(self, session_id: str) -> None:
+        """Resume a specific session."""
+        session = load_session(session_id)
+
+        if not session:
+            self.output.panel(
+                f"Session `{session_id}` not found.\n\n"
+                "Use `/resume list` to see available sessions.",
+                title="Session Not Found",
+                border_style="red",
+            )
+            return
+
+        # Check if agent supports session restoration
+        if not self.agent:
+            self.output.panel(
+                "Agent not initialized. Cannot restore session.",
+                title="Error",
+                border_style="red",
+            )
+            return
+
+        # Check if agent has restore_session method
+        if not hasattr(self.agent, "restore_session"):
+            self.output.panel(
+                "Session restoration not yet implemented in agent.\n\n"
+                f"Session `{session_id}` has {len(session.messages)} messages:\n"
+                f"Title: {session.metadata.title or '(none)'}\n"
+                f"Project: {session.metadata.project_path}",
+                title="Coming Soon",
+                border_style="yellow",
+            )
+            return
+
+        # Restore the session
+        try:
+            await self.agent.restore_session(session)
+
+            self.output.panel(
+                f"Restored session `{session_id}` with {len(session.messages)} messages.\n\n"
+                f"Title: {session.metadata.title or '(none)'}\n"
+                f"You can continue the conversation now.",
+                title="Session Restored",
+                border_style="green",
+            )
+        except Exception as e:
+            self.output.panel(
+                f"Failed to restore session: {e}", title="Error", border_style="red"
+            )

minion_code/commands/skill_command.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Skill command - wrapper to execute skills as slash commands.
+"""
+
+from . import BaseCommand, CommandType
+
+
+class SkillCommand(BaseCommand):
+    """
+    Command wrapper for executing skills.
+
+    Skills are dynamically loaded and can be executed like /skill-name.
+    This is a PROMPT type command - the skill content is expanded
+    and sent to the LLM.
+    """
+
+    name: str = ""  # Set dynamically
+    description: str = ""  # Set dynamically
+    usage: str = ""  # Set dynamically
+    command_type: CommandType = CommandType.PROMPT
+    is_skill: bool = True
+
+    def __init__(self, output, agent=None, skill=None):
+        """
+        Initialize the skill command.
+
+        Args:
+            output: OutputAdapter instance
+            agent: Optional agent instance
+            skill: Skill object to wrap
+        """
+        super().__init__(output, agent)
+        self.skill = skill
+
+        if skill:
+            self.name = skill.name
+            self.description = skill.description
+            self.usage = f"/{skill.name}"
+
+    async def execute(self, args: str) -> None:
+        """
+        Execute is not used for PROMPT commands.
+        The get_prompt method is used instead.
+        """
+        pass
+
+    async def get_prompt(self, args: str) -> str:
+        """
+        Get the expanded prompt for this skill.
+
+        Args:
+            args: Command arguments (usually ignored for skills)
+
+        Returns:
+            Expanded prompt string containing skill instructions
+        """
+        if not self.skill:
+            return f"Error: Skill not found"
+
+        # Build the skill activation message
+        header = f'<command-message>The "{self.skill.name}" skill is loading</command-message>'
+        skill_content = self.skill.get_prompt()
+
+        return f"{header}\n\n{skill_content}"
+
+
+def create_skill_command(skill) -> type:
+    """
+    Dynamically create a SkillCommand class for a specific skill.
+
+    Args:
+        skill: Skill object
+
+    Returns:
+        SkillCommand subclass configured for the skill
+    """
+
+    class DynamicSkillCommand(SkillCommand):
+        name = skill.name
+        description = skill.description
+        usage = f"/{skill.name}"
+
+        def __init__(self, output, agent=None):
+            super().__init__(output, agent, skill=skill)
+
+    DynamicSkillCommand.__name__ = f"{skill.name.replace('-', '_').title()}SkillCommand"
+    return DynamicSkillCommand

minion_code/commands/status_command.py

@@ -4,112 +4,87 @@
 Status command - Show system status and information
 """
 
-from rich.panel import Panel
-from rich.table import Table
-from rich.text import Text
 import sys
 import platform
 from datetime import datetime
-from minion_code.commands import BaseCommand
+from minion_code.commands import BaseCommand, CommandType
 
 
 class StatusCommand(BaseCommand):
     """Show system status and information."""
-    
+
     name = "status"
     description = "Show system status, agent info, and statistics"
     usage = "/status"
     aliases = ["info", "stat"]
-    
+    command_type = CommandType.LOCAL
+
     async def execute(self, args: str) -> None:
         """Execute the status command."""
-        # Create status table
-        status_table = Table(
-            title="📊 System Status", 
-            show_header=True, 
-            header_style="bold blue"
-        )
-        status_table.add_column("Component", style="cyan", no_wrap=True)
-        status_table.add_column("Status", style="white")
-        status_table.add_column("Details", style="yellow")
-        
+        # Prepare table data
+        headers = ["Component", "Status", "Details"]
+        rows = []
+
         # System info
-        status_table.add_row(
-            "System",
-            "✅ Running",
-            f"{platform.system()} {platform.release()}"
-        )
-        
-        status_table.add_row(
-            "Python",
-            "✅ Active",
-            f"{sys.version.split()[0]}"
+        rows.append(
+            ["System", "✅ Running", f"{platform.system()} {platform.release()}"]
         )
-        
+
+        rows.append(["Python", "✅ Active", f"{sys.version.split()[0]}"])
+
         # Agent info
         if self.agent:
             history = self.agent.get_conversation_history()
             tools_count = len(self.agent.tools) if self.agent.tools else 0
-            
-            status_table.add_row(
-                "Agent",
-                "✅ Ready",
-                f"{tools_count} tools loaded"
-            )
-            
-            status_table.add_row(
-                "Conversation",
-                "📝 Active" if history else "📝 Empty",
-                f"{len(history)} messages" if history else "No messages"
+
+            rows.append(["Agent", "✅ Ready", f"{tools_count} tools loaded"])
+
+            rows.append(
+                [
+                    "Conversation",
+                    "📝 Active" if history else "📝 Empty",
+                    f"{len(history)} messages" if history else "No messages",
+                ]
             )
         else:
-            status_table.add_row(
-                "Agent",
-                "❌ Not Ready",
-                "Not initialized"
-            )
-        
+            rows.append(["Agent", "❌ Not Ready", "Not initialized"])
+
         # Memory info (basic)
         try:
             import psutil
+
             memory = psutil.virtual_memory()
-            status_table.add_row(
-                "Memory",
-                "📊 Monitored",
-                f"{memory.percent}% used ({memory.available // (1024**3)} GB free)"
+            rows.append(
+                [
+                    "Memory",
+                    "📊 Monitored",
+                    f"{memory.percent}% used ({memory.available // (1024**3)} GB free)",
+                ]
             )
         except ImportError:
-            status_table.add_row(
-                "Memory",
-                "❌ Not Available",
-                "psutil not installed"
-            )
-        
-        self.console.print(status_table)
-        
+            rows.append(["Memory", "❌ Not Available", "psutil not installed"])
+
+        # Display table
+        self.output.table(headers, rows, title="📊 System Status")
+
         # Additional info panel
         current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-        
-        info_text = Text()
-        info_text.append("🕒 Current Time: ", style="bold")
-        info_text.append(f"{current_time}\n", style="white")
-        
+
+        info_lines = [f"🕒 Current Time: {current_time}"]
+
         if self.agent:
-            info_text.append("🤖 Agent Model: ", style="bold")
-            info_text.append(f"{getattr(self.agent, 'llm', 'Unknown')}\n", style="white")
-            
-            info_text.append("🛠️ Available Tools: ", style="bold")
+            info_lines.append(
+                f"🤖 Agent Model: {getattr(self.agent, 'llm', 'Unknown')}"
+            )
+
             if self.agent.tools:
                 tool_names = [tool.name for tool in self.agent.tools[:5]]
                 if len(self.agent.tools) > 5:
                     tool_names.append(f"... and {len(self.agent.tools) - 5} more")
-                info_text.append(", ".join(tool_names), style="white")
+                info_lines.append(f"🛠️ Available Tools: {', '.join(tool_names)}")
             else:
-                info_text.append("None", style="red")
-        
-        info_panel = Panel(
-            info_text,
-            title="[bold green]Additional Information[/bold green]",
-            border_style="green"
+                info_lines.append("🛠️ Available Tools: None")
+
+        self.output.panel(
+            "\n".join(info_lines), title="Additional Information", border_style="green"
         )
-        self.console.print(info_panel)