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

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/skills.py

@@ -2,17 +2,21 @@
 Skill Manager for Monoco Toolkit.
 
 This module provides centralized management and distribution of Agent Skills
-following the agentskills.io standard and the three-level architecture:
-- Atom Skills: Atomic capabilities
-- Workflow Skills: Orchestration of atoms
-- Role Skills: Configuration layer
+following the standardized architecture:
+- Atom Skills: monoco_atom_{name} - Atomic capabilities
+- Workflow Skills: monoco_workflow_{name} - Orchestration of atoms
+- Role Skills: monoco_role_{name} - Configuration layer
 
 Key Responsibilities:
-1. Discover skills from resources/{lang}/skills/ directory (legacy)
-2. Discover skills from resources/atoms/, workflows/, roles/ (new three-level)
-3. Validate skill structure and metadata
-4. Distribute skills to target agent framework directories
-5. Support i18n for skill content
+1. Discover skills from features (monoco/features/{feature}/resources/)
+2. Validate skill structure and metadata
+3. Distribute skills to target agent framework directories
+4. Support i18n for skill content
+
+Architecture Principle:
+- Core is framework-only, no skills
+- All skills are defined in Features (value delivery atoms)
+- All skills follow naming convention: monoco_{type}_{name}
 """
 
 import shutil
@@ -165,22 +169,17 @@ class Skill:
 
 class SkillManager:
     """
-    Central manager for Monoco skills supporting both legacy and three-level architecture.
+    Central manager for Monoco skills.
     
