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

minion_code/acp_server/test_client.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Simple ACP client for testing minion-code ACP agent.
+
+Usage:
+    python -m minion_code.acp_server.test_client
+    python -m minion_code.acp_server.test_client "your prompt here"
+"""
+
+import asyncio
+import sys
+from pathlib import Path
+from typing import Any
+
+from acp import spawn_agent_process, text_block
+from acp.interfaces import Client
+
+
+class TestClient(Client):
+    """Simple client that prints all updates."""
+
+    async def request_permission(self, options, session_id, tool_call, **kwargs: Any):
+        """Auto-accept all permissions for testing."""
+        print(f"[PERMISSION] {tool_call}")
+        return {"outcome": {"outcome": "accepted"}}
+
+    async def session_update(self, session_id, update, **kwargs):
+        """Print all session updates."""
+        update_type = type(update).__name__
+
+        # Format based on update type
+        if hasattr(update, "delta"):
+            # AgentMessageChunk or AgentThoughtChunk
+            content = update.delta
+            if update_type == "AgentThoughtChunk":
+                print(f"[THOUGHT] {content}", end="", flush=True)
+            else:
+                print(f"{content}", end="", flush=True)
+        elif hasattr(update, "tool_call_id"):
+            # ToolCallStart or ToolCallProgress
+            # Check session_update to distinguish them
+            session_update_type = getattr(update, "session_update", None)
+            if session_update_type == "tool_call":
+                # ToolCallStart
+                print(f"\n[TOOL START] {update.title} (id={update.tool_call_id})")
+                # Print content if available
+                if hasattr(update, "content") and update.content:
+                    for c in update.content:
+                        if hasattr(c, "content") and hasattr(c.content, "text"):
+                            print(f"  Code:\n{c.content.text}")
+            elif session_update_type == "tool_call_update":
+                # ToolCallProgress
+                status = getattr(update, "status", "unknown")
+                print(f"\n[TOOL {status.upper()}] id={update.tool_call_id}")
+                # Print content if available
+                if hasattr(update, "content") and update.content:
+                    for c in update.content:
+                        if hasattr(c, "content") and hasattr(c.content, "text"):
+                            print(f"  Result: {c.content.text}")
+        else:
+            print(f"\n[UPDATE] {update_type}: {update}")
+
+
+async def main(prompt: str = "Hello! What can you do?") -> None:
+    """Run the test client."""
+    print(f"Starting minion-code ACP agent...")
+    print(f"Prompt: {prompt}")
+    print("=" * 60)
+
+    # Spawn the minion-code ACP agent
+    async with spawn_agent_process(
+        TestClient(), sys.executable, "-m", "minion_code.acp_server.main"
+    ) as (conn, proc):
+        print("Agent spawned, initializing...")
+
+        # Initialize
+        init_response = await conn.initialize(protocol_version=1)
+        print(
+            f"Initialized: {init_response.agent_info.name} v{init_response.agent_info.version}"
+        )
+
+        # Create session
+        cwd = str(Path.cwd())
+        session = await conn.new_session(cwd=cwd, mcp_servers=[])
+        print(f"Session created: {session.session_id}")
+        print("=" * 60)
+        print()
+
+        # Send prompt
+        response = await conn.prompt(
+            session_id=session.session_id,
+            prompt=[text_block(prompt)],
+        )
+
+        print()
+        print("=" * 60)
+        print(f"Response stop_reason: {response.stop_reason}")
+
+
+if __name__ == "__main__":
+    # Get prompt from command line or use default
+    prompt = " ".join(sys.argv[1:]) if len(sys.argv) > 1 else "Hello! What can you do?"
+    asyncio.run(main(prompt))

minion_code/adapters/__init__.py

@@ -0,0 +1,22 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Output Adapters - Abstraction layer for UI output
+
+This module provides adapters to decouple command business logic from UI rendering.
+Commands use a unified OutputAdapter interface, which can be implemented for different
+UI environments (Rich CLI, Textual TUI, etc.).
+"""
+
+from .output_adapter import OutputAdapter, MessageStyle, ConfirmOptions, ChoiceOptions
+from .rich_adapter import RichOutputAdapter
+from .textual_adapter import TextualOutputAdapter
+
+__all__ = [
+    "OutputAdapter",
+    "MessageStyle",
+    "ConfirmOptions",
+    "ChoiceOptions",
+    "RichOutputAdapter",
+    "TextualOutputAdapter",
+]

minion_code/adapters/output_adapter.py

