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

monoco/core/sync.py

@@ -46,6 +46,12 @@ def sync_command(
         help="Specific file to update (default: auto-detect from config or standard files)",
     ),
     check: bool = typer.Option(False, "--check", help="Dry run check mode"),
+    workflows: bool = typer.Option(
+        False,
+        "--workflows",
+        "-w",
+        help="Also distribute Flow Skills as Antigravity Workflows to .agent/workflows/",
+    ),
 ):
     """
     Synchronize Agent Environment (System Prompts & Skills).
@@ -84,7 +90,39 @@ def sync_command(
         f"[blue]Collected {len(collected_prompts)} prompts from {len(active_features)} features.[/blue]"
     )
 
-    # 3. Distribute Skills
+
+
+    # 3. Distribute Roles
+    console.print("[bold blue]Distributing agent roles...[/bold blue]")
+    
+    # Source: Builtin Resource Dir
+    # monoco/core/sync.py -> monoco/core -> monoco -> features/agent/resources/roles
+    resource_dir = Path(__file__).parent.parent / "features" / "agent" / "resources" / "roles"
+    
+    # Target: .monoco/roles
+    target_roles_dir = root / ".monoco" / "roles"
+    # Only create if we have sources
+    if resource_dir.exists():
+        target_roles_dir.mkdir(parents=True, exist_ok=True)
+        import shutil
+        
+        count = 0
+        for yaml_file in resource_dir.glob("*.yaml"):
+            target_file = target_roles_dir / yaml_file.name
+            try:
+                # Copy only if different or new? For now, nice and simple overwrite.
+                shutil.copy2(yaml_file, target_file)
+                console.print(f"[dim]  ✓ Synced role {yaml_file.name}[/dim]")
+                count += 1
+            except Exception as e:
+                console.print(f"[red]  Failed to sync role {yaml_file.name}: {e}[/red]")
+        
+        if count > 0:
+             console.print(f"[green]  ✓ Updated {count} roles in .monoco/roles/[/green]")
+    else:
+        console.print("[yellow]  No builtin roles found to sync.[/yellow]")
+
+    # 4. Distribute Skills
     console.print("[bold blue]Distributing skills to agent frameworks...[/bold blue]")
 
     # Determine language from config
@@ -124,6 +162,26 @@ def sync_command(
             "[yellow]No agent frameworks detected. Skipping skill distribution.[/yellow]"
         )
 
+    # 5. Distribute Workflows (if --workflows flag is set)
+    if workflows:
+        console.print("[bold blue]Distributing Flow Skills as Workflows...[/bold blue]")
+        
+        try:
+            workflow_results = skill_manager.distribute_workflows(force=False, lang=skill_lang)
+            success_count = sum(1 for v in workflow_results.values() if v)
+            if workflow_results:
+                console.print(
+                    f"[green]  ✓ Distributed {success_count}/{len(workflow_results)} workflows to .agent/workflows/[/green]"
+                )
+            else:
+                console.print(
+                    "[yellow]  No Flow Skills found to convert[/yellow]"
+                )
+        except Exception as e:
+            console.print(
+                f"[red]  Failed to distribute workflows: {e}[/red]"
+            )
+
     # 4. Determine Targets
     targets = _get_targets(root, config, target)
 
@@ -238,3 +296,17 @@ def uninstall_command(
         console.print(
             "[yellow]No agent frameworks detected. Skipping skill cleanup.[/yellow]"
         )
+
+    # 3. Clean up Workflows
+    console.print("[bold blue]Cleaning up distributed workflows...[/bold blue]")
+    
+    try:
+        removed_count = skill_manager.cleanup_workflows()
+        if removed_count > 0:
+            console.print(
+                f"[green]  ✓ Removed {removed_count} workflows from .agent/workflows/[/green]"
+            )
+    except Exception as e:
+        console.print(
+            f"[red]  Failed to clean workflows: {e}[/red]"
+        )

monoco/core/workflow_converter.py

@@ -0,0 +1,420 @@
+"""
+Flow Skill to Antigravity Workflow Converter.
+
+This module converts Monoco Flow Skills to Antigravity Workflow format.
+
+Conversion Rules:
+1. Frontmatter: Only keep 'description', discard other fields (name, type, role, version, author)
+2. Filename: monoco_flow_engineer/SKILL.md -> flow-engineer.md
+3. Content: Remove Mermaid state diagrams, convert to simple step lists
+4. Output: .agent/workflows/ directory
+"""
+
+import re
+from pathlib import Path
+from typing import Optional, Tuple
+import yaml
+from rich.console import Console
+
+console = Console()
+
+
+class FlowSkillConverter:
+    """Converts Flow Skill files to Antigravity Workflow format."""
+
+    # Source directories to search for Flow Skills
+    SOURCE_PATTERNS = [
+        "monoco/features/agent/resources/{lang}/skills/flow_*/SKILL.md",
+        "monoco/features/*/resources/{lang}/skills/flow_*/SKILL.md",
+    ]
+
+    def __init__(self, root_dir: Path):
+        """
+        Initialize converter with project root directory.
+        
+        Args:
+            root_dir: Project root directory
+        """
+        self.root_dir = root_dir
+
+    def _is_flow_skill(self, skill_file: Path) -> bool:
+        """
+        Check if a SKILL.md file is a Flow Skill by reading its frontmatter.
+        
+        Args:
+            skill_file: Path to SKILL.md file
+            
+        Returns:
+            True if the skill is a Flow Skill (type == "flow")
+        """
+        try:
+            content = skill_file.read_text(encoding="utf-8")
+            if not content.startswith("---"):
+                return False
+            
+            parts = content.split("---", 2)
+            if len(parts) < 3:
+                return False
+            
+            frontmatter = yaml.safe_load(parts[1].strip()) or {}
+            return frontmatter.get("type") == "flow"
+        except Exception:
+            return False
+
+    def discover_flow_skills(self, lang: str = "zh") -> list[Path]:
+        """
+        Discover all Flow Skill files in the source directories.
+        
+        Flow Skills are discovered from monoco/features/*/resources/ directories,
+        not from the distributed .claude/skills/ directory.
+        
+        Args:
+            lang: Language code (default: "zh")
+            
+        Returns:
+            List of paths to Flow Skill SKILL.md files
+        """
+        flow_skills = []
+        seen_names = set()
+        
+        # Search in source directories
+        features_dir = self.root_dir / "monoco" / "features"
+        if features_dir.exists():
+            for feature_dir in features_dir.iterdir():
+                if not feature_dir.is_dir():
+                    continue
+                    
+                resources_dir = feature_dir / "resources" / lang / "skills"
+                if not resources_dir.exists():
+                    continue
+                
+                for skill_dir in resources_dir.iterdir():
+                    if not skill_dir.is_dir():
+                        continue
+                    
+                    skill_file = skill_dir / "SKILL.md"
+                    if skill_file.exists() and skill_dir.name not in seen_names:
+                        # Check if it's a flow skill by reading frontmatter
+                        if self._is_flow_skill(skill_file):
+                            flow_skills.append(skill_file)
+                            seen_names.add(skill_dir.name)
+        
+        return sorted(flow_skills)
+
+    def convert_skill(self, skill_file: Path) -> Tuple[str, str]:
+        """
+        Convert a Flow Skill file to Antigravity Workflow format.
+        
+        Args:
+            skill_file: Path to the Flow Skill SKILL.md file
+            
+        Returns:
+            Tuple of (workflow_filename, workflow_content)
+        """
+        content = skill_file.read_text(encoding="utf-8")
+        
+        # Parse frontmatter
+        frontmatter, body = self._extract_frontmatter(content)
+        
+        # Convert frontmatter (keep only description)
+        new_frontmatter = self._convert_frontmatter(frontmatter)
+        
+        # Convert body content
+        new_body = self._convert_body(body)
+        
+        # Generate workflow filename
+        workflow_filename = self._generate_filename(skill_file)
+        
+        # Combine
+        if new_frontmatter:
+            workflow_content = f"---\n{new_frontmatter}---\n\n{new_body}"
+        else:
+            workflow_content = new_body
+        
+        return workflow_filename, workflow_content
+
+    def _extract_frontmatter(self, content: str) -> Tuple[dict, str]:
+        """
+        Extract YAML frontmatter from markdown content.
+        
+        Args:
+            content: Full markdown content
+            
+        Returns:
+            Tuple of (frontmatter_dict, body_content)
+        """
+        if not content.startswith("---"):
+            return {}, content
+        
+        parts = content.split("---", 2)
+        if len(parts) < 3:
+            return {}, content
+        
+        try:
+            frontmatter = yaml.safe_load(parts[1].strip()) or {}
+        except yaml.YAMLError:
+            frontmatter = {}
+        
+        body = parts[2].strip()
+        return frontmatter, body
+
+    def _convert_frontmatter(self, frontmatter: dict) -> str:
+        """
+        Convert frontmatter to Antigravity Workflow format.
+        
+        Only keeps 'description' field.
+        
+        Args:
+            frontmatter: Original frontmatter dictionary
+            
+        Returns:
+            New frontmatter as YAML string
+        """
+        description = frontmatter.get("description", "")
+        
+        if not description:
+            return ""
+        
+        # Create minimal frontmatter with only description
+        new_frontmatter = {"description": description}
+        
+        return yaml.dump(new_frontmatter, allow_unicode=True, sort_keys=False)
+
+    def _convert_body(self, body: str) -> str:
+        """
+        Convert body content to Antigravity Workflow format.
+        
+        - Remove Mermaid state diagrams
+        - Keep step sections but simplify
+        - Remove complex formatting
+        
+        Args:
+            body: Original body content
+            
+        Returns:
+            Converted body content
+        """
+        lines = body.split("\n")
+        result_lines = []
+        in_mermaid = False
+        skip_section = False
+        
+        for line in lines:
+            # Detect Mermaid code block start
+            if line.strip().startswith("```mermaid"):
+                in_mermaid = True
+                continue
+            
+            # Detect Mermaid code block end
+            if in_mermaid and line.strip() == "```":
+                in_mermaid = False
+                continue
+            
+            # Skip lines inside Mermaid block
+            if in_mermaid:
+                continue
+            
+            # Skip "工作流状态机" section header
+            if "工作流状态机" in line or "Workflow State Machine" in line:
+                skip_section = True
+                continue
+            
+            # Detect new section (level 2 header)
+            if line.strip().startswith("## ") and skip_section:
+                skip_section = False
+            
+            if skip_section:
+                continue
+            
+            # Keep the line
+            result_lines.append(line)
+        
+        # Clean up excessive blank lines
+        cleaned_lines = self._cleanup_blank_lines(result_lines)
+        
+        return "\n".join(cleaned_lines)
+
+    def _cleanup_blank_lines(self, lines: list[str]) -> list[str]:
+        """
+        Clean up excessive blank lines while preserving structure.
+        
+        Args:
+            lines: List of content lines
+            
+        Returns:
+            Cleaned list of lines
+        """
+        result = []
+        prev_blank = False
+        
+        for line in lines:
+            is_blank = not line.strip()
+            
+            # Skip consecutive blank lines
+            if is_blank and prev_blank:
+                continue
+            
+            result.append(line)
+            prev_blank = is_blank
+        
+        # Remove trailing blank lines
+        while result and not result[-1].strip():
+            result.pop()
+        
+        return result
+
+    def _generate_filename(self, skill_file: Path) -> str:
+        """
+        Generate workflow filename from skill file path.
+        
+        Conversion: flow_engineer/SKILL.md -> flow-engineer.md
+        
+        Args:
+            skill_file: Path to the Flow Skill SKILL.md file
+            
+        Returns:
+            Workflow filename
+        """
+        # Get parent directory name (e.g., "flow_engineer")
+        skill_dir_name = skill_file.parent.name
+        
+        # Remove "flow_" prefix
+        if skill_dir_name.startswith("flow_"):
+            role_name = skill_dir_name[len("flow_"):]
+        else:
+            role_name = skill_dir_name
+        
+        # Convert to workflow filename
+        workflow_filename = f"flow-{role_name}.md"
+        
+        return workflow_filename
+
+
+class WorkflowDistributor:
+    """Distributes converted workflows to target directory."""
+
+    def __init__(self, root_dir: Path):
+        """
+        Initialize distributor.
+        
+        Args:
+            root_dir: Project root directory
+        """
+        self.root_dir = root_dir
+        self.converter = FlowSkillConverter(root_dir)
+
+    def distribute(self, force: bool = False, lang: str = "zh") -> dict[str, bool]:
+        """
+        Convert and distribute all Flow Skills to .agent/workflows/.
+        
+        Args:
+            force: Overwrite existing files even if unchanged
+            lang: Language code for Flow Skills (default: "zh")
+            
+        Returns:
+            Dictionary mapping workflow filenames to success status
+        """
+        results = {}
+        
+        # Discover flow skills
+        flow_skills = self.converter.discover_flow_skills(lang=lang)
+        
+        if not flow_skills:
+            console.print("[yellow]No Flow Skills found to convert[/yellow]")
+            return results
+        
+        # Target directory
+        workflows_dir = self.root_dir / ".agent" / "workflows"
+        workflows_dir.mkdir(parents=True, exist_ok=True)
+        
+        console.print(f"[dim]Found {len(flow_skills)} Flow Skills to convert[/dim]")
+        
+        for skill_file in flow_skills:
+            try:
+                workflow_filename, workflow_content = self.converter.convert_skill(skill_file)
+                target_file = workflows_dir / workflow_filename
+                
+                # Check if update is needed
+                if target_file.exists() and not force:
+                    existing_content = target_file.read_text(encoding="utf-8")
+                    if existing_content == workflow_content:
+                        console.print(f"[dim]  = {workflow_filename} is up to date[/dim]")
+                        results[workflow_filename] = True
+                        continue
+                
+                # Write workflow file
+                target_file.write_text(workflow_content, encoding="utf-8")
+                console.print(f"[green]  ✓ Created {workflow_filename}[/green]")
+                results[workflow_filename] = True
+                
+            except Exception as e:
+                console.print(f"[red]  ✗ Failed to convert {skill_file.name}: {e}[/red]")
+                results[skill_file.name] = False
+        
+        return results
+
+    def cleanup(self, lang: str = "zh") -> int:
+        """
+        Remove all distributed workflows from .agent/workflows/.
+        
+        Args:
+            lang: Language code for Flow Skills (default: "zh")
+            
+        Returns:
+            Number of files removed
+        """
+        workflows_dir = self.root_dir / ".agent" / "workflows"
+        
+        if not workflows_dir.exists():
+            return 0
+        
+        removed_count = 0
+        
+        # Discover flow skills to know which files to remove
+        flow_skills = self.converter.discover_flow_skills(lang=lang)
+        workflow_filenames = set()
+        
+        for skill_file in flow_skills:
+            workflow_filename = self.converter._generate_filename(skill_file)
+            workflow_filenames.add(workflow_filename)
+        
+        # Remove workflow files
+        for workflow_file in workflows_dir.glob("flow-*.md"):
+            if workflow_file.name in workflow_filenames:
+                workflow_file.unlink()
+                console.print(f"[green]  ✓ Removed {workflow_file.name}[/green]")
+                removed_count += 1
+        
+        # Remove empty directory
+        if workflows_dir.exists() and not any(workflows_dir.iterdir()):
+            workflows_dir.rmdir()
+            console.print(f"[dim]  Removed empty directory: {workflows_dir}[/dim]")
+        
+        if removed_count == 0:
+            console.print(f"[dim]No workflows to remove from {workflows_dir}[/dim]")
+        
+        return removed_count
+
+
+def convert_flow_skill_to_workflow(skill_content: str) -> str:
+    """
+    Convert Flow Skill content to Antigravity Workflow format.
+    
+    This is a standalone utility function for direct content conversion.
+    
+    Args:
+        skill_content: Original Flow Skill markdown content
+        
+    Returns:
+        Converted Workflow markdown content
+    """
+    converter = FlowSkillConverter(Path("."))
+    
+    frontmatter, body = converter._extract_frontmatter(skill_content)
+    new_frontmatter = converter._convert_frontmatter(frontmatter)
+    new_body = converter._convert_body(body)
+    
+    if new_frontmatter:
+        return f"---\n{new_frontmatter}---\n\n{new_body}"
+    else:
+        return new_body

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"