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

monoco/daemon/scheduler.py

@@ -0,0 +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
+from pathlib import Path
+
+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
+        
+        # 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()
+            
+            # 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:
+                    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 config
+        except Exception as e:
+            logger.warning(f"Failed to load scheduler config: {e}. Using defaults.")
+            return config
+    
+    async def start(self):
+        """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...")
+        self._running = False
+        
+        # Cancel background tasks
+        for task in self._tasks:
+            task.cancel()
+        
+        # Stop ActionRouter
+        asyncio.create_task(self.action_router.stop())
+        
+        # Stop Handlers
+        stop_all_handlers(self.handlers)
+        self.handlers = []
+        
+        # Stop Watchers
+        for watcher in self.watchers:
+            asyncio.create_task(watcher.stop())
+        self.watchers = []
+        
+        # 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,
+            )
+            self.watchers.append(IssueWatcher(config, event_bus))
+            
+            # 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))
+            
+            # 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),
+        }

monoco/daemon/services.py

@@ -3,7 +3,7 @@ from typing import List, Optional, Dict, Any
 from asyncio import Queue
 from pathlib import Path
 
-import json
+from monoco.core.workspace import MonocoProject, Workspace
 
 logger = logging.getLogger("monoco.daemon.services")
 
@@ -31,6 +31,7 @@ class Broadcaster:
         if not self.subscribers:
             return
 
+        import json
         message = {"event": event_type, "data": json.dumps(payload)}
 
         # Dispatch to all queues
@@ -40,12 +41,6 @@ class Broadcaster:
         logger.debug(f"Broadcasted {event_type} to {len(self.subscribers)} clients.")
 
 
-# Monitors moved to monoco.core.git and monoco.features.issue.monitor
-
-
-from monoco.core.workspace import MonocoProject, Workspace
-
-
 class ProjectContext:
     """
     Holds the runtime state for a single project.
@@ -58,7 +53,31 @@ class ProjectContext:
         self.name = project.name
         self.path = project.path
         self.issues_root = project.issues_root
-        self.monitor = IssueMonitor(self.issues_root, broadcaster, project_id=self.id)
+
+        async def on_upsert(issue_data: dict):
+            await broadcaster.broadcast(
+                "issue_upserted", {"issue": issue_data, "project_id": self.id}
+            )
+
+        async def on_delete(issue_data: dict):
+            await broadcaster.broadcast(
+                "issue_deleted", {"id": issue_data["id"], "project_id": self.id}
+            )
+
+        from monoco.features.issue.monitor import IssueMonitor
+        self.monitor = IssueMonitor(self.issues_root, on_upsert, on_delete)
+
+    async def notify_move(self, old_path: str, new_path: str, issue_data: dict):
+        """Explicitly notify frontend about a logical move (Physical path changed)."""
+        await self.broadcaster.broadcast(
+            "issue_moved",
+            {
+                "old_path": old_path,
+                "new_path": new_path,
+                "issue": issue_data,
+                "project_id": self.id,
+            },
+        )
 
     async def start(self):
         await self.monitor.start()
@@ -113,53 +132,3 @@ class ProjectManager:
             }
             for p in self.projects.values()
         ]
-
-
-from monoco.features.issue.monitor import IssueMonitor
-
-
-class ProjectContext:
-    """
-    Holds the runtime state for a single project.
-    Now wraps the core MonocoProject primitive.
-    """
-
-    def __init__(self, project: MonocoProject, broadcaster: Broadcaster):
-        self.project = project
-        self.id = project.id
-        self.name = project.name
-        self.path = project.path
-        self.issues_root = project.issues_root
-
-        async def on_upsert(issue_data: dict):
-            await broadcaster.broadcast(
-                "issue_upserted", {"issue": issue_data, "project_id": self.id}
-            )
-
-        async def on_delete(issue_data: dict):
-            # We skip broadcast here if it's part of a move?
-            # Actually, standard upsert/delete is fine, but we need a specialized event for MOVE
-            # to help VS Code redirect without closing/reopening.
-            await broadcaster.broadcast(
-                "issue_deleted", {"id": issue_data["id"], "project_id": self.id}
-            )
-
-        self.monitor = IssueMonitor(self.issues_root, on_upsert, on_delete)
-
-    async def notify_move(self, old_path: str, new_path: str, issue_data: dict):
-        """Explicitly notify frontend about a logical move (Physical path changed)."""
-        await self.broadcaster.broadcast(
-            "issue_moved",
-            {
-                "old_path": old_path,
-                "new_path": new_path,
-                "issue": issue_data,
-                "project_id": self.id,
-            },
-        )
-
-    async def start(self):
-        await self.monitor.start()
-
-    def stop(self):
-        self.monitor.stop()

