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

minion_code/acp_server/hooks.py

@@ -0,0 +1,354 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+ACP-specific hooks for tool execution notifications.
+
+These hooks integrate with the ACP protocol to send session_update
+notifications when tools are called.
+"""
+
+import logging
+import uuid
+from dataclasses import dataclass, field
+from typing import Any, Dict, Optional
+
+from acp import Client
+from acp.schema import (
+    ToolCallStart,
+    ToolCallProgress,
+    ToolCallUpdate,
+    PermissionOption,
+    TextContentBlock,
+    ContentToolCallContent,
+)
+
+from ..agents.hooks import (
+    HookConfig,
+    PreToolUseResult,
+    PostToolUseResult,
+    PermissionDecision,
+)
+from .permissions import PermissionStore
+
+logger = logging.getLogger(__name__)
+
+
+# Map tool names to ToolKind
+TOOL_KIND_MAP = {
+    "file_read": "read",
+    "file_write": "edit",
+    "file_edit": "edit",
+    "glob": "search",
+    "grep": "search",
+    "bash": "execute",
+    "python_interpreter": "execute",
+    "web_fetch": "fetch",
+    "web_search": "search",
+    "think": "think",
+}
+
+# Tools that are safe and don't need permission
+# These are read-only, internal, or non-destructive operations
+SAFE_TOOLS = {
+    # Read-only tools
+    # "file_read",
+    # "glob",
+    # "grep",
+    # "ls",
+    # "todo_read",
+    # Internal/non-destructive tools
+    "think",
+    "final_answer",
+    "user_input",
+    # Note: file_write, file_edit, bash, python_interpreter are NOT safe
+}
+
+
+def get_tool_kind(tool_name: str) -> str:
+    """Get the ACP ToolKind for a tool name."""
+    return TOOL_KIND_MAP.get(tool_name, "other")
+
+
+@dataclass
+class ACPToolHooks:
+    """
+    ACP-specific tool hooks that send session_update notifications.
+
+    This class creates pre/post tool use hooks that:
+    1. pre_tool_use: Sends ToolCallStart notification (status="in_progress")
+    2. post_tool_use: Sends ToolCallProgress update (status="completed"/"failed")
+    """
+
+    client: Client
+    session_id: str
+    request_permission: bool = False  # Whether to request permission via ACP
+    permission_store: Optional[PermissionStore] = None  # Persistent permission storage
+    _tool_call_ids: Dict[str, str] = field(default_factory=dict)
+
+    @staticmethod
+    def _generate_tool_call_id() -> str:
+        """Generate a unique tool call ID."""
+        return str(uuid.uuid4())
+
+    async def pre_tool_use(
+        self, tool_name: str, tool_input: Dict[str, Any], tool_use_id: str
+    ) -> PreToolUseResult:
+        """
+        Pre-tool-use hook that sends ToolCallStart notification.
+
+        Sends a session_update with ToolCallStart to notify the ACP client
+        that a tool is about to be executed.
+        """
+        # Generate and store tool call ID
+        tool_call_id = self._generate_tool_call_id()
+        self._tool_call_ids[tool_use_id] = tool_call_id
+
+        # Check if this tool needs permission
+        needs_permission = self.request_permission and tool_name not in SAFE_TOOLS
+
+        if tool_name in SAFE_TOOLS:
+            logger.debug(f"Tool {tool_name} is safe, skipping permission request")
+
+        # Check persistent permissions first
+        if needs_permission and self.permission_store:
+            stored_permission = self.permission_store.is_allowed(tool_name)
+            if stored_permission is True:
+                logger.info(
+                    f"Tool {tool_name} has persistent allow permission, skipping request"
+                )
+                needs_permission = False
+            elif stored_permission is False:
+                logger.info(f"Tool {tool_name} has persistent reject permission")
+                return PreToolUseResult(
+                    decision=PermissionDecision.DENY,
+                    reason="Tool permanently rejected by user",
+                )
+
+        # Request permission via ACP if enabled and tool is not safe
+        if needs_permission:
+            try:
+                # Create permission options
+                options = [
+                    PermissionOption(
+                        option_id="allow_once",
+                        name="Allow once",
+                        kind="allow_once",
+                    ),
+                    PermissionOption(
+                        option_id="allow_always",
+                        name="Always allow this tool",
+                        kind="allow_always",
+                    ),
+                    PermissionOption(
+                        option_id="reject_once",
+                        name="Reject",
+                        kind="reject_once",
+                    ),
+                ]
+
+                # Create tool call info for permission request (use ToolCallUpdate, not ToolCallStart)
+                tool_call_for_permission = ToolCallUpdate(
+                    tool_call_id=tool_call_id,
+                    title=f"Permission: {tool_name}",
+                    kind=get_tool_kind(tool_name),
+                    status="pending",
+                    content=[
+                        ContentToolCallContent(
+                            type="content",
+                            content=TextContentBlock(
+                                type="text",
+                                text=f"Tool: {tool_name}\nInput: {tool_input}",
+                            ),
+                        )
+                    ],
+                )
+
+                # Request permission from user
+                permission_response = await self.client.request_permission(
+                    options=options,
+                    session_id=self.session_id,
+                    tool_call=tool_call_for_permission,
+                )
+
+                # Check response - extract option_id and outcome
+                raw_outcome = permission_response.outcome
+                option_id = None
+                outcome = raw_outcome
+
+                # Handle nested structures from different ACP clients
+                if hasattr(raw_outcome, "option_id"):
+                    option_id = raw_outcome.option_id
+                if hasattr(raw_outcome, "outcome"):
+                    outcome = raw_outcome.outcome
+                    if hasattr(outcome, "option_id"):
+                        option_id = outcome.option_id
+
+                # Use option_id if available (more reliable), otherwise fall back to outcome
+                selected = option_id or outcome
+
+                logger.info(
+                    f"Permission response for {tool_name}: selected={selected}, option_id={option_id}, outcome={outcome}"
+                )
+
+                if selected in ("rejected", "reject_once", "reject_always"):
+                    logger.info(f"Permission denied for {tool_name}: {selected}")
+                    # Save persistent rejection if "always"
+                    if selected == "reject_always" and self.permission_store:
+                        self.permission_store.set_permission(
+                            tool_name, always_allow=False
+                        )
+                    return PreToolUseResult(
+                        decision=PermissionDecision.DENY,
+                        reason="User denied permission",
+                    )
+
+                # Save persistent allowance if "always"
+                if selected == "allow_always" and self.permission_store:
+                    self.permission_store.set_permission(tool_name, always_allow=True)
+                    logger.info(f"Saved persistent allow permission for {tool_name}")
+
+                logger.info(f"Permission granted for {tool_name}: {selected}")
+
+            except Exception as e:
+                logger.error(f"Failed to request permission: {e}")
+                # Continue without permission on error (fail open)
+
+        # Send tool_call start notification
+        try:
+            tool_call = ToolCallStart(
+                session_update="tool_call",
+                tool_call_id=tool_call_id,
+                title=f"Running {tool_name}",
+                kind=get_tool_kind(tool_name),
+                status="in_progress",
+                raw_input=tool_input,
+            )
+            await self.client.session_update(
+                session_id=self.session_id,
+                update=tool_call,
+            )
+        except Exception as e:
+            logger.error(f"Failed to send tool_call notification: {e}")
+
+        return PreToolUseResult(decision=PermissionDecision.ACCEPT)
+
+    async def post_tool_use(
+        self,
+        tool_name: str,
+        tool_input: Dict[str, Any],
+        tool_use_id: str,
+        result: Any,
+        error: Optional[Exception] = None,
+    ) -> PostToolUseResult:
+        """
+        Post-tool-use hook that sends ToolCallProgress notification.
+
+        Sends a session_update with ToolCallProgress to notify the ACP client
+        about the tool execution result.
+        """
+        # Get the tool call ID
+        tool_call_id = self._tool_call_ids.pop(tool_use_id, None)
+        if not tool_call_id:
+            logger.warning(f"No tool_call_id found for {tool_use_id}")
+            return PostToolUseResult()
+
+        # Determine status and format output
+        if error:
+            status = "failed"
+            output = str(error)
+        else:
+            status = "completed"
+            # Format result for display
+            if isinstance(result, str):
+                output = result
+            elif result is None:
+                output = "(no output)"
+            else:
+                try:
+                    import json
+
+                    output = json.dumps(result, indent=2, default=str)
+                except Exception:
+                    output = str(result)
+
+        # Send tool_call progress notification
+        try:
+            update = ToolCallProgress(
+                session_update="tool_call_update",
+                tool_call_id=tool_call_id,
+                status=status,
+                raw_output=output,
+            )
+            await self.client.session_update(
+                session_id=self.session_id,
+                update=update,
+            )
+        except Exception as e:
+            logger.error(f"Failed to send tool_call_update notification: {e}")
+
+        return PostToolUseResult()
+
+
+def create_acp_hooks(
+    client: Client,
+    session_id: str,
+    request_permission: bool = False,
+    include_dangerous_check: bool = True,
+    permission_store: Optional[PermissionStore] = None,
+) -> HookConfig:
+    """
+    Create HookConfig with ACP-specific hooks.
+
+    Args:
+        client: ACP Client instance
+        session_id: Current session ID
+        request_permission: Whether to request permission via ACP for tool calls
+        include_dangerous_check: Whether to include dangerous command blocking
+        permission_store: Optional persistent permission storage
+
+    Returns:
+        HookConfig configured for ACP integration
+    """
+    acp_hooks = ACPToolHooks(
+        client=client,
+        session_id=session_id,
+        request_permission=request_permission,
+        permission_store=permission_store,
+    )
+
+    # Create hook functions
+    async def acp_pre_tool_use(
+        tool_name: str, tool_input: Dict[str, Any], tool_use_id: str
+    ) -> PreToolUseResult:
+        return await acp_hooks.pre_tool_use(tool_name, tool_input, tool_use_id)
+
+    async def acp_post_tool_use(
+        tool_name: str,
+        tool_input: Dict[str, Any],
+        tool_use_id: str,
+        result: Any,
+        error: Optional[Exception] = None,
+    ) -> PostToolUseResult:
+        return await acp_hooks.post_tool_use(
+            tool_name, tool_input, tool_use_id, result, error
+        )
+
+    config = HookConfig()
+
+    # Add dangerous command check if requested
+    if include_dangerous_check:
+        from ..agents.hooks import create_dangerous_command_check_hook
+
+        config.add_pre_tool_use("bash", create_dangerous_command_check_hook())
+
+    # Add ACP hooks for all tools
+    config.add_pre_tool_use("*", acp_pre_tool_use)
+    config.add_post_tool_use("*", acp_post_tool_use)
+
+    return config
+
+
+__all__ = [
+    "ACPToolHooks",
+    "create_acp_hooks",
+]

minion_code/acp_server/main.py

@@ -0,0 +1,194 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+ACP server entry point for minion-code.
+
+This module provides the main entry point for running minion-code
+as an ACP agent over stdio.
+
+Usage:
+    mcode acp
+    mcode acp --dangerously-skip-permissions
+    python -m minion_code.acp_server.main
+"""
+
+import asyncio
+import json
+import logging
+import os
+import sys
+from pathlib import Path
+from typing import Optional
+
+# Save original stdout for ACP communication
+_original_stdout = sys.stdout
+
+# Configure loguru to use stderr BEFORE any imports that use it
+# This is critical for ACP - stdout is reserved for JSON-RPC communication
+from loguru import logger as loguru_logger
+
+loguru_logger.remove()  # Remove default handler
+loguru_logger.add(
+    sys.stderr, format="{time} | {level} | {name}:{function}:{line} - {message}"
+)
+
+# Also redirect standard stdout to stderr for any stray prints
+sys.stdout = sys.stderr
+
+# Now import everything else
+from acp import run_agent
+
+from .agent import MinionACPAgent
+
+logger = logging.getLogger(__name__)
+
+# Config directory
+MINION_CONFIG_DIR = Path.home() / ".minion"
+MINION_CODE_CONFIG = MINION_CONFIG_DIR / "minion-code.json"
+
+
+def ensure_config_dir() -> Path:
+    """Ensure ~/.minion directory exists."""
+    MINION_CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    return MINION_CONFIG_DIR
+
+
+def load_config() -> dict:
+    """Load minion-code config from ~/.minion/minion-code.json"""
+    if MINION_CODE_CONFIG.exists():
+        try:
+            with open(MINION_CODE_CONFIG, "r") as f:
+                return json.load(f)
+        except Exception as e:
+            logger.warning(f"Failed to load config: {e}")
+    return {}
+
+
+def save_config(config: dict) -> None:
+    """Save minion-code config to ~/.minion/minion-code.json"""
+    ensure_config_dir()
+    try:
+        with open(MINION_CODE_CONFIG, "w") as f:
+            json.dump(config, f, indent=2)
+    except Exception as e:
+        logger.warning(f"Failed to save config: {e}")
+
+
+def get_session_log_dir(cwd: str) -> Path:
+    """Get session log directory for a project."""
+    # Hash the cwd to create a unique folder name
+    import hashlib
+
+    cwd_hash = hashlib.md5(cwd.encode()).hexdigest()[:8]
+    project_name = Path(cwd).name
+    session_dir = MINION_CONFIG_DIR / "sessions" / f"{project_name}-{cwd_hash}"
+    session_dir.mkdir(parents=True, exist_ok=True)
+    return session_dir
+
+
+def setup_logging(level: str = "INFO") -> None:
+    """Setup logging to stderr and file (stdout is used for ACP protocol)."""
+    # Log to stderr
+    logging.basicConfig(
+        level=getattr(logging, level.upper()),
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+        stream=sys.stderr,
+    )
+    # Also log to file for debugging
+    debug_log = os.path.expanduser("~/minion-code-acp-debug.log")
+    file_handler = logging.FileHandler(debug_log, mode="a")
+    file_handler.setFormatter(
+        logging.Formatter(
+            "%(asctime)s - PID=%(process)d - %(name)s - %(levelname)s - %(message)s"
+        )
+    )
+    logging.getLogger().addHandler(file_handler)
+
+
+def main(
+    log_level: str = "INFO",
+    dangerously_skip_permissions: bool = False,
+    cwd: Optional[str] = None,
+    model: Optional[str] = None,
+) -> None:
+    """
+    Main entry point for running minion-code as an ACP agent.
+
+    This function:
+    1. Redirects stdout to stderr (stdout is reserved for ACP)
+    2. Sets up logging
+    3. Creates the MinionACPAgent
+    4. Runs the ACP server over stdio
+
+    Args:
+        log_level: Logging level (DEBUG, INFO, WARNING, ERROR)
+        dangerously_skip_permissions: If True, skip permission prompts for tool calls
+        cwd: Working directory for the agent (defaults to current directory)
+        model: LLM model to use (defaults to config file setting)
+    """
+    setup_logging(log_level)
+    pid = os.getpid()
+    logger.info(f"Starting minion-code ACP agent [PID={pid}]")
+
+    # Resolve working directory
+    if cwd:
+        cwd = os.path.abspath(cwd)
+        logger.info(f"Using working directory: {cwd}")
+    else:
+        cwd = os.getcwd()
+
+    # Load config
+    config = load_config()
+
+    # Handle model: CLI arg > config file > default
+    if model:
+        logger.info(f"Using model from CLI: {model}")
+    elif config.get("model"):
+        model = config.get("model")
+        logger.info(f"Using model from config: {model}")
+    else:
+        logger.info("Using default model (from MinionCodeAgent)")
+
+    # Check if permissions should be skipped
+    skip_permissions = dangerously_skip_permissions or config.get(
+        "skip_permissions", False
+    )
+    if skip_permissions:
+        logger.warning("Permission prompts DISABLED (--dangerously-skip-permissions)")
+
+    # Create the agent with config
+    agent = MinionACPAgent(
+        skip_permissions=skip_permissions,
+        config=config,
+        cwd=cwd,
+        model=model,
+    )
+
+    # Restore stdout for ACP communication
+    sys.stdout = _original_stdout
+
+    # Run the ACP agent (run_agent is an async function)
+    try:
+        asyncio.run(run_agent(agent))
+    except KeyboardInterrupt:
+        logger.info("Shutting down ACP agent")
+    except Exception as e:
+        logger.error(f"ACP agent error: {e}")
+        raise
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Minion Code ACP Agent")
+    parser.add_argument("--log-level", default="INFO", help="Log level")
+    parser.add_argument(
+        "--dangerously-skip-permissions",
+        action="store_true",
+        help="Skip permission prompts for tool calls",
+    )
+    args = parser.parse_args()
+    main(
+        log_level=args.log_level,
+        dangerously_skip_permissions=args.dangerously_skip_permissions,
+    )

