minion-code 0.1.0__py3-none-any.whl

minion_code/commands/help_command.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+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
+
+
+class HelpCommand(BaseCommand):
+    """Show help information for commands."""
+    
+    name = "help"
+    description = "Show available commands and their usage"
+    usage = "/help [command_name]"
+    aliases = ["h", "?"]
+    
+    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.console.print(error_panel)
+            return
+        
+        # Create temporary command instance to get help
+        temp_command = command_class(self.console, 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.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")
+        
+        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)
+        
+        # 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.console.print(usage_panel)

minion_code/commands/history_command.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+History command - Show conversation history
+"""
+
+from rich.panel import Panel
+from rich.table import Table
+from minion_code.commands import BaseCommand
+
+
+class HistoryCommand(BaseCommand):
+    """Show conversation history."""
+    
+    name = "history"
+    description = "Show conversation history with the agent"
+    usage = "/history [count]"
+    aliases = ["hist", "h"]
+    
+    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.console.print(error_panel)
+            return
+        
+        # Parse count argument
+        count = 5  # default
+        if args.strip():
+            try:
+                count = int(args.strip())
+                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.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.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.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']
+            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.console.print(user_panel)
+            
+            # 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)
+            
+            if i < len(recent_history):  # Don't add spacing after last message
+                self.console.print()
+        
+        # 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.console.print(summary_panel)

minion_code/commands/quit_command.py

@@ -0,0 +1,32 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Quit command - Exit the application
+"""
+
+from rich.panel import Panel
+from minion_code.commands import BaseCommand
+
+
+class QuitCommand(BaseCommand):
+    """Exit the application."""
+    
+    name = "quit"
+    description = "Exit the application"
+    usage = "/quit"
+    aliases = ["exit", "q", "bye"]
+    
+    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.console.print(goodbye_panel)
+        
+        # Set a flag that the TUI can check and cleanup resources
+        if hasattr(self, '_tui_instance'):
+            self._tui_instance.running = False
+            # Cleanup MCP resources
+            await self._tui_instance.cleanup()

minion_code/commands/status_command.py

@@ -0,0 +1,115 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+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
+
+
+class StatusCommand(BaseCommand):
+    """Show system status and information."""
+    
+    name = "status"
+    description = "Show system status, agent info, and statistics"
+    usage = "/status"
+    aliases = ["info", "stat"]
+    
+    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")
+        
+        # System info
+        status_table.add_row(
+            "System",
+            "✅ Running",
+            f"{platform.system()} {platform.release()}"
+        )
+        
+        status_table.add_row(
+            "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"
+            )
+        else:
+            status_table.add_row(
+                "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)"
+            )
+        except ImportError:
+            status_table.add_row(
+                "Memory",
+                "❌ Not Available",
+                "psutil not installed"
+            )
+        
+        self.console.print(status_table)
+        
+        # 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")
+        
+        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")
+            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")
+            else:
+                info_text.append("None", style="red")
+        
+        info_panel = Panel(
+            info_text,
+            title="[bold green]Additional Information[/bold green]",
+            border_style="green"
+        )
+        self.console.print(info_panel)

minion_code/commands/tools_command.py

