monoco-toolkit 0.3.11__py3-none-any.whl → 0.3.12__py3-none-any.whl

monoco/core/config.py

@@ -160,7 +160,7 @@ class AgentConcurrencyConfig(BaseModel):
     engineer: int = Field(default=1, description="Maximum concurrent Engineer agents")
     architect: int = Field(default=1, description="Maximum concurrent Architect agents")
     reviewer: int = Field(default=1, description="Maximum concurrent Reviewer agents")
-    planner: int = Field(default=1, description="Maximum concurrent Planner agents")
+    # Note: Planner role removed in FEAT-0155 (was never used)
     # Cool-down configuration
     failure_cooldown_seconds: int = Field(default=60, description="Cooldown period after a failure before retrying")
 

monoco/core/executor/__init__.py

@@ -0,0 +1,38 @@
+"""
+Executor Module - Layer 3 of the Event Automation Framework.
+
+This module provides concrete Action implementations for various execution types.
+It is part of the three-layer architecture:
+- Layer 1: File Watcher
+- Layer 2: Action Router
+- Layer 3: Action Executor (this module)
+
+Available Actions:
+- SpawnAgentAction: Spawn agent sessions
+- RunPytestAction: Execute pytest tests
+- GitCommitAction: Perform git commits
+- GitPushAction: Push to remote
+- SendIMAction: Send notifications
+
+Example Usage:
+    >>> from monoco.core.executor import SpawnAgentAction
+    >>> from monoco.core.scheduler import AgentEventType
+    >>> from monoco.core.router import ActionRouter
+    >>> 
+    >>> action = SpawnAgentAction(role="Engineer")
+    >>> router = ActionRouter()
+    >>> router.register(AgentEventType.ISSUE_STAGE_CHANGED, action)
+"""
+
+from .agent_action import SpawnAgentAction
+from .pytest_action import RunPytestAction
+from .git_action import GitCommitAction, GitPushAction
+from .im_action import SendIMAction
+
+__all__ = [
+    "SpawnAgentAction",
+    "RunPytestAction",
+    "GitCommitAction",
+    "GitPushAction",
+    "SendIMAction",
+]

monoco/core/executor/agent_action.py

