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

monoco/core/executor/im_action.py

@@ -0,0 +1,309 @@
+"""
+SendIMAction - Action for sending notifications.
+
+Part of Layer 3 (Action Executor) in the event automation framework.
+Provides action for sending IM/webhook notifications.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+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 NotificationResult:
+    """Result of a notification send."""
+    
+    def __init__(
+        self,
+        success: bool,
+        message: str,
+        response: Optional[Any] = None,
+    ):
+        self.success = success
+        self.message = message
+        self.response = response
+
+
+class SendIMAction(Action):
+    """
+    Action that sends notifications via IM or webhook.
+    
+    This action sends notifications to various channels:
+    - Webhook (HTTP POST)
+    - Console (stdout)
+    - File (append to log file)
+    
+    Future: Slack, Discord, Email, etc.
+    
+    Example:
+        >>> action = SendIMAction(
+        ...     channel="webhook",
+        ...     webhook_url="https://hooks.example.com/notify",
+        ...     message_template="Issue {issue_id} updated to {new_stage}",
+        ... )
+        >>> result = await action(event)
+    """
+    
+    def __init__(
+        self,
+        channel: str = "console",
+        message_template: str = "{event_type}: {payload}",
+        webhook_url: Optional[str] = None,
+        webhook_headers: Optional[Dict[str, str]] = None,
+        log_file: Optional[str] = None,
+        timeout: int = 30,
+        config: Optional[Dict[str, Any]] = None,
+    ):
+        super().__init__(config)
+        self.channel = channel
+        self.message_template = message_template
+        self.webhook_url = webhook_url
+        self.webhook_headers = webhook_headers or {}
+        self.log_file = log_file
+        self.timeout = timeout
+        self._last_result: Optional[NotificationResult] = None
+    
+    @property
+    def name(self) -> str:
+        return f"SendIMAction({self.channel})"
+    
+    async def can_execute(self, event: AgentEvent) -> bool:
+        """Check if the channel is available."""
+        if self.channel == "webhook":
+            return self.webhook_url is not None
+        elif self.channel == "file":
+            return self.log_file is not None
+        elif self.channel == "console":
+            return True
+        return False
+    
+    async def execute(self, event: AgentEvent) -> ActionResult:
+        """Send notification."""
+        # Format message
+        message = self._format_message(event)
+        
+        logger.debug(f"Sending {self.channel} notification: {message[:100]}...")
+        
+        try:
+            if self.channel == "webhook":
+                result = await self._send_webhook(message, event)
+            elif self.channel == "file":
+                result = await self._write_to_file(message)
+            else:  # console
+                result = await self._send_console(message)
+            
+            self._last_result = result
+            
+            if result.success:
+                return ActionResult.success_result(
+                    output={
+                        "channel": self.channel,
+                        "message_sent": True,
+                    },
+                    metadata={
+                        "message_preview": message[:200],
+                    },
+                )
+            else:
+                return ActionResult.failure_result(
+                    error=result.message,
+                    metadata={
+                        "channel": self.channel,
+                    },
+                )
+        
+        except Exception as e:
+            logger.error(f"Failed to send notification: {e}")
+            return ActionResult.failure_result(error=str(e))
+    
+    def _format_message(self, event: AgentEvent) -> str:
+        """Format notification message with event data."""
+        try:
+            return self.message_template.format(
+                event_type=event.type.value,
+                timestamp=event.timestamp.isoformat(),
+                source=event.source or "unknown",
+                **event.payload,
+            )
+        except (KeyError, ValueError) as e:
+            # If formatting fails, return a simple message
+            return f"Event: {event.type.value} at {event.timestamp.isoformat()}"
+    
+    async def _send_webhook(
+        self,
+        message: str,
+        event: AgentEvent,
+    ) -> NotificationResult:
+        """Send notification via webhook."""
+        try:
+            import aiohttp
+        except ImportError:
+            # Fallback to sync requests
+            return await self._send_webhook_sync(message, event)
+        
+        payload = {
+            "message": message,
+            "event_type": event.type.value,
+            "timestamp": event.timestamp.isoformat(),
+            "source": event.source,
+            "payload": event.payload,
+        }
+        
+        headers = {
+            "Content-Type": "application/json",
+            **self.webhook_headers,
+        }
+        
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.post(
+                    self.webhook_url,
+                    json=payload,
+                    headers=headers,
+                    timeout=aiohttp.ClientTimeout(total=self.timeout),
+                ) as response:
+                    if response.status < 400:
+                        return NotificationResult(
+                            success=True,
+                            message=f"Webhook sent: HTTP {response.status}",
+                            response={
+                                "status": response.status,
+                                "body": await response.text(),
+                            },
+                        )
+                    else:
+                        return NotificationResult(
+                            success=False,
+                            message=f"Webhook failed: HTTP {response.status}",
+                            response={"status": response.status},
+                        )
+        except Exception as e:
+            return NotificationResult(
+                success=False,
+                message=f"Webhook error: {str(e)}",
+            )
+    
+    async def _send_webhook_sync(
+        self,
+        message: str,
+        event: AgentEvent,
+    ) -> NotificationResult:
+        """Send webhook using sync requests (fallback)."""
+        try:
+            import requests
+        except ImportError:
+            return NotificationResult(
+                success=False,
+                message="Neither aiohttp nor requests available for webhook",
+            )
+        
+        payload = {
+            "message": message,
+            "event_type": event.type.value,
+            "timestamp": event.timestamp.isoformat(),
+            "source": event.source,
+            "payload": event.payload,
+        }
+        
+        headers = {
+            "Content-Type": "application/json",
+            **self.webhook_headers,
+        }
+        
+        try:
+            response = requests.post(
+                self.webhook_url,
+                json=payload,
+                headers=headers,
+                timeout=self.timeout,
+            )
+            
+            if response.status_code < 400:
+                return NotificationResult(
+                    success=True,
+                    message=f"Webhook sent: HTTP {response.status_code}",
+                    response={
+                        "status": response.status_code,
+                        "body": response.text,
+                    },
+                )
+            else:
+                return NotificationResult(
+                    success=False,
+                    message=f"Webhook failed: HTTP {response.status_code}",
+                )
+        except Exception as e:
+            return NotificationResult(
+                success=False,
+                message=f"Webhook error: {str(e)}",
+            )
+    
+    async def _write_to_file(self, message: str) -> NotificationResult:
+        """Write notification to log file."""
+        try:
+            import aiofiles
+        except ImportError:
+            # Fallback to sync file write
+            return await self._write_to_file_sync(message)
+        
+        try:
+            timestamp = asyncio.get_event_loop().time()
+            log_line = f"[{timestamp}] {message}\n"
+            
+            async with aiofiles.open(self.log_file, "a") as f:
+                await f.write(log_line)
+            
+            return NotificationResult(
+                success=True,
+                message=f"Written to {self.log_file}",
+            )
+        except Exception as e:
+            return NotificationResult(
+                success=False,
+                message=f"File write error: {str(e)}",
+            )
+    
+    async def _write_to_file_sync(self, message: str) -> NotificationResult:
+        """Write to file synchronously (fallback)."""
+        try:
+            import time
+            log_line = f"[{time.time()}] {message}\n"
+            
+            with open(self.log_file, "a") as f:
+                f.write(log_line)
+            
+            return NotificationResult(
+                success=True,
+                message=f"Written to {self.log_file}",
+            )
+        except Exception as e:
+            return NotificationResult(
+                success=False,
+                message=f"File write error: {str(e)}",
+            )
+    
+    async def _send_console(self, message: str) -> NotificationResult:
+        """Print notification to console."""
+        print(f"[NOTIFICATION] {message}")
+        return NotificationResult(
+            success=True,
+            message="Printed to console",
+        )
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """Get action statistics."""
+        stats = super().get_stats()
+        stats.update({
+            "channel": self.channel,
+            "webhook_configured": self.webhook_url is not None,
+            "log_file": self.log_file,
+        })
+        return stats

monoco/core/executor/pytest_action.py

@@ -0,0 +1,218 @@
+"""
+RunPytestAction - Action for running pytest tests.
+
+Part of Layer 3 (Action Executor) in the event automation framework.
+Executes pytest and parses results.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import subprocess
+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 PytestResult:
+    """Result of a pytest execution."""
+    
+    def __init__(
+        self,
+        returncode: int,
+        stdout: str,
+        stderr: str,
+        summary: Optional[Dict[str, Any]] = None,
+    ):
+        self.returncode = returncode
+        self.stdout = stdout
+        self.stderr = stderr
+        self.summary = summary or {}
+    
+    @property
+    def passed(self) -> bool:
+        return self.returncode == 0
+    
+    @property
+    def failed_count(self) -> int:
+        return self.summary.get("failed", 0)
+    
+    @property
+    def passed_count(self) -> int:
+        return self.summary.get("passed", 0)
+    
+    @property
+    def total_count(self) -> int:
+        return self.summary.get("total", 0)
+
+
+class RunPytestAction(Action):
+    """
+    Action that runs pytest tests.
+    
+    This action executes pytest with configurable options and
+    parses the results for downstream processing.
+    
+    Example:
+        >>> action = RunPytestAction(
+        ...     test_path="tests/",
+        ...     markers=["unit"],
+        ...     cov=True,
+        ... )
+        >>> result = await action(event)
+    """
+    
+    def __init__(
+        self,
+        test_path: Optional[str] = None,
+        markers: Optional[List[str]] = None,
+        cov: bool = False,
+        cov_report: Optional[str] = None,
+        verbose: bool = True,
+        timeout: int = 300,
+        config: Optional[Dict[str, Any]] = None,
+    ):
+        super().__init__(config)
+        self.test_path = test_path or "."
+        self.markers = markers or []
+        self.cov = cov
+        self.cov_report = cov_report
+        self.verbose = verbose
+        self.timeout = timeout
+        self._last_result: Optional[PytestResult] = None
+    
+    @property
+    def name(self) -> str:
+        return "RunPytestAction"
+    
+    async def can_execute(self, event: AgentEvent) -> bool:
+        """Always can execute (no preconditions)."""
+        return True
+    
+    async def execute(self, event: AgentEvent) -> ActionResult:
+        """Run pytest tests."""
+        logger.info(f"Running pytest for {self.test_path}")
+        
+        try:
+            result = await self._run_pytest()
+            self._last_result = result
+            
+            if result.passed:
+                return ActionResult.success_result(
+                    output={
+                        "passed": result.passed_count,
+                        "failed": result.failed_count,
+                        "total": result.total_count,
+                    },
+                    metadata={
+                        "stdout_preview": result.stdout[:500] if result.stdout else None,
+                    },
+                )
+            else:
+                return ActionResult.failure_result(
+                    error=f"Tests failed: {result.failed_count} failures",
+                    metadata={
+                        "passed": result.passed_count,
+                        "failed": result.failed_count,
+                        "total": result.total_count,
+                        "stderr_preview": result.stderr[:500] if result.stderr else None,
+                    },
+                )
+        
+        except Exception as e:
+            logger.error(f"Pytest execution failed: {e}")
+            return ActionResult.failure_result(error=str(e))
+    
+    async def _run_pytest(self) -> PytestResult:
+        """Execute pytest subprocess."""
+        cmd = ["python", "-m", "pytest"]
+        
+        # Add test path
+        cmd.append(self.test_path)
+        
+        # Add markers
+        if self.markers:
+            marker_expr = " and ".join(self.markers)
+            cmd.extend(["-m", marker_expr])
+        
+        # Add coverage
+        if self.cov:
+            cmd.append("--cov")
+            if self.cov_report:
+                cmd.extend(["--cov-report", self.cov_report])
+        
+        # Add verbosity
+        if self.verbose:
+            cmd.append("-v")
+        
+        # Add JSON report for parsing
+        cmd.extend(["--tb=short", "-q"])
+        
+        logger.debug(f"Running command: {' '.join(cmd)}")
+        
+        # Run subprocess
+        process = await asyncio.create_subprocess_exec(
+            *cmd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        
+        try:
+            stdout, stderr = await asyncio.wait_for(
+                process.communicate(),
+                timeout=self.timeout,
+            )
+        except asyncio.TimeoutError:
+            process.kill()
+            raise RuntimeError(f"Pytest timed out after {self.timeout}s")
+        
+        stdout_str = stdout.decode("utf-8", errors="replace")
+        stderr_str = stderr.decode("utf-8", errors="replace")
+        
+        # Parse summary
+        summary = self._parse_summary(stdout_str)
+        
+        return PytestResult(
+            returncode=process.returncode,
+            stdout=stdout_str,
+            stderr=stderr_str,
+            summary=summary,
+        )
+    
+    def _parse_summary(self, output: str) -> Dict[str, int]:
+        """Parse pytest summary from output."""
+        summary = {"passed": 0, "failed": 0, "error": 0, "skipped": 0, "total": 0}
+        
+        # Look for summary line like "5 passed, 2 failed in 0.5s"
+        import re
+        pattern = r"(\d+)\s+(passed|failed|error|skipped)"
+        matches = re.findall(pattern, output)
+        
+        for count, status in matches:
+            summary[status] = int(count)
+            summary["total"] += int(count)
+        
+        return summary
+    
+    def get_last_result(self) -> Optional[PytestResult]:
+        """Get the last pytest result."""
+        return self._last_result
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """Get action statistics."""
+        stats = super().get_stats()
+        stats.update({
+            "test_path": self.test_path,
+            "markers": self.markers,
+            "last_result": {
+                "passed": self._last_result.passed if self._last_result else None,
+                "failed": self._last_result.failed_count if self._last_result else None,
+            } if self._last_result else None,
+        })
+        return stats

monoco/core/git.py

@@ -149,6 +149,29 @@ def delete_branch(path: Path, branch_name: str, force: bool = False):
         raise RuntimeError(f"Failed to delete branch {branch_name}: {stderr}")
 
 
+def get_merge_base(path: Path, ref1: str, ref2: str) -> str:
+    code, stdout, stderr = _run_git(["merge-base", ref1, ref2], path)
+    if code != 0:
+        raise RuntimeError(f"Failed to find merge base: {stderr}")
+    return stdout.strip()
+
+
+def git_checkout_files(path: Path, ref: str, files: List[str]):
+    if not files:
+        return
+    code, _, stderr = _run_git(["checkout", ref, "--"] + files, path)
+    if code != 0:
+        raise RuntimeError(f"Failed to checkout files from {ref}: {stderr}")
+
+
+def has_diff(path: Path, ref1: str, ref2: str, files: List[str]) -> bool:
+    """Check if there are differences between two refs for specific files."""
+    if not files:
+        return False
+    code, stdout, _ = _run_git(["diff", "--name-only", ref1, ref2, "--"] + files, path)
+    return code == 0 and bool(stdout.strip())
+
+
 def get_worktrees(path: Path) -> List[Tuple[str, str, str]]:
     """Returns list of (path, head, branch)"""
     code, stdout, stderr = _run_git(["worktree", "list", "--porcelain"], path)
@@ -207,6 +230,21 @@ def worktree_remove(path: Path, worktree_path: Path, force: bool = False):
         raise RuntimeError(f"Failed to remove worktree: {stderr}")
 
 
+def get_current_head(path: Path) -> str:
+    """Get the current HEAD commit hash."""
+    code, stdout, stderr = _run_git(["rev-parse", "HEAD"], path)
+    if code != 0:
+        raise RuntimeError(f"Failed to get current HEAD: {stderr}")
+    return stdout.strip()
+
+
+def git_reset_hard(path: Path, ref: str):
+    """Reset the repository to a specific ref using --hard."""
+    code, _, stderr = _run_git(["reset", "--hard", ref], path)
+    if code != 0:
+        raise RuntimeError(f"Git reset --hard to {ref} failed: {stderr}")
+
+
 class GitMonitor:
     """
     Polls the Git repository for HEAD changes and triggers updates.

monoco/core/hooks/context.py

@@ -74,29 +74,90 @@ class HookContext:
     extra: Dict[str, Any] = field(default_factory=dict)
     
     @classmethod
-    def from_runtime_session(
+    def from_agent_task(
         cls,
-        runtime_session: Any,
+        task: Any,
         project_root: Optional[Path] = None,
     ) -> "HookContext":
         """
-        Create a HookContext from a RuntimeSession.
+        Create a HookContext from an AgentTask.
         
         Args:
-            runtime_session: The RuntimeSession object
+            task: The AgentTask object
             project_root: Optional project root path
             
         Returns:
             A populated HookContext
         """
-        model = runtime_session.model
+        # Build IssueInfo if we have an issue_id
+        issue_info = None
+        issue_id = getattr(task, "issue_id", None)
+        if issue_id:
+            issue_info = IssueInfo(
+                id=issue_id,
+            )
+            
+            # Try to load full issue metadata
+            try:
+                from monoco.features.issue.core import find_issue_path, parse_issue
+                from monoco.core.config import find_monoco_root
+                
+                if project_root is None:
+                    project_root = find_monoco_root()
+                
+                issues_root = project_root / "Issues"
+                issue_path = find_issue_path(issues_root, issue_id)
+                if issue_path:
+                    metadata = parse_issue(issue_path)
+                    if metadata:
+                        issue_info = IssueInfo.from_metadata(metadata)
+            except Exception:
+                pass  # Use basic issue info
         
+        # Build GitInfo
+        git_info = None
+        if project_root:
+            git_info = GitInfo(project_root=project_root)
+        
+        return cls(
+            session_id=getattr(task, "task_id", "unknown"),
+            role_name=getattr(task, "role_name", "unknown"),
+            session_status="pending",
+            created_at=getattr(task, "created_at", datetime.now()),
+            issue=issue_info,
+            git=git_info,
+        )
+    
+    @classmethod
+    def from_session_state(
+        cls,
+        session_id: str,
+        role_name: str,
+        issue_id: Optional[str],
+        status: str,
+        project_root: Optional[Path] = None,
+    ) -> "HookContext":
+        """
+        Create a HookContext from session state parameters.
+        
+        This is a more flexible factory method that doesn't depend on
+        specific session implementations.
+        
+        Args:
+            session_id: The session/task ID
+            role_name: The role name
+            issue_id: Optional issue ID
+            status: Session status
+            project_root: Optional project root path
+            
+        Returns:
+            A populated HookContext
+        """
         # Build IssueInfo if we have an issue_id
         issue_info = None
-        if model.issue_id:
+        if issue_id:
             issue_info = IssueInfo(
-                id=model.issue_id,
-                branch_name=model.branch_name,
+                id=issue_id,
             )
             
             # Try to load full issue metadata
@@ -108,7 +169,7 @@ class HookContext:
                     project_root = find_monoco_root()
                 
                 issues_root = project_root / "Issues"
-                issue_path = find_issue_path(issues_root, model.issue_id)
+                issue_path = find_issue_path(issues_root, issue_id)
                 if issue_path:
                     metadata = parse_issue(issue_path)
                     if metadata:
@@ -122,10 +183,10 @@ class HookContext:
             git_info = GitInfo(project_root=project_root)
         
         return cls(
-            session_id=model.id,
-            role_name=model.role_name,
-            session_status=model.status,
-            created_at=model.created_at,
+            session_id=session_id,
+            role_name=role_name,
+            session_status=status,
+            created_at=datetime.now(),
             issue=issue_info,
             git=git_info,
         )