-    Three-Level Architecture:
-    - Atom Skills: resources/atoms/*.yaml
-    - Workflow Skills: resources/workflows/*.yaml  
-    - Role Skills: resources/roles/*.yaml
+    Architecture:
+    - Atom Skills: resources/{lang}/skills/monoco_atom_*/SKILL.md or resources/atoms/*.yaml
+    - Workflow Skills: resources/{lang}/skills/monoco_workflow_*/SKILL.md or resources/workflows/*.yaml
+    - Role Skills: resources/{lang}/roles/monoco_role_*.yaml
     
-    Legacy Architecture:
-    - Standard Skills: resources/{lang}/skills/{name}/SKILL.md
-    - Flow Skills: resources/{lang}/skills/flow_*/SKILL.md
+    All skills follow the naming convention: monoco_{type}_{name}
     """
 
-    # Default prefix for flow skills
-    FLOW_SKILL_PREFIX = "monoco_flow_"
-    
-    # Prefix for three-level architecture skills
+    # Prefix for standardized skill naming
     ATOM_PREFIX = "monoco_atom_"
     WORKFLOW_PREFIX = "monoco_workflow_"
     ROLE_PREFIX = "monoco_role_"
@@ -189,37 +188,24 @@ class SkillManager:
         self,
         root: Path,
         features: Optional[List] = None,
-        flow_skill_prefix: str = FLOW_SKILL_PREFIX,
     ):
         self.root = root
         self.features = features or []
-        self.flow_skill_prefix = flow_skill_prefix
         
-        # Legacy skills
+        # Skills discovered from resources/{lang}/skills/monoco_*/SKILL.md
         self.skills: Dict[str, Skill] = {}
         
-        # New three-level architecture skills
+        # Three-level architecture skills
         self._skill_loaders: Dict[str, SkillLoader] = {}
         self._atoms: Dict[str, AtomSkillMetadata] = {}
         self._workflows: Dict[str, WorkflowSkillMetadata] = {}
         self._roles: Dict[str, RoleSkillMetadata] = {}
 
-        # Load legacy skills
+        # Discover skills from features only (core is framework-only, no skills)
         if self.features:
             self._discover_skills_from_features()
-        self._discover_core_skills()
-        
-        # Load new three-level skills
-        self._discover_three_level_skills()
-
-    def _discover_core_skills(self) -> None:
-        """Discover skills from monoco/core/resources/{lang}/skills/."""
-        core_resources_dir = self.root / "monoco" / "core" / "resources"
-
-        if not core_resources_dir.exists():
-            return
+            self._discover_three_level_skills()
 
-        self._discover_skills_in_resources(core_resources_dir, "monoco_core")
 
     def _discover_skills_from_features(self) -> None:
         """Discover skills from Feature resources."""
@@ -250,7 +236,7 @@ class SkillManager:
         if not resources_dir.exists():
             return
 
-        skill_names: Set[str] = set()
+        skill_folders: Set[Path] = set()
 
         for lang_dir in resources_dir.iterdir():
             if not lang_dir.is_dir() or len(lang_dir.name) != 2:
@@ -262,9 +248,11 @@ class SkillManager:
 
             for skill_subdir in skills_dir.iterdir():
                 if skill_subdir.is_dir() and (skill_subdir / "SKILL.md").exists():
-                    skill_names.add(skill_subdir.name)
+                    # print(f"DEBUG: Found skill folder {skill_subdir.name} in feature {feature_name}")
+                    skill_folders.add(skill_subdir)
 
-        for skill_name in skill_names:
+        for skill_dir in skill_folders:
+            skill_name = skill_dir.name
             skill = Skill(
                 root_dir=self.root,
                 skill_name=skill_name,
@@ -277,40 +265,96 @@ class SkillManager:
                 )
                 continue
 
-            skill_type = skill.get_type()
-            if skill_type == "flow":
-                name = skill_name
-                if name.startswith("flow_"):
-                    name = name[5:]
-                skill_key = f"{self.flow_skill_prefix}{name}"
+            # Naming Logic: All skills must follow monoco_{type}_{name} convention
+            # The skill_key is the folder name (which should match the metadata name)
+            if skill_name.startswith("monoco_"):
+                skill_key = skill_name
             else:
-                skill_key = f"{feature_name}_{skill_name}"
+                # Non-compliant skills are skipped (should not happen after standardization)
+                console.print(
+                    f"[yellow]Warning: Skill {skill_name} does not follow monoco_{{type}}_{{name}} naming, skipping[/yellow]"
+                )
+                continue
 
             skill.name = skill_key
             self.skills[skill_key] = skill
 
     def _discover_three_level_skills(self) -> None:
-        """Discover skills from the new three-level architecture."""
-        # Discover from agent feature resources
-        agent_resources_dir = self.root / "monoco" / "features" / "agent" / "resources"
-        
-        if not agent_resources_dir.exists():
-            return
-            
-        loader = SkillLoader(agent_resources_dir)
-        loader.load_all()
-        
-        self._skill_loaders["agent"] = loader
+        """Discover skills from the new three-level architecture in resources/{atoms,workflows,roles}/."""
+        from monoco.core.feature import MonocoFeature
         
-        # Merge loaded skills
-        for name, atom in loader._atoms.items():
-            self._atoms[f"{self.ATOM_PREFIX}{name}"] = atom
-            
-        for name, workflow in loader._workflows.items():
-            self._workflows[f"{self.WORKFLOW_PREFIX}{name}"] = workflow
-            
-        for name, role in loader._roles.items():
-            self._roles[f"{self.ROLE_PREFIX}{name}"] = role
+        for feature in self.features:
+            if not isinstance(feature, MonocoFeature):
+                continue
+                
+            module_parts = feature.__class__.__module__.split(".")
+            if (
+                len(module_parts) >= 3
+                and module_parts[0] == "monoco"
+                and module_parts[1] == "features"
+            ):
+                feature_name = module_parts[2]
+                resources_dir = self.root / "monoco" / "features" / feature_name / "resources"
+                
+                if not resources_dir.exists():
+                    continue
+                
+                # Discover atoms from resources/atoms/*.yaml
+                atoms_dir = resources_dir / "atoms"
+                if atoms_dir.exists():
+                    for atom_file in atoms_dir.glob("*.yaml"):
+                        try:
+                            data = yaml.safe_load(atom_file.read_text())
+                            atom = AtomSkillMetadata(**data)
+                            
+                            # Ensure name follows monoco_atom_ prefix
+                            atom_key = atom.name
+                            if not atom_key.startswith(self.ATOM_PREFIX):
+                                atom_key = f"{self.ATOM_PREFIX}{atom_key}"
+                            
+                            self._atoms[atom_key] = atom
+                        except Exception as e:
+                            console.print(f"[red]Failed to load atom skill {atom_file}: {e}[/red]")
+                
+                # Discover workflows from resources/workflows/*.yaml
+                workflows_dir = resources_dir / "workflows"
+                if workflows_dir.exists():
+                    for workflow_file in workflows_dir.glob("*.yaml"):
+                        try:
+                            data = yaml.safe_load(workflow_file.read_text())
+                            workflow = WorkflowSkillMetadata(**data)
+                            
+                            # Ensure name follows monoco_workflow_ prefix
+                            workflow_key = workflow.name
+                            if not workflow_key.startswith(self.WORKFLOW_PREFIX):
+                                workflow_key = f"{self.WORKFLOW_PREFIX}{workflow_key}"
+                            
+                            self._workflows[workflow_key] = workflow
+                        except Exception as e:
+                            console.print(f"[red]Failed to load workflow skill {workflow_file}: {e}[/red]")
+                
+                # Discover roles from resources/{lang}/roles/*.yaml
+                for lang_dir in resources_dir.iterdir():
+                    if not lang_dir.is_dir() or len(lang_dir.name) != 2:
+                        continue
+                    
+                    roles_dir = lang_dir / "roles"
+                    if not roles_dir.exists():
+                        continue
+                    
+                    for role_file in roles_dir.glob("*.yaml"):
+                        try:
+                            data = yaml.safe_load(role_file.read_text())
+                            role = RoleSkillMetadata(**data)
+                            
+                            # Ensure name follows monoco_role_ prefix
+                            role_key = role.name
+                            if not role_key.startswith(self.ROLE_PREFIX):
+                                role_key = f"{self.ROLE_PREFIX}{role_key}"
+                            
+                            self._roles[role_key] = role
+                        except Exception as e:
+                            console.print(f"[red]Failed to load role skill {role_file}: {e}[/red]")
 
     # ========================================================================
     # Legacy Skill API (backward compatible)
@@ -688,19 +732,14 @@ class SkillManager:
         """Get list of available flow skill commands."""
         commands = []
         
-        # Legacy flow skills
-        for skill in self.get_flow_skills():
-            role = skill.get_role()
-            if role:
-                commands.append(f"/flow:{role}")
-            else:
-                name = skill.name
-                if name.startswith(self.flow_skill_prefix):
-                    role = name[len(self.flow_skill_prefix):]
-                    if role:
-                        commands.append(f"/flow:{role}")
+        # Workflow/Flow skills with role attribute from legacy skills
+        for skill in self.skills.values():
+            if skill.get_type() in ["flow", "workflow"]:
+                role = skill.get_role()
+                if role:
+                    commands.append(f"/flow:{role}")
         
-        # New role skills
+        # Role skills from three-level architecture
         for role_name in self._roles.keys():
             short_name = role_name.replace(self.ROLE_PREFIX, "")
             commands.append(f"/flow:{short_name}")