minion-code 0.1.0__py3-none-any.whl

examples/simple_tui.py

@@ -0,0 +1,267 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Simple TUI using MinionCodeAgent
+
+This example shows how the new MinionCodeAgent class simplifies
+the TUI implementation by handling all the tool setup internally.
+
+Compare this with minion_agent_tui.py to see the reduction in boilerplate code.
+"""
+
+import asyncio
+import sys
+from pathlib import Path
+
+# Add project root to path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from minion_code import MinionCodeAgent
+from minion_code.commands import command_registry
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+from rich.markdown import Markdown
+from rich.table import Table
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.prompt import Prompt
+
+
+class SimpleTUI:
+    """Simplified TUI using MinionCodeAgent."""
+    
+    def __init__(self):
+        self.agent = None
+        self.running = True
+        self.console = Console()
+    
+    async def setup(self):
+        """Setup the agent."""
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            console=self.console,
+        ) as progress:
+            task = progress.add_task("🔧 Setting up MinionCodeAgent...", total=None)
+            
+            # Much simpler setup - no manual tool configuration needed
+            self.agent = await MinionCodeAgent.create(
+                name="Simple TUI Assistant",
+                llm="gpt-4o-mini",
+            )
+            
+            progress.update(task, completed=True)
+        
+        success_panel = Panel(
+            f"✅ Agent ready with [bold green]{len(self.agent.tools)}[/bold green] tools!",
+            title="[bold green]Setup Complete[/bold green]",
+            border_style="green"
+        )
+        self.console.print(success_panel)
+    
+    def show_help(self):
+        """Show help information."""
+        help_table = Table(title="📚 Simple TUI Help", 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_row("help", "Show this help")
+        help_table.add_row("tools", "List available tools")
+        help_table.add_row("history", "Show conversation history")
+        help_table.add_row("clear", "Clear history")
+        help_table.add_row("quit", "Exit")
+        
+        self.console.print(help_table)
+        self.console.print("\n💡 [italic]Just type your message to chat with the AI agent![/italic]")
+    
+    async def process_input(self, user_input: str):
+        """Process user input."""
+        user_input = user_input.strip()
+        
+        # Check if it's a command (starts with /)
+        if user_input.startswith('/'):
+            await self.process_command(user_input)
+            return
+        
+        # Process with agent
+        try:
+            with Progress(
+                SpinnerColumn(),
+                TextColumn("[progress.description]{task.description}"),
+                console=self.console,
+            ) as progress:
+                task = progress.add_task("🤖 Processing...", total=None)
+                response = await self.agent.run_async(user_input)
+                progress.update(task, completed=True)
+            
+            # Display agent response with rich formatting
+            if "```" in response.answer:
+                # If response contains code blocks, render as markdown
+                agent_content = Markdown(response.answer)
+            else:
+                agent_content = response.answer
+            
+            response_panel = Panel(
+                agent_content,
+                title="🤖 [bold green]Agent Response[/bold green]",
+                border_style="green"
+            )
+            self.console.print(response_panel)
+            
+        except Exception as e:
+            error_panel = Panel(
+                f"❌ [bold red]Error: {e}[/bold red]",
+                title="[bold red]Error[/bold red]",
+                border_style="red"
+            )
+            self.console.print(error_panel)
+    
+    async def process_command(self, command_input: str):
+        """Process a command input."""
+        # Remove the leading /
+        command_input = command_input[1:] if command_input.startswith('/') else command_input
+        
+        # Split command and arguments
+        parts = command_input.split(' ', 1)
+        command_name = parts[0].lower()
+        args = parts[1] if len(parts) > 1 else ""
+        
+        # Get command class
+        command_class = command_registry.get_command(command_name)
+        if not command_class:
+            error_panel = Panel(
+                f"❌ [bold red]Unknown command: /{command_name}[/bold red]\n"
+                f"💡 [italic]Use '/help' to see available commands[/italic]",
+                title="[bold red]Error[/bold red]",
+                border_style="red"
+            )
+            self.console.print(error_panel)
+            return
+        
+        # Create and execute command
+        try:
+            command_instance = command_class(self.console, self.agent)
+            
+            # Special handling for quit command
+            if command_name in ["quit", "exit", "q", "bye"]:
+                command_instance._tui_instance = self
+            
+            await command_instance.execute(args)
+            
+        except Exception as e:
+            error_panel = Panel(
+                f"❌ [bold red]Error executing command /{command_name}: {e}[/bold red]",
+                title="[bold red]Command Error[/bold red]",
+                border_style="red"
+            )
+            self.console.print(error_panel)
+    
+    def show_tools(self):
+        """Show available tools in a beautiful table."""
+        if not self.agent or not self.agent.tools:
+            self.console.print("❌ No tools available")
+            return
+        
+        tools_table = Table(title="🛠️ Available Tools", 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")
+        
+        for tool in self.agent.tools:
+            tool_type = "Read-only" if getattr(tool, 'readonly', False) else "Read-write"
+            tools_table.add_row(
+                tool.name,
+                tool.description[:60] + "..." if len(tool.description) > 60 else tool.description,
+                tool_type
+            )
+        
+        self.console.print(tools_table)
+    
+    def show_history(self):
+        """Show conversation history in a beautiful format."""
+        if not self.agent:
+            return
+            
+        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
+        
+        history_panel = Panel(
+            f"📝 [bold blue]Conversation History ({len(history)} messages)[/bold blue]",
+            border_style="blue"
+        )
+        self.console.print(history_panel)
+        
+        for i, entry in enumerate(history[-5:], 1):  # Show last 5 messages
+            # User message
+            user_panel = Panel(
+                entry['user_message'][:200] + "..." if len(entry['user_message']) > 200 else entry['user_message'],
+                title=f"👤 [bold cyan]You (Message {len(history)-5+i})[/bold cyan]",
+                border_style="cyan"
+            )
+            self.console.print(user_panel)
+            
+            # Agent response
+            agent_response = entry['agent_response'][:200] + "..." if len(entry['agent_response']) > 200 else entry['agent_response']
+            agent_panel = Panel(
+                agent_response,
+                title="🤖 [bold green]Agent[/bold green]",
+                border_style="green"
+            )
+            self.console.print(agent_panel)
+            self.console.print()  # Add spacing
+    
+    async def run(self):
+        """Run the TUI."""
+        # Welcome banner
+        welcome_panel = Panel(
+            "🚀 [bold blue]Simple MinionCodeAgent TUI[/bold blue]\n"
+            "💡 [italic]Use '/help' for commands or just chat with the agent![/italic]\n"
+            "🛑 [italic]Type '/quit' to exit[/italic]",
+            title="[bold magenta]Welcome[/bold magenta]",
+            border_style="magenta"
+        )
+        self.console.print(welcome_panel)
+        
+        await self.setup()
+        
+        while self.running:
+            try:
+                # Use rich prompt for better input experience
+                user_input = Prompt.ask(
+                    "\n[bold cyan]👤 You[/bold cyan]",
+                    console=self.console
+                ).strip()
+                
+                if user_input:
+                    await self.process_input(user_input)
+                    
+            except (EOFError, KeyboardInterrupt):
+                goodbye_panel = Panel(
+                    "\n👋 [bold yellow]Goodbye![/bold yellow]",
+                    title="[bold red]Exit[/bold red]",
+                    border_style="red"
+                )
+                self.console.print(goodbye_panel)
+                break
+
+
+async def main():
+    """Main function."""
+    tui = SimpleTUI()
+    await tui.run()
+
+
+def run():
+    """Synchronous entry point."""
+    asyncio.run(main())
+
+
+if __name__ == "__main__":
+    run()

examples/simple_usage.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python3
+"""Simple usage example of FileFreshnessService."""
+
+import os
+import sys
+
+# Add parent directory to path for imports
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from minion_code.services import (
+    record_file_read,
+    record_file_edit,
+    check_file_freshness,
+    generate_file_modification_reminder,
+    add_event_listener,
+    emit_event,
+)
+
+
+def main():
+    """Simple usage demonstration."""
+    
+    # Set up a simple event listener
+    def on_conflict(context):
+        print(f"⚠️  Conflict: {context.data['file_path']}")
+    
+    add_event_listener('file:conflict', on_conflict)
+    
+    # Create test file
+    test_file = "example.py"
+    with open(test_file, "w") as f:
+        f.write("print('Hello, World!')")
+    
+    # Record reading the file
+    record_file_read(test_file)
+    print(f"✅ Recorded reading {test_file}")
+    
+    # Check freshness (should be fresh)
+    result = check_file_freshness(test_file)
+    print(f"📊 File is fresh: {result.is_fresh}")
+    
+    # Simulate external modification
+    with open(test_file, "w") as f:
+        f.write("print('Modified externally!')")
+    
+    # Check freshness again (should detect conflict)
+    result = check_file_freshness(test_file)
+    print(f"📊 After external change - Fresh: {result.is_fresh}, Conflict: {result.conflict}")
+    
+    # Generate reminder for external modification
+    reminder = generate_file_modification_reminder(test_file)
+    if reminder:
+        print(f"💡 Reminder: {reminder}")
+    
+    # Record agent edit (resolves conflict)
+    record_file_edit(test_file, "print('Agent fixed this!')")
+    print(f"✅ Agent edited {test_file}")
+    
+    # Check freshness after agent edit
+    result = check_file_freshness(test_file)
+    print(f"📊 After agent edit - Fresh: {result.is_fresh}, Conflict: {result.conflict}")
+    
+    # Cleanup
+    os.remove(test_file)
+    print("🧹 Cleaned up test file")
+
+
+if __name__ == "__main__":
+    main()

minion_code/__init__.py

@@ -0,0 +1,16 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+Minion Code Tools Package
+
+A collection of tools and enhanced agents for the Minion framework including 
+file operations, system commands, web interactions, and specialized agents
+with dynamic system prompts and state management.
+"""
+
+from . import tools
+from . import agents
+from .agents import MinionCodeAgent, create_minion_code_agent
+
+__version__ = "0.1.0"
+__all__ = ["tools", "agents", "MinionCodeAgent", "create_minion_code_agent"]

