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

monoco/core/executor/git_action.py

@@ -1,303 +0,0 @@
-"""
-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

monoco/core/executor/im_action.py

@@ -1,309 +0,0 @@
-"""
-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