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

monoco/core/scheduler/events.py

@@ -0,0 +1,197 @@
+"""
+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, Union
+from dataclasses import dataclass, field
+from datetime import datetime
+
+
+def _is_async_handler(handler: Callable) -> bool:
+    """
+    Check if a handler is async (coroutine function or has async __call__).
+    
+    Handles both:
+    - Regular async functions: async def func(): ...
+    - Callable objects with async __call__: class Handler: async def __call__(self, ...): ...
+    """
+    # Direct check for coroutine function
+    if inspect.iscoroutinefunction(handler):
+        return True
+    # Check for callable object with async __call__ method
+    if hasattr(handler, "__call__") and inspect.iscoroutinefunction(handler.__call__):
+        return True
+    return False
+
+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"
+    
+    # IM events (FEAT-0167)
+    IM_MESSAGE_RECEIVED = "im.message.received"
+    IM_MESSAGE_REPLIED = "im.message.replied"
+    IM_AGENT_TRIGGER = "im.agent.trigger"
+    IM_SESSION_STARTED = "im.session.started"
+    IM_SESSION_CLOSED = "im.session.closed"
+    IM_CHANNEL_CREATED = "im.channel.created"
+    IM_CHANNEL_UPDATED = "im.channel.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 _is_async_handler(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()

monoco/core/scheduler/local.py

@@ -0,0 +1,377 @@
+"""
+LocalProcessScheduler - Local process-based agent scheduler.
+
+Implements the AgentScheduler ABC using local subprocess execution.
+Integrates with SessionManager and Worker for process lifecycle management.
+"""
+
+import asyncio
+import logging
+import subprocess
+import sys
+import time
+import uuid
+from pathlib import Path
+from typing import Dict, Optional, Any
+
+from .base import AgentScheduler, AgentTask, AgentStatus
+from .engines import EngineFactory
+from .events import AgentEventType, event_bus
+
+logger = logging.getLogger("monoco.core.scheduler.local")
+
+
+class LocalProcessScheduler(AgentScheduler):
+    """
+    Local process-based scheduler for agent execution.
+    
+    This scheduler manages agent tasks as local subprocesses, providing:
+    - Process lifecycle management (spawn, monitor, terminate)
+    - Concurrency quota control via semaphore
+    - Timeout handling
+    - Session tracking and status reporting
+    
+    Attributes:
+        max_concurrent: Maximum number of concurrent agent processes
+        project_root: Root path of the Monoco project
+    
+    Example:
+        >>> scheduler = LocalProcessScheduler(max_concurrent=5)
+        >>> session_id = await scheduler.schedule(task)
+        >>> status = scheduler.get_status(session_id)
+    """
+    
+    def __init__(
+        self,
+        max_concurrent: int = 5,
+        project_root: Optional[Path] = None,
+    ):
+        self.max_concurrent = max_concurrent
+        self.project_root = project_root or Path.cwd()
+        
+        # Session tracking: session_id -> process info
+        self._sessions: Dict[str, Dict[str, Any]] = {}
+        
+        # Concurrency control
+        self._semaphore = asyncio.Semaphore(max_concurrent)
+        
+        # Background monitoring task
+        self._monitor_task: Optional[asyncio.Task] = None
+        self._running = False
+    
+    async def start(self):
+        """Start the scheduler and monitoring loop."""
+        if self._running:
+            return
+        self._running = True
+        self._monitor_task = asyncio.create_task(self._monitor_loop())
+        logger.info(f"LocalProcessScheduler started (max_concurrent={self.max_concurrent})")
+    
+    async def stop(self):
+        """Stop the scheduler and terminate all sessions."""
+        if not self._running:
+            return
+        self._running = False
+        
+        # Cancel monitor loop
+        if self._monitor_task:
+            self._monitor_task.cancel()
+            try:
+                await self._monitor_task
+            except asyncio.CancelledError:
+                pass
+        
+        # Terminate all active sessions
+        for session_id in list(self._sessions.keys()):
+            await self.terminate(session_id)
+        
+        logger.info("LocalProcessScheduler stopped")
+    
+    async def schedule(self, task: AgentTask) -> str:
+        """
+        Schedule a task for execution as a local subprocess.
+        
+        Args:
+            task: The task to schedule
+            
+        Returns:
+            session_id: Unique identifier for the scheduled session
+            
+        Raises:
+            RuntimeError: If scheduling fails or engine is not supported
+        """
+        session_id = str(uuid.uuid4())
+        
+        # Acquire semaphore slot
+        acquired = await self._semaphore.acquire()
+        if not acquired:
+            # This shouldn't happen with asyncio.Semaphore, but just in case
+            raise RuntimeError("Failed to acquire concurrency slot")
+        
+        try:
+            # Get engine adapter
+            adapter = EngineFactory.create(task.engine)
+            command = adapter.build_command(task.prompt)
+            
+            logger.info(f"[{session_id}] Starting {task.role_name} with {task.engine} engine")
+            
+            # Start subprocess
+            process = subprocess.Popen(
+                command,
+                stdout=sys.stdout,
+                stderr=sys.stderr,
+                text=True,
+                cwd=self.project_root,
+            )
+            
+            # Track session
+            self._sessions[session_id] = {
+                "task": task,
+                "process": process,
+                "status": AgentStatus.RUNNING,
+                "started_at": time.time(),
+                "role_name": task.role_name,
+                "issue_id": task.issue_id,
+            }
+            
+            # Publish session started event
+            await event_bus.publish(
+                AgentEventType.SESSION_STARTED,
+                {
+                    "session_id": session_id,
+                    "issue_id": task.issue_id,
+                    "role_name": task.role_name,
+                    "engine": task.engine,
+                },
+                source="LocalProcessScheduler"
+            )
+            
+            return session_id
+            
+        except Exception as e:
+            # Release semaphore on failure
+            self._semaphore.release()
+            logger.error(f"[{session_id}] Failed to start task: {e}")
+            raise RuntimeError(f"Failed to schedule task: {e}")
+    
+    async def terminate(self, session_id: str) -> bool:
+        """
+        Terminate a running or pending session.
+        
+        Args:
+            session_id: The session ID to terminate
+            
+        Returns:
+            True if termination was successful, False otherwise
+        """
+        session = self._sessions.get(session_id)
+        if not session:
+            logger.warning(f"[{session_id}] Session not found for termination")
+            return False
+        
+        process = session.get("process")
+        if not process:
+            return False
+        
+        try:
+            # Try graceful termination
+            process.terminate()
+            
+            # Wait a bit for graceful shutdown
+            try:
+                process.wait(timeout=2)
+            except subprocess.TimeoutExpired:
+                # Force kill if still running
+                process.kill()
+                process.wait()
+            
+            session["status"] = AgentStatus.TERMINATED
+            
+            # Publish session terminated event
+            await event_bus.publish(
+                AgentEventType.SESSION_TERMINATED,
+                {
+                    "session_id": session_id,
+                    "issue_id": session.get("issue_id"),
+                    "role_name": session.get("role_name"),
+                },
+                source="LocalProcessScheduler"
+            )
+            
+            # Release semaphore
+            self._semaphore.release()
+            
+            logger.info(f"[{session_id}] Session terminated")
+            return True
+            
+        except Exception as e:
+            logger.error(f"[{session_id}] Error terminating session: {e}")
+            return False
+    
+    def get_status(self, session_id: str) -> Optional[AgentStatus]:
+        """
+        Get the current status of a session.
+        
+        Args:
+            session_id: The session ID to query
+            
+        Returns:
+            The current AgentStatus, or None if session not found
+        """
+        session = self._sessions.get(session_id)
+        if not session:
+            return None
+        return session.get("status")
+    
+    def list_active(self) -> Dict[str, AgentStatus]:
+        """
+        List all active (pending or running) sessions.
+        
+        Returns:
+            Dictionary mapping session_id to AgentStatus
+        """
+        return {
+            session_id: session["status"]
+            for session_id, session in self._sessions.items()
+            if session["status"] in (AgentStatus.PENDING, AgentStatus.RUNNING)
+        }
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """
+        Get scheduler statistics.
+        
+        Returns:
+            Dictionary containing scheduler metrics
+        """
+        active_count = len(self.list_active())
+        total_count = len(self._sessions)
+        
+        return {
+            "running": self._running,
+            "max_concurrent": self.max_concurrent,
+            "active_sessions": active_count,
+            "total_sessions": total_count,
+            "available_slots": self.max_concurrent - active_count,
+        }
+    
+    async def _monitor_loop(self):
+        """Background loop to monitor session statuses."""
+        logger.info("Starting session monitor loop")
+        
+        while self._running:
+            try:
+                await self._check_sessions()
+                await asyncio.sleep(2)  # Check every 2 seconds
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                logger.error(f"Error in monitor loop: {e}")
+                await asyncio.sleep(2)
+    
+    async def _check_sessions(self):
+        """Check all sessions and update statuses."""
+        for session_id, session in list(self._sessions.items()):
+            process = session.get("process")
+            if not process:
+                continue
+            
+            current_status = session["status"]
+            
+            # Skip if already in terminal state
+            if current_status in (
+                AgentStatus.COMPLETED,
+                AgentStatus.FAILED,
+                AgentStatus.TERMINATED,
+                AgentStatus.TIMEOUT,
+            ):
+                continue
+            
+            # Check timeout
+            task = session.get("task")
+            started_at = session.get("started_at", 0)
+            if task and task.timeout and (time.time() - started_at) > task.timeout:
+                logger.warning(f"[{session_id}] Task timeout exceeded ({task.timeout}s)")
+                await self._handle_timeout(session_id, session)
+                continue
+            
+            # Check process status
+            returncode = process.poll()
+            if returncode is None:
+                # Still running
+                continue
+            
+            # Process finished
+            if returncode == 0:
+                await self._handle_completion(session_id, session)
+            else:
+                await self._handle_failure(session_id, session, returncode)
+    
+    async def _handle_completion(self, session_id: str, session: Dict[str, Any]):
+        """Handle successful session completion."""
+        session["status"] = AgentStatus.COMPLETED
+        
+        # Publish completion event
+        await event_bus.publish(
+            AgentEventType.SESSION_COMPLETED,
+            {
+                "session_id": session_id,
+                "issue_id": session.get("issue_id"),
+                "role_name": session.get("role_name"),
+            },
+            source="LocalProcessScheduler"
+        )
+        
+        # Release semaphore
+        self._semaphore.release()
+        
+        logger.info(f"[{session_id}] Session completed successfully")
+    
+    async def _handle_failure(self, session_id: str, session: Dict[str, Any], returncode: int):
+        """Handle session failure."""
+        session["status"] = AgentStatus.FAILED
+        
+        # Publish failure event
+        await event_bus.publish(
+            AgentEventType.SESSION_FAILED,
+            {
+                "session_id": session_id,
+                "issue_id": session.get("issue_id"),
+                "role_name": session.get("role_name"),
+                "reason": f"Process exited with code {returncode}",
+            },
+            source="LocalProcessScheduler"
+        )
+        
+        # Release semaphore
+        self._semaphore.release()
+        
+        logger.error(f"[{session_id}] Session failed with exit code {returncode}")
+    
+    async def _handle_timeout(self, session_id: str, session: Dict[str, Any]):
+        """Handle session timeout."""
+        process = session.get("process")
+        
+        # Kill the process
+        if process:
+            try:
+                process.kill()
+                process.wait()
+            except Exception as e:
+                logger.error(f"[{session_id}] Error killing timed out process: {e}")
+        
+        session["status"] = AgentStatus.TIMEOUT
+        
+        # Publish failure event (timeout is a type of failure)
+        await event_bus.publish(
+            AgentEventType.SESSION_FAILED,
+            {
+                "session_id": session_id,
+                "issue_id": session.get("issue_id"),
+                "role_name": session.get("role_name"),
+                "reason": "Timeout exceeded",
+            },
+            source="LocalProcessScheduler"
+        )
+        
+        # Release semaphore
+        self._semaphore.release()

monoco/core/setup.py

@@ -211,6 +211,8 @@ def init_cli(
     project_config_path = project_config_dir / "project.yaml"
 
     project_initialized = False
+    workspace_config = {}
+    project_key = "MON"
 
     # Check if we should init project
     if workspace_config_path.exists() or project_config_path.exists():
@@ -323,6 +325,13 @@ def init_cli(
     try:
         from monoco.core.githooks import install_hooks
 
+        # Check if git initialized, if not, do it
+        if not (cwd / ".git").exists():
+            console.print("[dim]Git repository not found. Initializing...[/dim]")
+            # Set global default branch to main
+            subprocess.run(["git", "config", "--global", "init.defaultBranch", "main"], check=False)
+            subprocess.run(["git", "init"], cwd=cwd, check=False)
+
         # Re-load config to get the just-written hooks (or default ones)
         # Actually we have the dict right here in workspace_config['hooks']
         hooks_config = workspace_config.get("hooks", {})