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

monoco/core/registry.py

@@ -1,45 +1,54 @@
-from typing import Dict, List
+from typing import Dict, List, Optional
 from monoco.core.feature import MonocoFeature
+from monoco.core.loader import FeatureLoader, FeatureRegistry as LoaderFeatureRegistry
 
 
 class FeatureRegistry:
-    _features: Dict[str, MonocoFeature] = {}
+    """
+    Feature registry that wraps the new unified FeatureLoader.
+    
+    This class provides backward compatibility while delegating to the
+    new FeatureLoader for dynamic discovery and lifecycle management.
+    """
+
+    _loader: Optional[FeatureLoader] = None
+
+    @classmethod
+    def _get_loader(cls) -> FeatureLoader:
+        """Get or create the default feature loader."""
+        if cls._loader is None:
+            cls._loader = FeatureLoader()
+            # Discover and load all features
+            cls._loader.discover()
+            cls._loader.load_all()
+        return cls._loader
 
     @classmethod
     def register(cls, feature: MonocoFeature):
         """Register a feature instance."""
-        cls._features[feature.name] = feature
+        loader = cls._get_loader()
+        loader.registry.register(feature)  # type: ignore
 
     @classmethod
     def get_features(cls) -> List[MonocoFeature]:
         """Get all registered features."""
-        return list(cls._features.values())
+        loader = cls._get_loader()
+        return loader.registry.get_all()  # type: ignore
 
     @classmethod
-    def get_feature(cls, name: str) -> MonocoFeature:
+    def get_feature(cls, name: str) -> Optional[MonocoFeature]:
         """Get a specific feature by name."""
-        return cls._features.get(name)
+        loader = cls._get_loader()
+        return loader.registry.get(name)  # type: ignore
 
     @classmethod
     def load_defaults(cls):
         """
-        Load default core features.
-        TODO: In the future, this could be dynamic via entry points.
-        """
-        # Import here to avoid circular dependencies at module level
-        from monoco.features.issue.adapter import IssueFeature
-        from monoco.features.spike.adapter import SpikeFeature
-        from monoco.features.i18n.adapter import I18nFeature
-        from monoco.features.memo.adapter import MemoFeature
-
-        cls.register(IssueFeature())
-        cls.register(SpikeFeature())
-        cls.register(I18nFeature())
-        cls.register(MemoFeature())
-
+        Load default core features using the unified FeatureLoader.
         
