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

monoco/core/scheduler/engines.py

@@ -0,0 +1,175 @@
+"""
+Agent Engine Adapters for Monoco Scheduler.
+
+This module provides a unified interface for different AI agent execution engines,
+allowing the Worker to seamlessly switch between Gemini, Claude, and future engines.
+"""
+
+from abc import ABC, abstractmethod
+from typing import List
+
+
+class EngineAdapter(ABC):
+    """
+    Abstract base class for agent engine adapters.
+
+    Each adapter is responsible for:
+    1. Constructing the correct CLI command for its engine
+    2. Handling engine-specific error scenarios
+    3. Providing metadata about the engine's capabilities
+    """
+
+    @abstractmethod
+    def build_command(self, prompt: str) -> List[str]:
+        """
+        Build the CLI command to execute the agent with the given prompt.
+
+        Args:
+            prompt: The instruction/context to send to the agent
+
+        Returns:
+            List of command arguments (e.g., ["gemini", "-y", "prompt text"])
+        """
+        pass
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Return the canonical name of this engine."""
+        pass
+
+    @property
+    def supports_yolo_mode(self) -> bool:
+        """Whether this engine supports auto-approval mode."""
+        return False
+
+
+class GeminiAdapter(EngineAdapter):
+    """
+    Adapter for Google Gemini CLI.
+
+    Command format: gemini -p <prompt> -y
+    The -y flag enables "YOLO mode" (auto-approval of actions).
+    """
+
+    def build_command(self, prompt: str) -> List[str]:
+        # Based on Gemini CLI help: -p <prompt> for non-interactive
+        return ["gemini", "-p", prompt, "-y"]
+
+    @property
+    def name(self) -> str:
+        return "gemini"
+
+    @property
+    def supports_yolo_mode(self) -> bool:
+        return True
+
+
+class ClaudeAdapter(EngineAdapter):
+    """
+    Adapter for Anthropic Claude CLI.
+
+    Command format: claude -p <prompt>
+    The -p/--print flag enables non-interactive mode.
+    """
+
+    def build_command(self, prompt: str) -> List[str]:
+        # Based on Claude CLI help: -p <prompt> is NOT standard, usually -p means print/non-interactive.
+        # But for one-shot execution, we do passing prompt as argument with -p flag.
+        return ["claude", "-p", prompt]
+
+    @property
+    def name(self) -> str:
+        return "claude"
+
+    @property
+    def supports_yolo_mode(self) -> bool:
+        # Claude uses -p for non-interactive mode, similar concept
+        return True
+
+
+class QwenAdapter(EngineAdapter):
+    """
+    Adapter for Qwen Code CLI.
+
+    Command format: qwen -p <prompt> -y
+    """
+
+    def build_command(self, prompt: str) -> List[str]:
+        # Assuming Qwen follows similar patterns (based on user feedback)
+        return ["qwen", "-p", prompt, "-y"]
+
+    @property
+    def name(self) -> str:
+        return "qwen"
+
+    @property
+    def supports_yolo_mode(self) -> bool:
+        return True
+
+
+class KimiAdapter(EngineAdapter):
+    """
+    Adapter for Kimi CLI (Moonshot AI).
+
+    Command format: kimi -p <prompt> --print
+    Note: --print implicitly adds --yolo.
+    """
+
+    def build_command(self, prompt: str) -> List[str]:
+        # Based on Kimi CLI help: -p, --prompt TEXT.
+        # Also using --print for non-interactive mode (which enables yolo).
+        return ["kimi", "-p", prompt, "--print"]
+
+    @property
+    def name(self) -> str:
+        return "kimi"
+
+    @property
+    def supports_yolo_mode(self) -> bool:
+        return True
+
+
+class EngineFactory:
+    """
+    Factory for creating engine adapter instances.
+
+    Usage:
+        adapter = EngineFactory.create("gemini")
+        command = adapter.build_command("Write a test")
+    """
+
+    _adapters = {
+        "gemini": GeminiAdapter,
+        "claude": ClaudeAdapter,
+        "qwen": QwenAdapter,
+        "kimi": KimiAdapter,
+    }
+
+    @classmethod
+    def create(cls, engine_name: str) -> EngineAdapter:
+        """
+        Create an adapter instance for the specified engine.
+
+        Args:
+            engine_name: Name of the engine (e.g., "gemini", "claude")
+
+        Returns:
+            An instance of the appropriate EngineAdapter
+
+        Raises:
+            ValueError: If the engine is not supported
+        """
+        adapter_class = cls._adapters.get(engine_name.lower())
+        if not adapter_class:
+            supported = ", ".join(cls._adapters.keys())
+            raise ValueError(
+                f"Unsupported engine: '{engine_name}'. "
+                f"Supported engines: {supported}"
+            )
+        return adapter_class()
+
+    @classmethod
+    def supported_engines(cls) -> List[str]:
+        """Return a list of all supported engine names."""
+        return list(cls._adapters.keys())

monoco/core/scheduler/events.py

@@ -0,0 +1,171 @@
+"""
+EventBus - Central event system for Agent scheduling (FEAT-0155).
+
+Provides async event publishing/subscription mechanism for decoupled
+Agent lifecycle management.
+"""
+
+import asyncio
+import inspect
+import logging
+from enum import Enum, auto
+from typing import Dict, List, Callable, Any, Optional
+from dataclasses import dataclass, field
+from datetime import datetime
+
+logger = logging.getLogger("monoco.core.scheduler.events")
+
+
+class AgentEventType(Enum):
+    """Event types for Agent lifecycle and triggers."""
+    # Memo events
+    MEMO_CREATED = "memo.created"
+    MEMO_THRESHOLD = "memo.threshold"
+    
+    # Issue events
+    ISSUE_CREATED = "issue.created"
+    ISSUE_UPDATED = "issue.updated"
+    ISSUE_STAGE_CHANGED = "issue.stage_changed"
+    ISSUE_STATUS_CHANGED = "issue.status_changed"
+    
+    # Session events
+    SESSION_STARTED = "session.started"
+    SESSION_COMPLETED = "session.completed"
+    SESSION_FAILED = "session.failed"
+    SESSION_CRASHED = "session.crashed"
+    SESSION_TERMINATED = "session.terminated"
+    
+    # PR events (for Reviewer trigger)
+    PR_CREATED = "pr.created"
+    PR_UPDATED = "pr.updated"
+
+
+@dataclass
+class AgentEvent:
+    """Event data structure."""
+    type: AgentEventType
+    payload: Dict[str, Any]
+    timestamp: datetime = None
+    source: str = None
+    
+    def __post_init__(self):
+        if self.timestamp is None:
+            self.timestamp = datetime.now()
+
+
+EventHandler = Callable[[AgentEvent], Any]
+
+
+class EventBus:
+    """
+    Central async event bus for Agent scheduling.
+    
+    Supports:
+    - Subscribe/unsubscribe handlers for specific event types
+    - Publish events to all subscribed handlers
+    - Async handler execution
+    """
+    
+    def __init__(self):
+        self._handlers: Dict[AgentEventType, List[EventHandler]] = {
+            event_type: [] for event_type in AgentEventType
+        }
+        self._lock = asyncio.Lock()
+        self._event_queue: asyncio.Queue = asyncio.Queue()
+        self._dispatch_task: Optional[asyncio.Task] = None
+        self._running = False
+    
+    async def start(self):
+        """Start the event dispatch loop."""
+        if self._running:
+            return
+        self._running = True
+        self._dispatch_task = asyncio.create_task(self._dispatch_loop())
+        logger.info("EventBus started")
+    
+    async def stop(self):
+        """Stop the event dispatch loop."""
+        if not self._running:
+            return
+        self._running = False
+        if self._dispatch_task:
+            self._dispatch_task.cancel()
+            try:
+                await self._dispatch_task
+            except asyncio.CancelledError:
+                pass
+        logger.info("EventBus stopped")
+    
+    async def _dispatch_loop(self):
+        """Background loop to dispatch events."""
+        while self._running:
+            try:
+                event = await asyncio.wait_for(self._event_queue.get(), timeout=1.0)
+                await self._dispatch_event(event)
+            except asyncio.TimeoutError:
+                continue
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                logger.error(f"Error dispatching event: {e}")
+    
+    async def _dispatch_event(self, event: AgentEvent):
+        """Dispatch event to all subscribed handlers."""
+        handlers = self._handlers.get(event.type, [])
+        if not handlers:
+            logger.debug(f"No handlers for event {event.type.value}")
+            return
+        
+        logger.debug(f"Dispatching {event.type.value} to {len(handlers)} handlers")
+        
+        # Execute handlers concurrently
+        tasks = []
+        for handler in handlers:
+            try:
+                if inspect.iscoroutinefunction(handler):
+                    tasks.append(asyncio.create_task(handler(event)))
+                else:
+                    handler(event)
+            except Exception as e:
+                logger.error(f"Handler error for {event.type.value}: {e}")
+        
+        if tasks:
+            await asyncio.gather(*tasks, return_exceptions=True)
+    
+    def subscribe(self, event_type: AgentEventType, handler: EventHandler):
+        """Subscribe a handler to an event type."""
+        if handler not in self._handlers[event_type]:
+            self._handlers[event_type].append(handler)
+            logger.debug(f"Handler subscribed to {event_type.value}")
+    
+    def unsubscribe(self, event_type: AgentEventType, handler: EventHandler):
+        """Unsubscribe a handler from an event type."""
+        if handler in self._handlers[event_type]:
+            self._handlers[event_type].remove(handler)
+            logger.debug(f"Handler unsubscribed from {event_type.value}")
+    
+    async def publish(self, event_type: AgentEventType, payload: Dict[str, Any], source: str = None):
+        """Publish an event to the bus."""
+        event = AgentEvent(type=event_type, payload=payload, source=source)
+        await self._event_queue.put(event)
+        logger.debug(f"Published event {event_type.value}")
+    
+    def get_subscriber_count(self, event_type: AgentEventType) -> int:
+        """Get number of subscribers for an event type."""
+        return len(self._handlers.get(event_type, []))
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """Get event bus statistics."""
+        return {
+            "running": self._running,
+            "queue_size": self._event_queue.qsize(),
+            "subscribers": {
+                event_type.value: len(handlers)
+                for event_type, handlers in self._handlers.items()
+                if handlers
+            }
+        }
+
+
+# Global event bus instance
+event_bus = EventBus()