@@ -0,0 +1,86 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Tools command - Show available tools
+"""
+
+from rich.table import Table
+from rich.panel import Panel
+from minion_code.commands import BaseCommand
+
+
+class ToolsCommand(BaseCommand):
+    """Show available tools."""
+    
+    name = "tools"
+    description = "List all available tools and their descriptions"
+    usage = "/tools [filter]"
+    aliases = ["t"]
+    
+    async def execute(self, args: str) -> None:
+        """Execute the tools command."""
+        if not self.agent or not self.agent.tools:
+            error_panel = Panel(
+                "❌ [bold red]No tools available or agent not initialized[/bold red]",
+                title="[bold red]Error[/bold red]",
+                border_style="red"
+            )
+            self.console.print(error_panel)
+            return
+        
+        filter_text = args.strip().lower()
+        tools = self.agent.tools
+        
+        # Filter tools if filter text provided
+        if filter_text:
+            tools = [tool for tool in tools 
+                    if filter_text in tool.name.lower() or 
+                       filter_text in tool.description.lower()]
+        
+        if not tools:
+            no_tools_panel = Panel(
+                f"❌ [bold yellow]No tools found matching '{filter_text}'[/bold yellow]",
+                title="[bold yellow]No Results[/bold yellow]",
+                border_style="yellow"
+            )
+            self.console.print(no_tools_panel)
+            return
+        
+        # Create tools table
+        tools_table = Table(
+            title=f"🛠️ Available Tools{f' (filtered: {filter_text})' if filter_text else ''}", 
+            show_header=True, 
+            header_style="bold magenta"
+        )
+        tools_table.add_column("Tool Name", style="cyan", no_wrap=True)
+        tools_table.add_column("Description", style="white")
+        tools_table.add_column("Type", style="yellow")
+        tools_table.add_column("Inputs", style="green")
+        
+        for tool in tools:
+            tool_type = "Read-only" if getattr(tool, 'readonly', False) else "Read-write"
+            
+            # Get input parameters
+            inputs = getattr(tool, 'inputs', {})
+            input_names = list(inputs.keys()) if inputs else []
+            input_str = ", ".join(input_names[:3])  # Show first 3 inputs
+            if len(input_names) > 3:
+                input_str += f" (+{len(input_names) - 3} more)"
+            
+            tools_table.add_row(
+                tool.name,
+                tool.description[:50] + "..." if len(tool.description) > 50 else tool.description,
+                tool_type,
+                input_str or "-"
+            )
+        
+        self.console.print(tools_table)
+        
+        # Show summary
+        summary_panel = Panel(
+            f"📊 [bold blue]Total: {len(tools)} tools[/bold blue]"
+            f"{f' (filtered from {len(self.agent.tools)} total)' if filter_text else ''}",
+            title="[bold green]Summary[/bold green]",
+            border_style="green"
+        )
+        self.console.print(summary_panel)

minion_code/commands/version_command.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Version command - Show version information
+"""
+
+from rich.panel import Panel
+from rich.table import Table
+from minion_code.commands import BaseCommand
+
+
+class VersionCommand(BaseCommand):
+    """Show version information."""
+    
+    name = "version"
+    description = "Show version information for MinionCode and dependencies"
+    usage = "/version"
+    aliases = ["v", "ver"]
+    
+    async def execute(self, args: str) -> None:
+        """Execute the version command."""
+        # Create version table
+        version_table = Table(
+            title="📦 Version Information", 
+            show_header=True, 
+            header_style="bold blue"
+        )
+        version_table.add_column("Component", style="cyan", no_wrap=True)
+        version_table.add_column("Version", style="white")
+        version_table.add_column("Status", style="green")
+        
+        # MinionCode version
+        version_table.add_row(
+            "MinionCode",
+            "0.1.0",
+            "✅ Active"
+        )
+        
+        # Python version
+        import sys
+        version_table.add_row(
+            "Python",
+            f"{sys.version.split()[0]}",
+            "✅ Compatible"
+        )
+        
+        # Rich version
+        try:
+            import rich
+            version = getattr(rich, '__version__', 'Unknown')
+            version_table.add_row(
+                "Rich",
+                version,
+                "✅ Loaded"
+            )
+        except ImportError:
+            version_table.add_row(
+                "Rich",
+                "Not installed",
+                "❌ Missing"
+            )
+        
+        # Textual version
+        try:
+            import textual
+            version = getattr(textual, '__version__', 'Unknown')
+            version_table.add_row(
+                "Textual",
+                version,
+                "✅ Available"
+            )
+        except ImportError:
+            version_table.add_row(
+                "Textual",
+                "Not installed",
+                "⚠️ Optional"
+            )
+        
+        # Minion version
+        try:
+            import minion
+            version_table.add_row(
+                "Minion",
+                getattr(minion, '__version__', 'Unknown'),
+                "✅ Core"
+            )
+        except ImportError:
+            version_table.add_row(
+                "Minion",
+                "Not found",
+                "❌ Required"
+            )
+        
+        self.console.print(version_table)
+        
+        # Additional info
+        info_panel = Panel(
+            "🚀 [bold blue]MinionCode TUI[/bold blue] - Advanced AI-powered development assistant\n"
+            "🔗 Built with Rich for beautiful terminal interfaces\n"
+            "🤖 Powered by Minion framework for AI agent capabilities",
+            title="[bold green]About[/bold green]",
+            border_style="green"
+        )
+        self.console.print(info_panel)