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

monoco/core/watcher/task.py

@@ -0,0 +1,238 @@
+"""
+TaskWatcher - Monitors task files for changes.
+
+Part of Layer 1 (File Watcher) in the event automation framework.
+Emits events for task status changes and completion.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Set
+
+from monoco.core.scheduler import AgentEventType, EventBus, event_bus
+
+from .base import (
+    ChangeType,
+    FieldChange,
+    FileEvent,
+    FilesystemWatcher,
+    WatchConfig,
+    PollingWatcher,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class TaskFileEvent(FileEvent):
+    """FileEvent specific to Task files."""
+    
+    def __init__(
+        self,
+        path: Path,
+        change_type: ChangeType,
+        task_changes: Optional[List[Dict[str, Any]]] = None,
+        **kwargs,
+    ):
+        super().__init__(
+            path=path,
+            change_type=change_type,
+            watcher_name="TaskWatcher",
+            **kwargs,
+        )
+        self.task_changes = task_changes or []
+    
+    def to_agent_event_type(self) -> Optional[AgentEventType]:
+        """Tasks map to issue updates for now."""
+        return AgentEventType.ISSUE_UPDATED
+    
+    def to_payload(self) -> Dict[str, Any]:
+        """Convert to payload with Task-specific fields."""
+        payload = super().to_payload()
+        payload["task_changes"] = self.task_changes
+        return payload
+
+
+@dataclass
+class TaskItem:
+    """Represents a single task item."""
+    content: str
+    state: str  # " ", "x", "X", "-", "/"
+    line_number: int
+    level: int = 0
+    
+    @property
+    def is_completed(self) -> bool:
+        return self.state.lower() == "x"
+    
+    @property
+    def is_in_progress(self) -> bool:
+        return self.state in ("-", "/")
+
+
+class TaskWatcher(PollingWatcher):
+    """
+    Watcher for task files.
+    
+    Monitors task files (e.g., tasks.md, TODO.md) for:
+    - Task creation
+    - Task status changes (todo -> doing -> done)
+    - Task completion
+    
+    Example:
+        >>> config = WatchConfig(
+        ...     path=Path("./tasks.md"),
+        ...     patterns=["*.md"],
+        ... )
+        >>> watcher = TaskWatcher(config)
+        >>> await watcher.start()
+    """
+    
+    # Regex to match task items
+    TASK_PATTERN = re.compile(
+        r"^(\s*)-\s*\[([ xX\-/])\]\s*(.+)$",
+        re.MULTILINE,
+    )
+    
+    def __init__(
+        self,
+        config: WatchConfig,
+        event_bus: Optional[EventBus] = None,
+        name: str = "TaskWatcher",
+    ):
+        super().__init__(config, event_bus, name)
+        self._task_cache: Dict[str, TaskItem] = {}  # task_id -> TaskItem
+    
+    async def _check_changes(self) -> None:
+        """Check for task file changes."""
+        if not self.config.path.exists():
+            return
+        
+        try:
+            content = self._read_file_content(self.config.path) or ""
+            current_tasks = self._parse_tasks(content)
+            
+            # Detect changes
+            task_changes = self._detect_task_changes(current_tasks)
+            
+            if task_changes:
+                await self._emit_task_changes(task_changes)
+            
+            # Update cache
+            self._task_cache = current_tasks
+        
+        except Exception as e:
+            logger.error(f"Error checking task file: {e}")
+    
+    def _parse_tasks(self, content: str) -> Dict[str, TaskItem]:
+        """Parse task items from content."""
+        tasks = {}
+        lines = content.split("\n")
+        
+        for line_num, line in enumerate(lines, 1):
+            match = self.TASK_PATTERN.match(line)
+            if match:
+                indent = match.group(1)
+                state = match.group(2)
+                task_content = match.group(3).strip()
+                
+                # Generate task ID from content hash
+                import hashlib
+                task_id = hashlib.md5(
+                    f"{line_num}:{task_content}".encode()
+                ).hexdigest()[:12]
+                
+                tasks[task_id] = TaskItem(
+                    content=task_content,
+                    state=state,
+                    line_number=line_num,
+                    level=len(indent) // 2,
+                )
+        
+        return tasks
+    
+    def _detect_task_changes(
+        self,
+        current_tasks: Dict[str, TaskItem],
+    ) -> List[Dict[str, Any]]:
+        """Detect changes between cached and current tasks."""
+        changes = []
+        current_ids = set(current_tasks.keys())
+        cached_ids = set(self._task_cache.keys())
+        
+        # New tasks
+        for task_id in current_ids - cached_ids:
+            task = current_tasks[task_id]
+            changes.append({
+                "type": "created",
+                "task_id": task_id,
+                "content": task.content,
+                "state": task.state,
+            })
+        
+        # Deleted tasks
+        for task_id in cached_ids - current_ids:
+            task = self._task_cache[task_id]
+            changes.append({
+                "type": "deleted",
+                "task_id": task_id,
+                "content": task.content,
+            })
+        
+        # Modified tasks
+        for task_id in current_ids & cached_ids:
+            current = current_tasks[task_id]
+            cached = self._task_cache[task_id]
+            
+            if current.state != cached.state:
+                changes.append({
+                    "type": "state_changed",
+                    "task_id": task_id,
+                    "content": current.content,
+                    "old_state": cached.state,
+                    "new_state": current.state,
+                    "is_completed": current.is_completed,
+                })
+        
+        return changes
+    
+    async def _emit_task_changes(self, changes: List[Dict[str, Any]]) -> None:
+        """Emit events for task changes."""
+        event = TaskFileEvent(
+            path=self.config.path,
+            change_type=ChangeType.MODIFIED,
+            task_changes=changes,
+            metadata={
+                "total_changes": len(changes),
+                "completed_tasks": sum(1 for c in changes if c.get("is_completed")),
+            },
+        )
+        await self.emit(event)
+        
+        # Log summary
+        created = sum(1 for c in changes if c["type"] == "created")
+        completed = sum(1 for c in changes if c["type"] == "state_changed" and c.get("is_completed"))
+        logger.debug(f"Task changes: {created} created, {completed} completed")
+    
+    def get_task_stats(self) -> Dict[str, int]:
+        """Get task statistics."""
+        total = len(self._task_cache)
+        completed = sum(1 for t in self._task_cache.values() if t.is_completed)
+        in_progress = sum(1 for t in self._task_cache.values() if t.is_in_progress)
+        
+        return {
+            "total": total,
+            "completed": completed,
+            "in_progress": in_progress,
+            "pending": total - completed - in_progress,
+        }
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """Get watcher statistics."""
+        stats = super().get_stats()
+        stats.update(self.get_task_stats())
+        return stats

monoco/daemon/events.py

@@ -0,0 +1,34 @@
+"""
+EventBus - Central event system for Agent scheduling.
+
+DEPRECATED: This module has been moved to monoco.core.scheduler.
+This file is kept for backward compatibility and re-exports from the new location.
+
+Migration:
+    Old: from monoco.daemon.events import AgentEventType, event_bus
+    New: from monoco.core.scheduler import AgentEventType, event_bus
+"""
+
+import warnings
+from monoco.core.scheduler import (
+    AgentEventType,
+    AgentEvent,
+    EventBus,
+    event_bus,
+    EventHandler,
+)
+
+warnings.warn(
+    "monoco.daemon.events is deprecated. "
+    "Use monoco.core.scheduler instead.",
+    DeprecationWarning,
+    stacklevel=2
+)
+
+__all__ = [
+    "AgentEventType",
+    "AgentEvent",
+    "EventBus",
+    "event_bus",
+    "EventHandler",
+]

monoco/daemon/scheduler.py

@@ -1,236 +1,207 @@
+"""
+Scheduler Service - Unified event-driven architecture (FEAT-0164).
+
+This module implements a unified event-driven scheduler service that:
+1. Uses AgentScheduler for agent lifecycle management (FEAT-0160)
+2. Integrates Watcher framework for file system events (FEAT-0161)
+3. Uses ActionRouter for event routing (FEAT-0161)
+4. Uses new Handler framework from core.automation (FEAT-0162)
+
+Replaces the old architecture based on SessionManager + SemaphoreManager + polling loops.
+"""
+
 import asyncio
 import logging
 import os
-from typing import Dict, Optional, List, Any, Tuple
+from typing import Dict, Optional, List, Any
 from pathlib import Path
 
-from monoco.daemon.services import ProjectManager, SemaphoreManager
-from monoco.daemon.triggers import MemoAccumulationPolicy, HandoverPolicy
-from monoco.features.agent.manager import SessionManager
-from monoco.features.agent.models import RoleTemplate
-from monoco.features.agent.session import RuntimeSession
-from monoco.features.agent.apoptosis import ApoptosisManager
-from monoco.features.issue.core import list_issues
+from monoco.daemon.services import ProjectManager
+from monoco.core.scheduler import (
+    AgentEventType,
+    event_bus,
+    AgentScheduler,
+    LocalProcessScheduler,
+)
+from monoco.core.router import ActionRouter
+from monoco.core.watcher import WatchConfig, IssueWatcher, MemoWatcher, TaskWatcher
+from monoco.core.automation.handlers import start_all_handlers, stop_all_handlers
 from monoco.core.config import get_config
 
 logger = logging.getLogger("monoco.daemon.scheduler")
 
+
 class SchedulerService:
+    """
+    Unified event-driven scheduler service.
+    
+    Responsibilities:
+    - Initialize and manage AgentScheduler
+    - Setup and manage Watchers for file system events
+    - Configure ActionRouter for event routing
+    - Start/stop all handlers
+    
+    Architecture:
+    ```
+    SchedulerService
+    ├── AgentScheduler (LocalProcessScheduler)
+    │   └── Manages agent process lifecycle
+    ├── Watchers
+    │   ├── IssueWatcher -> EventBus
+    │   ├── MemoWatcher -> EventBus
+    │   └── TaskWatcher -> EventBus
+    ├── ActionRouter
+    │   └── Routes events to Actions
+    └── Handlers (from core.automation)
+        ├── TaskFileHandler
+        ├── IssueStageHandler
+        ├── MemoThresholdHandler
+        └── PRCreatedHandler
+    ```
+    """
+    
     def __init__(self, project_manager: ProjectManager):
         self.project_manager = project_manager
-        self.session_managers: Dict[str, SessionManager] = {} 
-        self._monitoring_task: Optional[asyncio.Task] = None
-        self.apoptosis_managers: Dict[str, ApoptosisManager] = {}
         
-        # Initialize SemaphoreManager with config
-        config = self._load_concurrency_config()
-        self.semaphore_manager = SemaphoreManager(config)
-
-    def _load_concurrency_config(self) -> Optional[Any]:
-        """Load concurrency configuration from config files and env vars."""
+        # AgentScheduler (FEAT-0160)
+        scheduler_config = self._load_scheduler_config()
+        self.agent_scheduler: AgentScheduler = LocalProcessScheduler(
+            max_concurrent=scheduler_config.get("max_concurrent", 5),
+            project_root=Path.cwd(),
+        )
+        
+        # ActionRouter (FEAT-0161)
+        self.action_router = ActionRouter(event_bus)
+        
+        # Watchers (FEAT-0161)
+        self.watchers: List[Any] = []
+        
+        # Handlers (FEAT-0162)
+        self.handlers: List[Any] = []
+        
+        # Background tasks
+        self._tasks: List[asyncio.Task] = []
+        self._running = False
+    
+    def _load_scheduler_config(self) -> Dict[str, Any]:
+        """Load scheduler configuration from config files and env vars."""
+        config = {"max_concurrent": 5}
+        
         try:
             settings = get_config()
-            concurrency_config = settings.agent.concurrency
+            
+            # Check for concurrency config
+            if hasattr(settings, "agent") and hasattr(settings.agent, "concurrency"):
+                concurrency_config = settings.agent.concurrency
+                if hasattr(concurrency_config, "global_max"):
+                    config["max_concurrent"] = concurrency_config.global_max
             
             # Check for environment variable override
             env_max_agents = os.environ.get("MONOCO_MAX_AGENTS")
             if env_max_agents:
                 try:
-                    concurrency_config.global_max = int(env_max_agents)
-                    logger.info(f"Overriding global_max from environment: {env_max_agents}")
+                    config["max_concurrent"] = int(env_max_agents)
+                    logger.info(f"Overriding max_concurrent from environment: {env_max_agents}")
                 except ValueError:
                     logger.warning(f"Invalid MONOCO_MAX_AGENTS value: {env_max_agents}")
             
-            return concurrency_config
+            return config
         except Exception as e:
-            logger.warning(f"Failed to load concurrency config: {e}. Using defaults.")
-            return None
-
-    def get_managers(self, project_path: Path) -> Tuple[SessionManager, ApoptosisManager]:
-        key = str(project_path)
-        if key not in self.session_managers:
-            sm = SessionManager(project_root=project_path)
-            self.session_managers[key] = sm
-            self.apoptosis_managers[key] = ApoptosisManager(sm)
-        return self.session_managers[key], self.apoptosis_managers[key]
-
+            logger.warning(f"Failed to load scheduler config: {e}. Using defaults.")
+            return config
+    
     async def start(self):
-        logger.info("Starting Scheduler Service...")
-        self._monitoring_task = asyncio.create_task(self.monitor_loop())
-
+        """Start the scheduler service."""
+        logger.info("Starting Scheduler Service (unified event-driven architecture)...")
+        self._running = True
+        
+        # 1. Start EventBus
+        await event_bus.start()
+        
+        # 2. Start AgentScheduler
+        await self.agent_scheduler.start()
+        
+        # 3. Setup and start Watchers
+        self._setup_watchers()
+        for watcher in self.watchers:
+            await watcher.start()
+        
+        # 4. Start Handlers (FEAT-0162)
+        self.handlers = start_all_handlers(self.agent_scheduler)
+        
+        # 5. Start ActionRouter
+        await self.action_router.start()
+        
+        logger.info("Scheduler Service started with unified event-driven architecture")
+    
     def stop(self):
+        """Stop the scheduler service."""
         logger.info("Stopping Scheduler Service...")
-        if self._monitoring_task:
-            self._monitoring_task.cancel()
-        
-        # Terminate all sessions
-        for sm in self.session_managers.values():
-            filtered_sessions = sm.list_sessions() 
-            for session in filtered_sessions:
-                session.terminate()
-
-    async def monitor_loop(self):
-        try:
-            while True:
-                await self.tick()
-                await asyncio.sleep(5)
-        except asyncio.CancelledError:
-            pass
-        except Exception as e:
-            logger.error(f"Scheduler loop crashed: {e}", exc_info=True)
-
-    async def tick(self):
-        # We iterate over keys to avoid modification during iteration issues if new projects added
-        projects = list(self.project_manager.projects.values())
-        for project_ctx in projects:
-            await self.process_project(project_ctx)
-
-    async def process_project(self, project_context):
-        sm, am = self.get_managers(project_context.path)
+        self._running = False
         
-        # 1. Trigger Check: Architect
-        await self.check_inbox_trigger(sm, project_context)
-
-        # 1.5 Handover Trigger: Architect -> Engineer
-        await self.check_handover_trigger(sm, project_context)
-
-        # 2. Monitor Active Sessions (Supervisor)
-        active_sessions = sm.list_sessions()
-        for session in active_sessions:
-            if session.model.status in ["running", "pending"]:
-                status = session.refresh_status() # Updates model.status
-                
-                # Check for timeout/failure
-                if status == "timeout" or status == "failed":
-                     if session.model.status != "crashed": 
-                         logger.warning(f"Session {session.model.id} led to {status}. Triggering Autopsy.")
-                         # Record failure for cooldown
-                         self.semaphore_manager.record_failure(
-                             issue_id=session.model.issue_id,
-                             session_id=session.model.id
-                         )
-                         am.trigger_apoptosis(session.model.id, failure_reason=f"Session status became {status}")
-                else:
-                    # Track active session in semaphore manager
-                    self.semaphore_manager.acquire(session.model.id, session.model.role_name)
-                
-                # Daemon Logic for Chained Execution
-                if status == "completed":
-                    # Clear failure record on success
-                    self.semaphore_manager.clear_failure(session.model.issue_id)
-                    self.handle_completion(session, sm)
-
-    async def check_inbox_trigger(self, sm: SessionManager, project_context):
-        # Checking existing Architect sessions
-        existing_architects = [s for s in sm.list_sessions() if s.model.role_name == "Architect" and s.model.status == "running"]
-        
-        if not existing_architects:
-            # Check semaphore before spawning
-            if not self.semaphore_manager.can_acquire("Architect"):
-                logger.warning("Cannot spawn Architect: concurrency limit reached")
-                return
-                
-            trigger_policy = MemoAccumulationPolicy(count_threshold=5)
-            if trigger_policy.evaluate({"issues_root": project_context.issues_root}):
-                logger.info(f"Triggering Architect for project {project_context.id}")
-                self.spawn_architect(sm, project_context)
-
-    async def check_handover_trigger(self, sm: SessionManager, project_context):
-        # Scan for OPEN + DOING issues with no active worker
-        try:
-            all_issues = list_issues(project_context.issues_root)
-            handover_policy = HandoverPolicy(target_status="open", target_stage="doing")
-            
-            for issue in all_issues:
-                if handover_policy.evaluate({"issue": issue}):
-                    # Check if session exists
-                    active = [s for s in sm.list_sessions(issue_id=issue.id) if s.model.status in ["running", "pending"]]
-                    if not active:
-                        # Check semaphore before spawning (including cooldown check)
-                        if not self.semaphore_manager.can_acquire("Engineer", issue_id=issue.id):
-                            logger.warning(f"Cannot spawn Engineer for {issue.id}: concurrency limit or cooldown active")
-                            continue
-                            
-                        logger.info(f"Handover trigger: Spawning Engineer for {issue.id}")
-                        self.spawn_engineer(sm, issue)
-        except Exception as e:
-            logger.error(f"Error in Handover trigger: {e}")
-
-    def spawn_engineer(self, sm: SessionManager, issue):
-        role = RoleTemplate(
-            name="Engineer",
-            description="Software Engineer",
-            trigger="handover",
-            goal=f"Implement feature: {issue.title}",
-            system_prompt="You are a Software Engineer. Read the issue and implement requirements.",
-            engine="gemini"
-        )
-        session = sm.create_session(issue_id=issue.id, role=role)
+        # Cancel background tasks
+        for task in self._tasks:
+            task.cancel()
         
-        # Acquire semaphore slot
-        self.semaphore_manager.acquire(session.model.id, "Engineer")
+        # Stop ActionRouter
+        asyncio.create_task(self.action_router.stop())
         
-        try:
-            session.start()
-        except Exception as e:
-            # Release slot on spawn failure
-            self.semaphore_manager.release(session.model.id)
-            self.semaphore_manager.record_failure(issue.id, session.model.id)
-            logger.error(f"Failed to start Engineer session for {issue.id}: {e}")
-            raise
-
-    def spawn_architect(self, sm: SessionManager, project_context):
-        # Create Architect Session
-        role = RoleTemplate(
-            name="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" # Default or from config?
-        )
-        session = sm.create_session(issue_id="architecture-review", role=role)
+        # Stop Handlers
+        stop_all_handlers(self.handlers)
+        self.handlers = []
         
-        # Acquire semaphore slot
-        self.semaphore_manager.acquire(session.model.id, "Architect")
+        # Stop Watchers
+        for watcher in self.watchers:
+            asyncio.create_task(watcher.stop())
+        self.watchers = []
         
-        try:
-            session.start()
-        except Exception as e:
-            # Release slot on spawn failure
-            self.semaphore_manager.release(session.model.id)
-            logger.error(f"Failed to start Architect session: {e}")
-            raise
-
-    def handle_completion(self, session: RuntimeSession, sm: SessionManager):
-        # Chained Execution: Engineer -> Reviewer
-        if session.model.role_name == "Engineer":
-            # Check semaphore before spawning Reviewer
-            if not self.semaphore_manager.can_acquire("Reviewer", issue_id=session.model.issue_id):
-                logger.warning(
-                    f"Cannot spawn Reviewer for {session.model.issue_id}: "
-                    f"concurrency limit reached. Review will be deferred."
-                )
-                return
-                
-            logger.info(f"Engineer finished for {session.model.issue_id}. Spawning Reviewer.")
-            reviewer_role = RoleTemplate(
-                name="Reviewer",
-                description="Code Reviewer",
-                trigger="engineer.completion",
-                goal=f"Review work on {session.model.issue_id}",
-                system_prompt="You are a Code Reviewer. Review the code changes.",
-                engine="gemini"
+        # Stop AgentScheduler
+        asyncio.create_task(self.agent_scheduler.stop())
+        
+        # Stop EventBus
+        asyncio.create_task(event_bus.stop())
+        
+        logger.info("Scheduler Service stopped")
+    
+    def _setup_watchers(self):
+        """Initialize all filesystem watchers."""
+        for project_ctx in self.project_manager.projects.values():
+            # IssueWatcher
+            config = WatchConfig(
+                path=project_ctx.issues_root,
+                patterns=["*.md"],
+                recursive=True,
             )
-            rs = sm.create_session(issue_id=session.model.issue_id, role=reviewer_role)
+            self.watchers.append(IssueWatcher(config, event_bus))
             
-            # Acquire semaphore slot
-            self.semaphore_manager.acquire(rs.model.id, "Reviewer")
+            # MemoWatcher
+            memo_path = project_ctx.path / "Memos" / "inbox.md"
+            if memo_path.exists():
+                memo_config = WatchConfig(
+                    path=memo_path,
+                    patterns=["*.md"],
+                )
+                self.watchers.append(MemoWatcher(memo_config, event_bus))
             
-            try:
-                rs.start()
-            except Exception as e:
-                # Release slot on spawn failure
-                self.semaphore_manager.release(rs.model.id)
-                logger.error(f"Failed to start Reviewer session for {session.model.issue_id}: {e}")
-                raise
+            # TaskWatcher (if tasks.md exists)
+            task_path = project_ctx.path / "tasks.md"
+            if task_path.exists():
+                task_config = WatchConfig(
+                    path=task_path,
+                    patterns=["*.md"],
+                )
+                self.watchers.append(TaskWatcher(task_config, event_bus))
+        
+        logger.info(f"Setup {len(self.watchers)} watchers")
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """Get scheduler service statistics."""
+        return {
+            "running": self._running,
+            "event_bus": event_bus.get_stats(),
+            "agent_scheduler": self.agent_scheduler.get_stats(),
+            "watchers": len(self.watchers),
+            "handlers": len(self.handlers),
+            "action_router": self.action_router.get_stats(),
+            "projects": len(self.project_manager.projects),
+        }