minion_code/acp_server/permissions.py

@@ -0,0 +1,142 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Permission store for persistent tool permissions.
+
+Stores user's "always allow" and "always reject" preferences
+per project in ~/.minion/sessions/<project>-<hash>/permissions.json
+"""
+
+import hashlib
+import json
+import logging
+from pathlib import Path
+from typing import Optional, Set, Dict
+
+logger = logging.getLogger(__name__)
+
+
+class PermissionStore:
+    """
+    Manages persistent tool permission preferences per project.
+
+    Stores permissions in ~/.minion/sessions/<project-name>-<hash>/permissions.json
+    """
+
+    def __init__(self, cwd: str):
+        """
+        Initialize permission store for a specific project.
+
+        Args:
+            cwd: The working directory (project root) for this session
+        """
+        cwd_hash = hashlib.md5(cwd.encode()).hexdigest()[:8]
+        project_name = Path(cwd).name
+        self.config_dir = (
+            Path.home() / ".minion" / "sessions" / f"{project_name}-{cwd_hash}"
+        )
+        self.permissions_file = self.config_dir / "permissions.json"
+
+        # Permission sets
+        self._allow_always: Set[str] = set()
+        self._reject_always: Set[str] = set()
+
+        # Load existing permissions
+        self._load()
+
+    def is_allowed(self, tool_name: str) -> Optional[bool]:
+        """
+        Check if tool has persistent permission.
+
+        Args:
+            tool_name: Name of the tool to check
+
+        Returns:
+            True if always allowed, False if always rejected, None if not set
+        """
+        if tool_name in self._allow_always:
+            return True
+        if tool_name in self._reject_always:
+            return False
+        return None
+
+    def set_permission(self, tool_name: str, always_allow: bool) -> None:
+        """
+        Set persistent permission for a tool.
+
+        Args:
+            tool_name: Name of the tool
+            always_allow: True to always allow, False to always reject
+        """
+        if always_allow:
+            self._allow_always.add(tool_name)
+            self._reject_always.discard(tool_name)
+            logger.info(f"Set permission: always allow '{tool_name}'")
+        else:
+            self._reject_always.add(tool_name)
+            self._allow_always.discard(tool_name)
+            logger.info(f"Set permission: always reject '{tool_name}'")
+
+        self._save()
+
+    def clear_permission(self, tool_name: str) -> None:
+        """
+        Clear permission for a tool (reset to ask every time).
+
+        Args:
+            tool_name: Name of the tool
+        """
+        self._allow_always.discard(tool_name)
+        self._reject_always.discard(tool_name)
+        self._save()
+        logger.info(f"Cleared permission for '{tool_name}'")
+
+    def clear_all(self) -> None:
+        """Clear all permissions."""
+        self._allow_always.clear()
+        self._reject_always.clear()
+        self._save()
+        logger.info("Cleared all permissions")
+
+    def get_all(self) -> Dict[str, list]:
+        """Get all permissions as a dict."""
+        return {
+            "allow_always": sorted(self._allow_always),
+            "reject_always": sorted(self._reject_always),
+        }
+
+    def _load(self) -> None:
+        """Load permissions from file."""
+        if not self.permissions_file.exists():
+            return
+
+        try:
+            with open(self.permissions_file, "r") as f:
+                data = json.load(f)
+
+            self._allow_always = set(data.get("allow_always", []))
+            self._reject_always = set(data.get("reject_always", []))
+            logger.debug(f"Loaded permissions from {self.permissions_file}")
+        except Exception as e:
+            logger.warning(f"Failed to load permissions: {e}")
+
+    def _save(self) -> None:
+        """Save permissions to file."""
+        try:
+            # Ensure directory exists
+            self.config_dir.mkdir(parents=True, exist_ok=True)
+
+            data = {
+                "allow_always": sorted(self._allow_always),
+                "reject_always": sorted(self._reject_always),
+            }
+
+            with open(self.permissions_file, "w") as f:
+                json.dump(data, f, indent=2)
+
+            logger.debug(f"Saved permissions to {self.permissions_file}")
+        except Exception as e:
+            logger.error(f"Failed to save permissions: {e}")
+
+
+__all__ = ["PermissionStore"]