minion_code/agents/__init__.py

@@ -0,0 +1,11 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+Minion Code Agents Package
+
+Enhanced agents with specialized capabilities for code development tasks.
+"""
+
+from .code_agent import MinionCodeAgent,create_minion_code_agent
+
+__all__ = ["MinionCodeAgent","create_minion_code_agent"]

minion_code/agents/code_agent.py

@@ -0,0 +1,320 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+MinionCodeAgent - Enhanced CodeAgent with minion_code tools
+
+This module provides a specialized CodeAgent subclass that comes pre-configured
+with all minion_code tools and optimized system prompts for code development tasks.
+
+Key features:
+- Pre-configured with all minion_code tools
+- Optimized system prompt for coding tasks
+- Async/sync support
+- Easy setup and initialization
+- Conversation history management
+"""
+
+import asyncio
+import logging
+import traceback
+from dataclasses import dataclass
+from pathlib import Path
+from typing import List, Optional, Union, Any
+import sys
+
+from minion.agents import CodeAgent
+
+# Import all minion_code tools
+from ..tools import (
+    FileReadTool,
+    FileWriteTool,
+    FileEditTool,
+    MultiEditTool,
+    BashTool,
+    GrepTool,
+    GlobTool,
+    LsTool,
+    PythonInterpreterTool,
+    UserInputTool,
+
+    TodoWriteTool,
+    TodoReadTool,
+    TOOL_MAPPING,
+)
+
+logger = logging.getLogger(__name__)
+
+# Todo reminder constants
+INITIAL_REMINDER = (
+    '<reminder source="system" topic="todos">'
+    "System message: complex work should be tracked with the Todo tool. "
+    "Do not respond to this reminder and do not mention it to the user."
+    '</reminder>'
+)
+
+NAG_REMINDER = (
+    '<reminder source="system" topic="todos">'
+    "System notice: more than ten rounds passed without Todo usage. "
+    "Update the Todo board if the task still requires multiple steps. "
+    "Do not reply to or mention this reminder to the user."
+    '</reminder>'
+)
+
+@dataclass
+class MinionCodeAgent(CodeAgent):
+    """
+    Enhanced CodeAgent with pre-configured minion_code tools.
+    
+    This class wraps the Minion CodeAgent with all minion_code tools
+    and provides optimized system prompts for coding tasks.
+    """
+    
+    DEFAULT_SYSTEM_PROMPT = (
+        "You are a coding agent operating INSIDE the user's repository at {workdir}.\n"
+        "Follow this loop strictly: plan briefly → use TOOLS to act directly on files/shell → report concise results.\n"
+        "Rules:\n"
+        "- Prefer taking actions with tools (read/write/edit/bash) over long prose.\n"
+        "- Keep outputs terse. Use bullet lists / checklists when summarizing.\n"
+        "- Never invent file paths. Ask via reads or list directories first if unsure.\n"
+        "- For edits, choose the right tool: string_edit for single string replacements, multi_edit for multiple changes to same file, file_edit for advanced operations.\n"
+        "- Always read files before editing to establish freshness tracking.\n"
+        "- For bash, avoid destructive or privileged commands; stay inside the workspace.\n"
+        "- Use the Todo tool to maintain multi-step plans when needed.\n"
+        "- After finishing, summarize what changed and how to run or test."
+    )
+
+    def __post_init__(self):
+        """Initialize the CodeAgent with thinking capabilities and optional state tracking."""
+        super().__post_init__()
+        self.conversation_history = []
+    
+    async def pre_step(self, input_data, kwargs):
+        """Override pre_step to track iterations without todo usage."""
+        # Call parent pre_step first
+        result = await super().pre_step(input_data, kwargs)
+        
+        # Initialize metadata if not exists
+        if not hasattr(self.state, 'metadata'):
+            self.state.metadata = {}
+        if "iteration_without_todos" not in self.state.metadata:
+            self.state.metadata["iteration_without_todos"] = 0
+        
+        # Increment iteration counter
+        self.state.metadata["iteration_without_todos"] += 1
+        
+        # Add nag reminder if more than 10 iterations without todo usage
+        if self.state.metadata["iteration_without_todos"] > 10:
+            self.state.history.append({
+                'role': 'user',
+                'content': NAG_REMINDER
+            })
+            # Reset counter to avoid spamming reminders
+            self.state.metadata["iteration_without_todos"] = 0
+        
+        return result
+        
+        return result
+    
+    @classmethod
+    async def create(
+        cls,
+        name: str = "Minion Code Assistant",
+        llm: str = "sonnet",
+        system_prompt: Optional[str] = None,
+        workdir: Optional[Union[str, Path]] = None,
+        additional_tools: Optional[List[Any]] = None,
+        **kwargs
+    ) -> "MinionCodeAgent":
+        """
+        Create a new MinionCodeAgent with all minion_code tools.
+        
+        Args:
+            name: Agent name
+            llm: LLM model to use
+            system_prompt: Custom system prompt (uses default if None)
+            workdir: Working directory (uses current if None)
+            additional_tools: Extra tools to add beyond minion_code tools
+            **kwargs: Additional arguments passed to CodeAgent.create()
+        
+        Returns:
+            Configured MinionCodeAgent instance
+        """
+        if workdir is None:
+            workdir = Path.cwd()
+        else:
+            workdir = Path(workdir)
+        
+        # Use default system prompt if none provided
+        if system_prompt is None:
+            system_prompt = cls.DEFAULT_SYSTEM_PROMPT.format(workdir=workdir)
+        
+        # Get all minion_code tools
+        minion_tools = [
+            FileReadTool(),
+            FileWriteTool(),
+            FileEditTool(),
+            MultiEditTool(),
+            BashTool(),
+            GrepTool(),
+            GlobTool(),
+            LsTool(),
+            PythonInterpreterTool(),
+            UserInputTool(),
+            TodoWriteTool(),
+            TodoReadTool(),
+        ]
+        
+        # Add any additional tools
+        all_tools = minion_tools[:]
+        if additional_tools:
+            all_tools.extend(additional_tools)
+        
+        logger.info(f"Creating MinionCodeAgent with {len(all_tools)} tools")
+        
+        # Create the underlying CodeAgent
+        agent = await super().create(
+            name=name,
+            llm=llm,
+            system_prompt=system_prompt,
+            tools=all_tools,
+            **kwargs
+        )
+        
+        # Initialize todo tracking metadata
+        if not hasattr(agent.state, 'metadata'):
+            agent.state.metadata = {}
+        agent.state.metadata["iteration_without_todos"] = 0
+        
+        # Add initial todo reminder to history
+        agent.state.history.append({
+            'role': 'user',
+            'content': INITIAL_REMINDER
+        })
+        
+        return agent
+    
+    async def run_async(self, message: str, **kwargs) -> Any:
+        """
+        Run agent asynchronously and track conversation history.
+        
+        Args:
+            message: User message
+            **kwargs: Additional arguments passed to agent.run_async()
+        
+        Returns:
+            Agent response
+        """
+        try:
+            response = await super().run_async(message, **kwargs)
+            
+            # Track conversation history
+            self.conversation_history.append({
+                'user_message': message,
+                'agent_response': response.answer if hasattr(response, 'answer') else str(response),
+                'timestamp': asyncio.get_event_loop().time()
+            })
+            
+            return response
+            
+        except Exception as e:
+            logger.error(f"Error in run_async: {e}")
+            traceback.print_exc()
+            raise
+    
+    def run(self, message: str, **kwargs) -> Any:
+        """
+        Run agent synchronously.
+        
+        Args:
+            message: User message
+            **kwargs: Additional arguments
+        
+        Returns:
+            Agent response
+        """
+        return asyncio.run(self.run_async(message, **kwargs))
+    
+    def get_conversation_history(self) -> List[dict]:
+        """Get conversation history."""
+        return self.conversation_history.copy()
+    
+    def clear_conversation_history(self):
+        """Clear conversation history."""
+        self.conversation_history.clear()
+    
+    def get_tools_info(self) -> List[dict]:
+        """
+        Get information about available tools.
+        
+        Returns:
+            List of tool information dictionaries
+        """
+        tools_info = []
+        for tool in self.tools:
+            readonly_status = getattr(tool, "readonly", None)
+            tools_info.append({
+                'name': tool.name,
+                'description': tool.description,
+                'readonly': readonly_status,
+                'type': type(tool).__name__
+            })
+        return tools_info
+    
+    def print_tools_summary(self):
+        """Print a summary of available tools."""
+        tools_info = self.get_tools_info()
+        
+        print(f"\n🛠️ Available Tools ({len(tools_info)} total):")
+        
+        # Group tools by category
+        categories = {
+            'File & Directory': ['file', 'read', 'write', 'grep', 'glob', 'ls'],
+            'System & Execution': ['bash', 'python', 'calc', 'system'],
+            'Web & Search': ['web', 'search', 'wikipedia', 'visit'],
+            'Other': []
+        }
+        
+        categorized_tools = {cat: [] for cat in categories}
+        
+        for tool in tools_info:
+            categorized = False
+            for category, keywords in categories.items():
+                if category == 'Other':
+                    continue
+                if any(keyword in tool['name'].lower() for keyword in keywords):
+                    categorized_tools[category].append(tool)
+                    categorized = True
+                    break
+            
+            if not categorized:
+                categorized_tools['Other'].append(tool)
+        
+        # Print categorized tools
+        for category, tools in categorized_tools.items():
+            if tools:
+                print(f"\n📁 {category} Tools:")
+                for tool in tools:
+                    readonly_icon = "🔒" if tool['readonly'] else "✏️"
+                    print(f"  {readonly_icon} {tool['name']}: {tool['description']}")
+        
+        print(f"\n🔒 = readonly tool, ✏️ = read/write tool")
+
+
+# Convenience function for quick setup
+async def create_minion_code_agent(
+    name: str = "Minion Code Assistant",
+    llm: str = "gpt-4o-mini",
+    **kwargs
+) -> MinionCodeAgent:
+    """
+    Convenience function to create a MinionCodeAgent.
+    
+    Args:
+        name: Agent name
+        llm: LLM model to use
+        **kwargs: Additional arguments passed to MinionCodeAgent.create()
+    
+    Returns:
+        Configured MinionCodeAgent instance
+    """
+    return await MinionCodeAgent.create(name=name, llm=llm, **kwargs)