@@ -0,0 +1,207 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Output Adapter - Abstract interface for UI output
+
+This module defines the abstract interface that all output adapters must implement.
+It provides a unified API for commands to output content and request user interaction,
+regardless of the underlying UI system (CLI, TUI, etc.).
+"""
+
+from abc import ABC, abstractmethod
+from typing import List, Optional
+from enum import Enum
+from dataclasses import dataclass
+
+
+class MessageStyle(Enum):
+    """Message style types"""
+
+    INFO = "info"
+    SUCCESS = "success"
+    WARNING = "warning"
+    ERROR = "error"
+
+
+@dataclass
+class ConfirmOptions:
+    """Options for confirmation dialog"""
+
+    message: str
+    title: str = "Confirm"
+    default: bool = False
+    ok_text: str = "Yes"
+    cancel_text: str = "No"
+    style: MessageStyle = MessageStyle.WARNING
+
+
+@dataclass
+class ChoiceOptions:
+    """Options for choice dialog"""
+
+    message: str
+    choices: List[str]
+    title: str = "Select"
+    default_index: int = 0
+
+
+class OutputAdapter(ABC):
+    """
+    Abstract output adapter interface.
+
+    This interface defines methods for:
+    1. Basic output (panel, table, text)
+    2. User interaction (confirm, choice, input)
+
+    All methods that request user interaction are async to support
+    both blocking (CLI) and non-blocking (TUI) implementations.
+    """
+
+    @abstractmethod
+    def panel(self, content: str, title: str = "", border_style: str = "blue") -> None:
+        """
+        Display a panel with content.
+
+        Args:
+            content: Panel content text
+            title: Panel title
+            border_style: Border color/style
+        """
+        pass
+
+    @abstractmethod
+    def table(self, headers: List[str], rows: List[List[str]], title: str = "") -> None:
+        """
+        Display a table.
+
+        Args:
+            headers: Column headers
+            rows: Table rows
+            title: Table title
+        """
+        pass
+
+    @abstractmethod
+    def text(self, content: str, style: str = "") -> None:
+        """
+        Display plain text.
+
+        Args:
+            content: Text content
+            style: Text style/color
+        """
+        pass
+
+    def info(self, content: str) -> None:
+        """
+        Display info message.
+
+        Args:
+            content: Message content
+        """
+        self.text(f"[blue]ℹ {content}[/blue]")
+
+    def success(self, content: str) -> None:
+        """
+        Display success message.
+
+        Args:
+            content: Message content
+        """
+        self.text(f"[green]✓ {content}[/green]")
+
+    def warning(self, content: str) -> None:
+        """
+        Display warning message.
+
+        Args:
+            content: Message content
+        """
+        self.text(f"[yellow]⚠ {content}[/yellow]")
+
+    def error(self, content: str) -> None:
+        """
+        Display error message.
+
+        Args:
+            content: Message content
+        """
+        self.text(f"[red]✗ {content}[/red]")
+
+    @abstractmethod
+    async def confirm(
+        self,
+        message: str,
+        title: str = "Confirm",
+        default: bool = False,
+        ok_text: str = "Yes",
+        cancel_text: str = "No",
+    ) -> bool:
+        """
+        Display a confirmation dialog and wait for user response.
+
+        Args:
+            message: Confirmation message
+            title: Dialog title
+            default: Default choice
+            ok_text: Text for confirmation button
+            cancel_text: Text for cancel button
+
+        Returns:
+            True if user confirmed, False if cancelled
+        """
+        pass
+
+    @abstractmethod
+    async def choice(
+        self,
+        message: str,
+        choices: List[str],
+        title: str = "Select",
+        default_index: int = 0,
+    ) -> int:
+        """
+        Display a choice dialog and wait for user selection.
+
+        Args:
+            message: Choice prompt message
+            choices: List of choices
+            title: Dialog title
+            default_index: Default selection index
+
+        Returns:
+            Selected index (0-based), or -1 if cancelled
+        """
+        pass
+
+    @abstractmethod
+    async def input(
+        self,
+        message: str,
+        title: str = "Input",
+        default: str = "",
+        placeholder: str = "",
+    ) -> Optional[str]:
+        """
+        Display an input dialog and wait for user input.
+
+        Args:
+            message: Input prompt message
+            title: Dialog title
+            default: Default value
+            placeholder: Placeholder text
+
+        Returns:
+            User input string, or None if cancelled
+        """
+        pass
+
+    @abstractmethod
+    def print(self, *args, **kwargs) -> None:
+        """
+        Generic print method for compatibility.
+
+        This method provides a fallback for any console.print() calls
+        that haven't been converted to the specific adapter methods.
+        """
+        pass

minion_code/adapters/rich_adapter.py

@@ -0,0 +1,169 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Rich Output Adapter - CLI implementation
+
+This adapter uses Rich Console for terminal output. It provides synchronous
+blocking behavior for user interactions, which is suitable for traditional
+CLI applications.
+"""
+
+from typing import List, Optional
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.prompt import Confirm, Prompt
+
+from .output_adapter import OutputAdapter
+
+
+class RichOutputAdapter(OutputAdapter):
+    """
+    Rich Console adapter for CLI mode.
+
+    This adapter provides direct terminal output using Rich Console.
+    All user interaction methods (confirm, choice, input) block execution
+    until the user responds in the terminal.
+    """
+
+    def __init__(self, console: Optional[Console] = None):
+        """
+        Initialize Rich adapter.
+
+        Args:
+            console: Rich Console instance. Creates new one if None.
+        """
+        self.console = console or Console()
+
+    def panel(self, content: str, title: str = "", border_style: str = "blue") -> None:
+        """Display a panel using Rich Panel."""
+        panel = Panel(content, title=title, border_style=border_style)
+        self.console.print(panel)
+
+    def table(self, headers: List[str], rows: List[List[str]], title: str = "") -> None:
+        """Display a table using Rich Table."""
+        table = Table(title=title, show_header=True, header_style="bold blue")
+
+        # Add columns
+        for header in headers:
+            table.add_column(header)
+
+        # Add rows
+        for row in rows:
+            table.add_row(*row)
+
+        self.console.print(table)
+
+    def text(self, content: str, style: str = "") -> None:
+        """Display plain text."""
+        if style:
+            self.console.print(content, style=style)
+        else:
+            self.console.print(content)
+
+    async def confirm(
+        self,
+        message: str,
+        title: str = "Confirm",
+        default: bool = False,
+        ok_text: str = "Yes",
+        cancel_text: str = "No",
+    ) -> bool:
+        """
+        Display confirmation dialog (blocking).
+
+        Shows a panel with the title and message, then uses Rich Confirm
+        to wait for user input in the terminal.
+        """
+        # Show title panel if provided
+        if title and title != "Confirm":
+            self.panel(message, title=title, border_style="yellow")
+            prompt_message = f"Continue? ({ok_text}/{cancel_text})"
+        else:
+            prompt_message = message
+
+        try:
+            return Confirm.ask(prompt_message, console=self.console, default=default)
+        except KeyboardInterrupt:
+            return False
+
+    async def choice(
+        self,
+        message: str,
+        choices: List[str],
+        title: str = "Select",
+        default_index: int = 0,
+    ) -> int:
+        """
+        Display choice dialog (blocking).
+
+        Shows numbered choices and waits for user to input a number.
+        """
+        # Show title if provided
+        if title:
+            self.console.print(f"[bold yellow]{title}[/bold yellow]")
+
+        # Show message
+        if message:
+            self.console.print(message)
+            self.console.print()
+
+        # Show choices
+        for i, choice in enumerate(choices):
+            marker = "→" if i == default_index else " "
+            self.console.print(f"  {marker} [{i+1}] {choice}")
+
+        self.console.print()
+
+        # Get user input
+        while True:
+            try:
+                choice_input = Prompt.ask(
+                    "Select number (or 'c' to cancel)",
+                    console=self.console,
+                    default=str(default_index + 1),
+                )
+
+                # Check for cancel
+                if choice_input.lower() in ["c", "cancel", "q", "quit"]:
+                    return -1
+
+                # Try to parse as number
+                index = int(choice_input) - 1
+                if 0 <= index < len(choices):
+                    return index
+
+                self.console.print("[red]Invalid choice. Please try again.[/red]")
+
+            except (ValueError, KeyboardInterrupt):
+                return -1
+
+    async def input(
+        self,
+        message: str,
+        title: str = "Input",
+        default: str = "",
+        placeholder: str = "",
+    ) -> Optional[str]:
+        """
+        Display input dialog (blocking).
+
+        Uses Rich Prompt to get text input from user.
+        """
+        # Show title if provided
+        if title:
+            self.console.print(f"[bold blue]{title}[/bold blue]")
+
+        # Combine message with placeholder if provided
+        prompt_message = message
+        if placeholder:
+            prompt_message = f"{message} (e.g., {placeholder})"
+
+        try:
+            return Prompt.ask(prompt_message, console=self.console, default=default)
+        except KeyboardInterrupt:
+            return None
+
+    def print(self, *args, **kwargs) -> None:
+        """Generic print for compatibility."""
+        self.console.print(*args, **kwargs)