-        from monoco.features.glossary.adapter import GlossaryFeature
-        cls.register(GlossaryFeature())
-
-        from monoco.features.agent.adapter import AgentFeature
-        cls.register(AgentFeature())
+        This method discovers and loads all features from monoco/features/
+        automatically, replacing the manual registration approach.
+        """
+        loader = cls._get_loader()
+        # Features are already discovered and loaded in _get_loader
+        # This method is kept for backward compatibility

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}")

monoco/daemon/app.py

@@ -9,6 +9,8 @@ from typing import Optional, List, Dict
 from monoco.daemon.services import Broadcaster, ProjectManager
 from monoco.core.git import GitMonitor
 from monoco.core.config import get_config, ConfigMonitor, ConfigScope, get_config_path
+from monoco.daemon.scheduler import SchedulerService
+from monoco.daemon.mailroom_service import MailroomService
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
@@ -34,6 +36,8 @@ broadcaster = Broadcaster()
 git_monitor: GitMonitor | None = None
 config_monitors: List[ConfigMonitor] = []
 project_manager: ProjectManager | None = None
+scheduler_service: SchedulerService | None = None
+mailroom_service: MailroomService | None = None
 
 
 @asynccontextmanager
@@ -41,7 +45,7 @@ async def lifespan(app: FastAPI):
     # Startup
     logger.info("Starting Monoco Daemon services...")
 
-    global project_manager, git_monitor, config_monitors
+    global project_manager, git_monitor, config_monitors, scheduler_service, mailroom_service
     # Use MONOCO_SERVER_ROOT if set, otherwise CWD
     env_root = os.getenv("MONOCO_SERVER_ROOT")
     workspace_root = Path(env_root) if env_root else Path.cwd()
@@ -72,6 +76,17 @@ async def lifespan(app: FastAPI):
     ]
 
     await project_manager.start_all()
+    # Start Scheduler
+    scheduler_service = SchedulerService(project_manager)
+    await scheduler_service.start()
+    
+    # Start Mailroom Service
+    mailroom_service = MailroomService(
+        workspace_root=workspace_root,
+        broadcaster=broadcaster,
+    )
+    await mailroom_service.start()
+    
     git_task = asyncio.create_task(git_monitor.start())
     config_tasks = [asyncio.create_task(m.start()) for m in config_monitors]
 
@@ -84,6 +99,10 @@ async def lifespan(app: FastAPI):
         m.stop()
     if project_manager:
         project_manager.stop_all()
+    if scheduler_service:
+        scheduler_service.stop()
+    if mailroom_service:
+        await mailroom_service.stop()
 
     await git_task
     await asyncio.gather(*config_tasks)
@@ -301,6 +320,21 @@ async def create_issue_endpoint(payload: CreateIssueRequest):
             related=payload.related,
             subdir=payload.subdir,
         )
+        
+        # Link memos to the newly created issue
+        if payload.from_memos:
+            from monoco.features.memo.core import load_memos, update_memo
+            
+            existing_memos = {m.uid: m for m in load_memos(project.issues_root)}
+            
+            for memo_id in payload.from_memos:
+                if memo_id in existing_memos:
+                    # Only update if not already linked to this issue (idempotency)
+                    memo = existing_memos[memo_id]
+                    if memo.ref != issue.id:
+                        update_memo(project.issues_root, memo_id, {"status": "tracked", "ref": issue.id})
+                # Non-blocking: ignore missing memos (just log warning)
+        
         return issue
     except Exception as e:
         raise HTTPException(status_code=400, detail=str(e))
@@ -489,3 +523,45 @@ async def update_workspace_state(state: WorkspaceState):
         raise HTTPException(
             status_code=500, detail=f"Failed to persist state: {str(e)}"
         )
+
+
+# --- Mailroom API Endpoints ---
+
+
+@app.get("/api/v1/mailroom/status")
+async def get_mailroom_status():
+    """
+    Get Mailroom service status, capabilities, and statistics.
+    """
+    if not mailroom_service:
+        raise HTTPException(status_code=503, detail="Mailroom service not initialized")
+    
+    return mailroom_service.get_status()
+
+
+@app.post("/api/v1/mailroom/discover")
+async def trigger_mailroom_discovery():
+    """
+    Trigger environment discovery for conversion tools.
+    """
+    if not mailroom_service:
+        raise HTTPException(status_code=503, detail="Mailroom service not initialized")
+    
+    discovery = mailroom_service.get_discovery()
+    tools = discovery.discover(force=True)
+    
+    total_tools = sum(len(t) for t in tools.values())
+    capabilities = discovery.get_capabilities_summary()
+    
+    return {
+        "discovered": total_tools,
+        "capabilities": capabilities,
+        "tools": [
+            {
+                "name": tool.name,
+                "type": tool.tool_type.value,
+                "version": tool.version,
+            }
+            for tool in discovery.get_all_tools()
+        ],
+    }

monoco/daemon/commands.py

@@ -15,6 +15,9 @@ def serve(
         False, "--reload", "-r", help="Enable auto-reload for dev"
     ),
     root: Optional[str] = typer.Option(None, "--root", help="Workspace root directory"),
+    max_agents: Optional[int] = typer.Option(
+        None, "--max-agents", help="Override global maximum concurrent agents (default: 3)"
+    ),
 ):
     """
     Start the Monoco Daemon server.
@@ -26,6 +29,13 @@ def serve(
         print_output(
             f"Workspace Root: {os.environ['MONOCO_SERVER_ROOT']}", title="Monoco Serve"
         )
+    
+    # Set max agents override if provided
+    if max_agents is not None:
+        os.environ["MONOCO_MAX_AGENTS"] = str(max_agents)
+        print_output(
+            f"Max Agents: {max_agents}", title="Monoco Serve"
+        )
 
     print_output(
         f"Starting Monoco Daemon on http://{host}:{port}", title="Monoco Serve"