@@ -0,0 +1,254 @@
+"""
+SpawnAgentAction - Action for spawning agent sessions.
+
+Part of Layer 3 (Action Executor) in the event automation framework.
+Uses AgentScheduler to spawn and manage agent sessions.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, List, Optional
+
+from monoco.core.scheduler import AgentEvent, AgentEventType, AgentScheduler, AgentTask
+from monoco.core.router import Action, ActionResult
+from monoco.features.agent.models import RoleTemplate
+
+logger = logging.getLogger(__name__)
+
+
+class SpawnAgentAction(Action):
+    """
+    Action that spawns an agent session.
+    
+    This action creates and starts a new agent session based on the event.
+    It supports different roles (Architect, Engineer, Reviewer, etc.)
+    and integrates with the AgentScheduler for lifecycle management.
+    
+    Example:
+        >>> action = SpawnAgentAction(
+        ...     role="Engineer",
+        ...     scheduler=scheduler,
+        ... )
+        >>> result = await action(event)
+    """
+    
+    ROLE_TEMPLATES = {
+        "Architect": {
+            "description": "System Architect",
+            "trigger": "memo.accumulation",
+            "goal": "Process memo inbox and create issues.",
+            "system_prompt": "You are the Architect. Process the Memo inbox.",
+            "engine": "gemini",
+        },
+        "Engineer": {
+            "description": "Software Engineer",
+            "trigger": "issue.stage_changed",
+            "goal": "Implement feature requirements.",
+            "system_prompt": "You are a Software Engineer. Read the issue and implement requirements.",
+            "engine": "gemini",
+        },
+        "Reviewer": {
+            "description": "Code Reviewer",
+            "trigger": "pr.created",
+            "goal": "Review code changes thoroughly.",
+            "system_prompt": "You are a Code Reviewer. Review the code changes thoroughly.",
+            "engine": "gemini",
+        },
+        "Coroner": {
+            "description": "Session Autopsy",
+            "trigger": "session.failed",
+            "goal": "Analyze failed session and create incident report.",
+            "system_prompt": "You are the Coroner. Analyze the failed session.",
+            "engine": "gemini",
+        },
+    }
+    
+    def __init__(
+        self,
+        role: str,
+        scheduler: AgentScheduler,
+        config: Optional[Dict[str, Any]] = None,
+        custom_role_template: Optional[Dict[str, str]] = None,
+    ):
+        super().__init__(config)
+        self.role = role
+        self.scheduler = scheduler
+        self.custom_role_template = custom_role_template
+        self._spawned_sessions: List[str] = []
+    
+    @property
+    def name(self) -> str:
+        return f"SpawnAgentAction({self.role})"
+    
+    async def can_execute(self, event: AgentEvent) -> bool:
+        """
+        Check if we should spawn an agent.
+        
+        Conditions:
+        - Scheduler has capacity for new tasks
+        """
+        # Check scheduler capacity
+        stats = self.scheduler.get_stats()
+        active_tasks = stats.get("active_tasks", 0)
+        max_concurrent = stats.get("max_concurrent", 5)
+        
+        if active_tasks >= max_concurrent:
+            logger.warning(f"Scheduler at capacity ({active_tasks}/{max_concurrent}), skipping")
+            return False
+        
+        return True
+    
+    async def execute(self, event: AgentEvent) -> ActionResult:
+        """Spawn an agent session."""
+        issue_id = event.payload.get("issue_id", "unknown")
+        issue_title = event.payload.get("issue_title", "Unknown")
+        
+        logger.info(f"Spawning {self.role} agent for {issue_id}")
+        
+        try:
+            # Create AgentTask
+            task = AgentTask(
+                task_id=f"{self.role.lower()}-{issue_id}-{event.timestamp.timestamp()}",
+                role_name=self.role,
+                issue_id=issue_id,
+                prompt=self._build_prompt(issue_id, issue_title),
+                engine=self._get_engine(),
+                timeout=self.config.get("timeout", 1800),
+                metadata={
+                    "trigger": event.type.value,
+                    "issue_title": issue_title,
+                },
+            )
+            
+            # Schedule task
+            session_id = await self.scheduler.schedule(task)
+            
+            # Track spawned session
+            self._spawned_sessions.append(session_id)
+            
+            logger.info(f"{self.role} scheduled: session={session_id}")
+            
+            return ActionResult.success_result(
+                output={
+                    "session_id": session_id,
+                    "issue_id": issue_id,
+                    "role": self.role,
+                },
+                metadata={
+                    "task_id": task.task_id,
+                },
+            )
+        
+        except Exception as e:
+            logger.error(f"Failed to spawn {self.role} for {issue_id}: {e}")
+            return ActionResult.failure_result(
+                error=str(e),
+                metadata={
+                    "issue_id": issue_id,
+                    "role": self.role,
+                },
+            )
+    
+    def _build_prompt(self, issue_id: str, issue_title: str) -> str:
+        """Build the prompt for the agent."""
+        template = self.ROLE_TEMPLATES.get(self.role, self.ROLE_TEMPLATES["Engineer"])
+        
+        return f"""You are a {template['description']}. 
+
+Issue: {issue_id} - {issue_title}
+
+Goal: {template['goal']}
+
+{template['system_prompt']}
+"""
+    
+    def _get_engine(self) -> str:
+        """Get the engine for this role."""
+        if self.custom_role_template:
+            return self.custom_role_template.get("engine", "gemini")
+        template = self.ROLE_TEMPLATES.get(self.role, self.ROLE_TEMPLATES["Engineer"])
+        return template["engine"]
+    
+    def get_spawned_sessions(self) -> List[str]:
+        """Get list of session IDs spawned by this action."""
+        return self._spawned_sessions.copy()
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """Get action statistics."""
+        stats = super().get_stats()
+        stats.update({
+            "role": self.role,
+            "spawned_sessions": len(self._spawned_sessions),
+        })
+        return stats
+
+
+class SpawnArchitectAction(SpawnAgentAction):
+    """Convenience action for spawning Architect agents."""
+    
+    def __init__(
+        self,
+        scheduler: AgentScheduler,
+        config: Optional[Dict[str, Any]] = None,
+    ):
+        super().__init__(
+            role="Architect",
+            scheduler=scheduler,
+            config=config,
+        )
+    
+    async def can_execute(self, event: AgentEvent) -> bool:
+        """Only execute for MEMO_THRESHOLD events."""
+        if event.type != AgentEventType.MEMO_THRESHOLD:
+            return False
+        return await super().can_execute(event)
+
+
+class SpawnEngineerAction(SpawnAgentAction):
+    """Convenience action for spawning Engineer agents."""
+    
+    def __init__(
+        self,
+        scheduler: AgentScheduler,
+        config: Optional[Dict[str, Any]] = None,
+    ):
+        super().__init__(
+            role="Engineer",
+            scheduler=scheduler,
+            config=config,
+        )
+    
+    async def can_execute(self, event: AgentEvent) -> bool:
+        """Only execute for ISSUE_STAGE_CHANGED to 'doing' events."""
+        if event.type != AgentEventType.ISSUE_STAGE_CHANGED:
+            return False
+        
+        new_stage = event.payload.get("new_stage")
+        issue_status = event.payload.get("issue_status")
+        
+        if new_stage != "doing" or issue_status != "open":
+            return False
+        
+        return await super().can_execute(event)
+
+
+class SpawnReviewerAction(SpawnAgentAction):
+    """Convenience action for spawning Reviewer agents."""
+    
+    def __init__(
+        self,
+        scheduler: AgentScheduler,
+        config: Optional[Dict[str, Any]] = None,
+    ):
+        super().__init__(
+            role="Reviewer",
+            scheduler=scheduler,
+            config=config,
+        )
+    
+    async def can_execute(self, event: AgentEvent) -> bool:
+        """Only execute for PR_CREATED events."""
+        if event.type != AgentEventType.PR_CREATED:
+            return False
+        return await super().can_execute(event)

monoco/core/executor/git_action.py

@@ -0,0 +1,303 @@
+"""
+Git Actions - Actions for git operations.
+
+Part of Layer 3 (Action Executor) in the event automation framework.
+Provides actions for git commit and push operations.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from monoco.core.scheduler import AgentEvent
+from monoco.core.router import Action, ActionResult
+
+logger = logging.getLogger(__name__)
+
+
+class GitResult:
+    """Result of a git command execution."""
+    
+    def __init__(
+        self,
+        returncode: int,
+        stdout: str,
+        stderr: str,
+    ):
+        self.returncode = returncode
+        self.stdout = stdout
+        self.stderr = stderr
+    
+    @property
+    def success(self) -> bool:
+        return self.returncode == 0
+
+
+class GitCommitAction(Action):
+    """
+    Action that performs git commit.
+    
+    This action stages files and creates a git commit with a message.
+    
+    Example:
+        >>> action = GitCommitAction(
+        ...     message="Auto-commit: {issue_id}",
+        ...     files=["*.py"],
+        ...     add_all=False,
+        ... )
+        >>> result = await action(event)
+    """
+    
+    def __init__(
+        self,
+        message: str,
+        files: Optional[List[str]] = None,
+        add_all: bool = False,
+        working_dir: Optional[Path] = None,
+        timeout: int = 30,
+        config: Optional[Dict[str, Any]] = None,
+    ):
+        super().__init__(config)
+        self.message = message
+        self.files = files or []
+        self.add_all = add_all
+        self.working_dir = working_dir or Path.cwd()
+        self.timeout = timeout
+        self._last_result: Optional[GitResult] = None
+    
+    @property
+    def name(self) -> str:
+        return "GitCommitAction"
+    
+    async def can_execute(self, event: AgentEvent) -> bool:
+        """Check if we're in a git repository."""
+        git_dir = self.working_dir / ".git"
+        return git_dir.exists()
+    
+    async def execute(self, event: AgentEvent) -> ActionResult:
+        """Perform git commit."""
+        # Format message with event data
+        formatted_message = self._format_message(event)
+        
+        logger.info(f"Performing git commit: {formatted_message[:50]}...")
+        
+        try:
+            # Stage files
+            if self.add_all:
+                await self._run_git_command(["git", "add", "-A"])
+            elif self.files:
+                for file_pattern in self.files:
+                    await self._run_git_command(["git", "add", file_pattern])
+            
+            # Check if there are changes to commit
+            status_result = await self._run_git_command(
+                ["git", "status", "--porcelain"]
+            )
+            
+            if not status_result.stdout.strip():
+                logger.info("No changes to commit")
+                return ActionResult.success_result(
+                    output={"committed": False, "reason": "no_changes"},
+                )
+            
+            # Commit
+            commit_result = await self._run_git_command(
+                ["git", "commit", "-m", formatted_message]
+            )
+            self._last_result = commit_result
+            
+            if commit_result.success:
+                # Get commit hash
+                hash_result = await self._run_git_command(
+                    ["git", "rev-parse", "HEAD"]
+                )
+                commit_hash = hash_result.stdout.strip()
+                
+                return ActionResult.success_result(
+                    output={
+                        "committed": True,
+                        "commit_hash": commit_hash,
+                        "message": formatted_message,
+                    },
+                )
+            else:
+                return ActionResult.failure_result(
+                    error=f"Git commit failed: {commit_result.stderr}",
+                )
+        
+        except Exception as e:
+            logger.error(f"Git commit failed: {e}")
+            return ActionResult.failure_result(error=str(e))
+    
+    def _format_message(self, event: AgentEvent) -> str:
+        """Format commit message with event data."""
+        try:
+            return self.message.format(**event.payload)
+        except (KeyError, ValueError):
+            # If formatting fails, return original message
+            return self.message
+    
+    async def _run_git_command(self, cmd: List[str]) -> GitResult:
+        """Execute a git command."""
+        process = await asyncio.create_subprocess_exec(
+            *cmd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            cwd=self.working_dir,
+        )
+        
+        try:
+            stdout, stderr = await asyncio.wait_for(
+                process.communicate(),
+                timeout=self.timeout,
+            )
+        except asyncio.TimeoutError:
+            process.kill()
+            raise RuntimeError(f"Git command timed out: {' '.join(cmd)}")
+        
+        return GitResult(
+            returncode=process.returncode,
+            stdout=stdout.decode("utf-8", errors="replace"),
+            stderr=stderr.decode("utf-8", errors="replace"),
+        )
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """Get action statistics."""
+        stats = super().get_stats()
+        stats.update({
+            "working_dir": str(self.working_dir),
+            "message_template": self.message,
+        })
+        return stats
+
+
+class GitPushAction(Action):
+    """
+    Action that performs git push.
+    
+    This action pushes commits to a remote repository.
+    
+    Example:
+        >>> action = GitPushAction(
+        ...     remote="origin",
+        ...     branch="main",
+        ... )
+        >>> result = await action(event)
+    """
+    
+    def __init__(
+        self,
+        remote: str = "origin",
+        branch: Optional[str] = None,
+        force: bool = False,
+        working_dir: Optional[Path] = None,
+        timeout: int = 60,
+        config: Optional[Dict[str, Any]] = None,
+    ):
+        super().__init__(config)
+        self.remote = remote
+        self.branch = branch
+        self.force = force
+        self.working_dir = working_dir or Path.cwd()
+        self.timeout = timeout
+        self._last_result: Optional[GitResult] = None
+    
+    @property
+    def name(self) -> str:
+        return "GitPushAction"
+    
+    async def can_execute(self, event: AgentEvent) -> bool:
+        """Check if we're in a git repository with a remote."""
+        git_dir = self.working_dir / ".git"
+        if not git_dir.exists():
+            return False
+        
+        # Check if remote exists
+        try:
+            result = await self._run_git_command(
+                ["git", "remote", "get-url", self.remote]
+            )
+            return result.success
+        except Exception:
+            return False
+    
+    async def execute(self, event: AgentEvent) -> ActionResult:
+        """Perform git push."""
+        # Determine branch
+        branch = self.branch
+        if not branch:
+            # Get current branch
+            result = await self._run_git_command(
+                ["git", "rev-parse", "--abbrev-ref", "HEAD"]
+            )
+            if result.success:
+                branch = result.stdout.strip()
+            else:
+                return ActionResult.failure_result(
+                    error="Could not determine current branch"
+                )
+        
+        logger.info(f"Pushing to {self.remote}/{branch}")
+        
+        try:
+            # Build command
+            cmd = ["git", "push", self.remote, branch]
+            if self.force:
+                cmd.append("--force-with-lease")
+            
+            result = await self._run_git_command(cmd)
+            self._last_result = result
+            
+            if result.success:
+                return ActionResult.success_result(
+                    output={
+                        "pushed": True,
+                        "remote": self.remote,
+                        "branch": branch,
+                    },
+                )
+            else:
+                return ActionResult.failure_result(
+                    error=f"Git push failed: {result.stderr}",
+                )
+        
+        except Exception as e:
+            logger.error(f"Git push failed: {e}")
+            return ActionResult.failure_result(error=str(e))
+    
+    async def _run_git_command(self, cmd: List[str]) -> GitResult:
+        """Execute a git command."""
+        process = await asyncio.create_subprocess_exec(
+            *cmd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            cwd=self.working_dir,
+        )
+        
+        try:
+            stdout, stderr = await asyncio.wait_for(
+                process.communicate(),
+                timeout=self.timeout,
+            )
+        except asyncio.TimeoutError:
+            process.kill()
+            raise RuntimeError(f"Git command timed out: {' '.join(cmd)}")
+        
+        return GitResult(
+            returncode=process.returncode,
+            stdout=stdout.decode("utf-8", errors="replace"),
+            stderr=stderr.decode("utf-8", errors="replace"),
+        )
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """Get action statistics."""
+        stats = super().get_stats()
+        stats.update({
+            "working_dir": str(self.working_dir),
+            "remote": self.remote,
+            "branch": self.branch or "auto",
+        })
+        return stats