monoco/daemon/triggers.py

@@ -0,0 +1,55 @@
+from typing import TYPE_CHECKING, Optional, List, Any
+from pathlib import Path
+from monoco.features.memo.core import load_memos
+from monoco.features.issue.models import IssueMetadata, IssueStatus, IssueStage
+
+if TYPE_CHECKING:
+    from monoco.features.issue.models import IssueMetadata
+
+class TriggerPolicy:
+    """
+    Base class for trigger policies.
+    """
+    def evaluate(self, context: dict) -> bool:
+        raise NotImplementedError
+
+class MemoAccumulationPolicy(TriggerPolicy):
+    """
+    Trigger when pending memos exceed a threshold.
+    """
+    def __init__(self, count_threshold: int = 5):
+        self.count_threshold = count_threshold
+
+    def evaluate(self, context: dict) -> bool:
+        issues_root = context.get("issues_root")
+        if not issues_root:
+            return False
+        
+        if isinstance(issues_root, str):
+            issues_root = Path(issues_root)
+            
+        try:
+            memos = load_memos(issues_root)
+            pending_memos = [m for m in memos if m.status == "pending"]
+            return len(pending_memos) >= self.count_threshold
+        except Exception as e:
+            print(f"Error evaluating MemoAccumulationPolicy: {e}")
+            return False
+
+class HandoverPolicy(TriggerPolicy):
+    """
+    Trigger when an issue enters a specific state (e.g. Open/Doing for Engineer).
+    """
+    def __init__(self, target_status: IssueStatus, target_stage: IssueStage):
+        self.target_status = target_status
+        self.target_stage = target_stage
+
+    def evaluate(self, context: dict) -> bool:
+        issue: Optional[IssueMetadata] = context.get("issue")
+        if not issue:
+            return False
+            
+        return (
+            issue.status == self.target_status 
+            and issue.stage == self.target_stage
+        )

monoco/features/agent/__init__.py

@@ -1,10 +1,25 @@
+"""
+Agent feature module - CLI interface for agent operations.
+
+Note: The old SessionManager/RuntimeSession/ApoptosisManager architecture
+has been removed in FEAT-0164. This module now provides CLI commands that
+use the new AgentScheduler abstraction from core.scheduler.
+"""
+
 from .models import RoleTemplate, AgentRoleConfig as AgentConfig, SchedulerConfig
 from .worker import Worker
 from .config import load_scheduler_config, load_agent_config
 from .defaults import DEFAULT_ROLES
-from .session import Session, RuntimeSession
-from .manager import SessionManager
-from .apoptosis import ApoptosisManager
+
+# Re-export engines from core.scheduler for backward compatibility
+from monoco.core.scheduler import (
+    EngineAdapter,
+    EngineFactory,
+    GeminiAdapter,
+    ClaudeAdapter,
+    QwenAdapter,
+    KimiAdapter,
+)
 
 __all__ = [
     "RoleTemplate",
@@ -14,8 +29,11 @@ __all__ = [
     "Worker",
     "load_scheduler_config",
     "DEFAULT_ROLES",
-    "Session",
-    "RuntimeSession",
-    "SessionManager",
-    "ApoptosisManager",
+    # Re-exported from core.scheduler
+    "EngineAdapter",
+    "EngineFactory",
+    "GeminiAdapter",
+    "ClaudeAdapter",
+    "QwenAdapter",
+    "KimiAdapter",
 ]

monoco/features/agent/adapter.py

@@ -1,18 +1,28 @@
 from pathlib import Path
 from typing import Dict
-from monoco.core.feature import MonocoFeature, IntegrationData
+from monoco.core.loader import FeatureModule, FeatureMetadata
+from monoco.core.feature import IntegrationData
 
 
-class AgentFeature(MonocoFeature):
-    @property
-    def name(self) -> str:
-        return "agent"
+class AgentFeature(FeatureModule):
+    """Agent management feature module with unified lifecycle support."""
 
-    def initialize(self, root: Path, config: Dict) -> None:
-        # Agent feature doesn't require special initialization
+    @property
+    def metadata(self) -> FeatureMetadata:
+        return FeatureMetadata(
+            name="agent",
+            version="1.0.0",
+            description="Agent session and role management",
+            dependencies=["core"],
+            priority=20,
+        )
+
+    def _on_mount(self, context: "FeatureContext") -> None:  # type: ignore
+        """Agent feature doesn't require special initialization."""
         pass
 
     def integrate(self, root: Path, config: Dict) -> IntegrationData:
+        """Provide integration data for agent environment."""
         # Determine language from config, default to 'en'
         lang = config.get("i18n", {}).get("source_lang", "en")