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

monoco/features/agent/cli.py

@@ -1,10 +1,12 @@
 import typer
 import time
+import asyncio
 from pathlib import Path
 from typing import Optional
 from monoco.core.output import print_output, print_error
 from monoco.core.config import get_config
-from monoco.features.agent import SessionManager, load_scheduler_config
+from monoco.features.agent import load_scheduler_config
+from monoco.core.scheduler import AgentTask, LocalProcessScheduler
 
 app = typer.Typer(name="agent", help="Manage agent sessions and roles")
 session_app = typer.Typer(name="session", help="Manage active agent sessions")
@@ -50,12 +52,10 @@ def list_providers():
     """
     from monoco.core.integrations import get_all_integrations
 
-    # Ideally we'd pass project-specific integrations here if they existed in config objects
     integrations = get_all_integrations(enabled_only=False)
 
     output = []
     for key, integration in integrations.items():
-        # Perform health check
         health = integration.check_health()
         status_icon = "✅" if health.available else "❌"
         
@@ -127,14 +127,9 @@ def run(
     full_prompt = " ".join(prompt) if prompt else ""
     
     if issue:
-        # User explicitly linked an issue
         issue_id = issue.upper()
         description = full_prompt or None
     else:
-        # Ad-hoc task check
-        import re
-        # Heuristic: if prompt looks like an ID and is short, maybe they meant ID?
-        # But explicit is better. Let's assume everything in prompt is instructions.
         issue_id = "NEW_TASK"
         description = full_prompt
 
@@ -156,13 +151,11 @@ def run(
     
     integration = get_integration(target_engine)
     
-    # If integration is found, check health
     is_available = False
     if integration:
         health = integration.check_health()
         is_available = health.available
         if not is_available and provider:
-            # If user explicitly requested this provider, fail hard
             print_error(f"Requested provider '{target_engine}' is not available.")
             print_error(f"Error: {health.error}")
             raise typer.Exit(code=1)
@@ -173,23 +166,18 @@ def run(
         
         all_integrations = get_all_integrations(enabled_only=True)
         fallback_found = None
-        
-        # Priority list for fallback
         priority = ["cursor", "claude", "gemini", "qwen", "kimi"]
         
-        # Try priority matches first
         for key in priority:
             if key in all_integrations:
                 if all_integrations[key].check_health().available:
                     fallback_found = key
                     break
         
-        # Determine strict fallback
         if fallback_found:
              print_output(f"🔄 Falling back to available provider: [bold green]{fallback_found}[/bold green]")
              selected_role.engine = fallback_found
         else:
-             # If NO CLI tools available, maybe generic agent?
              if "agent" in all_integrations:
                  print_output("🔄 Falling back to Generic Agent (No CLI execution).", style="yellow")
                  selected_role.engine = "agent"
@@ -198,7 +186,6 @@ def run(
                  print_error("Please install Cursor, Claude Code, or Gemini CLI.")
                  raise typer.Exit(code=1)
     elif provider:
-        # If available and user overrode it
         print_output(f"Overriding provider: {selected_role.engine} -> {provider}")
         selected_role.engine = provider
 
@@ -208,89 +195,136 @@ def run(
         title="Agent Framework",
     )
 
-    # 4. Initialize Session
-    manager = SessionManager()
-    session = manager.create_session(issue_id, selected_role)
+    # 4. Initialize AgentScheduler and schedule task
+    scheduler = LocalProcessScheduler(
+        max_concurrent=5,
+        project_root=project_root,
+    )
 
+    task = AgentTask(
+        task_id=f"cli-{issue_id}-{int(time.time())}",
+        role_name=selected_role.name,
+        issue_id=issue_id,
+        prompt=description or "Execute task",
+        engine=selected_role.engine,
+        timeout=selected_role.timeout or 900,
+        metadata={
+            "role_description": selected_role.description,
+            "role_goal": selected_role.goal,
+        },
+    )
 
     try:
-        # Pass description if it's a new task
-        context = {"description": description} if description else None
-        session.start(context=context)
+        # Run async scheduler in sync context
+        asyncio.run(scheduler.start())
+        session_id = asyncio.run(scheduler.schedule(task))
+        
+        print_output(f"Session {session_id} started.")
 
         if detach:
             print_output(
-                 f"Session {session.model.id} started in background (detached)."
+                 f"Session {session_id} running in background (detached)."
             )
             return
 
-        # Monitoring Loop
-        while session.refresh_status() == "running":
+        # Monitoring Loop - poll for task status
+        while True:
+            status = scheduler.get_task_status(session_id)
+            if status in ["completed", "failed", "crashed"]:
+                break
             time.sleep(1)
 
-        if session.model.status == "failed":
+        final_status = scheduler.get_task_status(session_id)
+        if final_status == "failed":
             print_error(
-                f"Session {session.model.id} FAILED. Review logs for details."
+                f"Session {session_id} FAILED. Review logs for details."
             )
         else:
             print_output(
-                f"Session finished with status: {session.model.status}",
+                f"Session finished with status: {final_status}",
                 title="Agent Framework",
             )
 
     except KeyboardInterrupt:
         print("\nStopping...")
-        session.terminate()
+        asyncio.run(scheduler.cancel_task(session_id))
         print_output("Session terminated.")
+    finally:
+        asyncio.run(scheduler.stop())
 
 
 @session_app.command(name="kill")
 def kill_session(session_id: str):
     """
     Terminate a specific session.
+    
+    Note: Uses AgentScheduler to cancel the task.
     """
-    manager = SessionManager()
-    session = manager.get_session(session_id)
-    if session:
-        session.terminate()
+    settings = get_config()
+    project_root = Path(settings.paths.root).resolve()
+    
+    scheduler = LocalProcessScheduler(
+        max_concurrent=5,
+        project_root=project_root,
+    )
+    
+    try:
+        asyncio.run(scheduler.start())
+        asyncio.run(scheduler.cancel_task(session_id))
         print_output(f"Session {session_id} terminated.")
-    else:
-        print_output(f"Session {session_id} not found.", style="red")
+    except Exception as e:
+        print_error(f"Failed to terminate session: {e}")
+    finally:
+        asyncio.run(scheduler.stop())
 
 
 @session_app.command(name="list")
 def list_sessions():
     """
     List active agent sessions.
+    
+    Note: Shows tasks from AgentScheduler.
     """
-    manager = SessionManager()
-    sessions = manager.list_sessions()
-
-    output = []
-    for s in sessions:
-        output.append(
-            {
-                "id": s.model.id,
-                "issue": s.model.issue_id,
-                "role": s.model.role_name,
-                "status": s.model.status,
-                "branch": s.model.branch_name,
-            }
-        )
-
-    print_output(
-        output
-        or "No active sessions found (Note: Persistence not implemented in CLI list yet).",
-        title="Active Sessions",
+    settings = get_config()
+    project_root = Path(settings.paths.root).resolve()
+    
+    scheduler = LocalProcessScheduler(
+        max_concurrent=5,
+        project_root=project_root,
     )
+    
+    try:
+        asyncio.run(scheduler.start())
+        stats = scheduler.get_stats()
+        
+        output = {
+            "scheduler_status": "running" if stats.get("running") else "stopped",
+            "active_tasks": stats.get("active_tasks", 0),
+            "completed_tasks": stats.get("completed_tasks", 0),
+            "failed_tasks": stats.get("failed_tasks", 0),
+        }
+
+        print_output(output, title="Agent Scheduler Status")
+    finally:
+        asyncio.run(scheduler.stop())
 
 
 @session_app.command(name="logs")
 def session_logs(session_id: str):
     """
     Stream logs for a session.
+    
+    Note: Logs are stored in .monoco/sessions/{session_id}.log
     """
+    settings = get_config()
+    project_root = Path(settings.paths.root).resolve()
+    log_path = project_root / ".monoco" / "sessions" / f"{session_id}.log"
+    
     print_output(f"Streaming logs for {session_id}...", title="Session Logs")
-    # Placeholder
-    print("[12:00:00] Session started")
-    print("[12:00:01] Worker initialized")
+    
+    if log_path.exists():
+        print(log_path.read_text())
+    else:
+        print(f"[12:00:00] Session {session_id} started")
+        print("[12:00:01] Worker initialized")
+        print("(Log file not found - showing placeholder)")

monoco/features/agent/engines.py

@@ -1,175 +1,36 @@
 """
 Agent Engine Adapters for Monoco Scheduler.
 
-This module provides a unified interface for different AI agent execution engines,
-allowing the Worker to seamlessly switch between Gemini, Claude, and future engines.
-"""
-
-from abc import ABC, abstractmethod
-from typing import List
-
-
-class EngineAdapter(ABC):
-    """
-    Abstract base class for agent engine adapters.
-
-    Each adapter is responsible for:
-    1. Constructing the correct CLI command for its engine
-    2. Handling engine-specific error scenarios
-    3. Providing metadata about the engine's capabilities
-    """
-
-    @abstractmethod
-    def build_command(self, prompt: str) -> List[str]:
-        """
-        Build the CLI command to execute the agent with the given prompt.
-
-        Args:
-            prompt: The instruction/context to send to the agent
-
-        Returns:
-            List of command arguments (e.g., ["gemini", "-y", "prompt text"])
-        """
-        pass
-
-    @property
-    @abstractmethod
-    def name(self) -> str:
-        """Return the canonical name of this engine."""
-        pass
-
-    @property
-    def supports_yolo_mode(self) -> bool:
-        """Whether this engine supports auto-approval mode."""
-        return False
-
-
-class GeminiAdapter(EngineAdapter):
-    """
-    Adapter for Google Gemini CLI.
-
-    Command format: gemini -p <prompt> -y
-    The -y flag enables "YOLO mode" (auto-approval of actions).
-    """
-
-    def build_command(self, prompt: str) -> List[str]:
-        # Based on Gemini CLI help: -p <prompt> for non-interactive
-        return ["gemini", "-p", prompt, "-y"]
-
-    @property
-    def name(self) -> str:
-        return "gemini"
-
-    @property
-    def supports_yolo_mode(self) -> bool:
-        return True
-
-
-class ClaudeAdapter(EngineAdapter):
-    """
-    Adapter for Anthropic Claude CLI.
-
-    Command format: claude -p <prompt>
-    The -p/--print flag enables non-interactive mode.
-    """
-
-    def build_command(self, prompt: str) -> List[str]:
-        # Based on Claude CLI help: -p <prompt> is NOT standard, usually -p means print/non-interactive.
-        # But for one-shot execution, we do passing prompt as argument with -p flag.
-        return ["claude", "-p", prompt]
-
-    @property
-    def name(self) -> str:
-        return "claude"
+DEPRECATED: This module has been moved to monoco.core.scheduler.
+This file is kept for backward compatibility and re-exports from the new location.
 
-    @property
-    def supports_yolo_mode(self) -> bool:
-        # Claude uses -p for non-interactive mode, similar concept
-        return True
-
-
-class QwenAdapter(EngineAdapter):
-    """
-    Adapter for Qwen Code CLI.
-
-    Command format: qwen -p <prompt> -y
-    """
-
-    def build_command(self, prompt: str) -> List[str]:
-        # Assuming Qwen follows similar patterns (based on user feedback)
-        return ["qwen", "-p", prompt, "-y"]
-
-    @property
-    def name(self) -> str:
-        return "qwen"
-
-    @property
-    def supports_yolo_mode(self) -> bool:
-        return True
-
-
-class KimiAdapter(EngineAdapter):
-    """
-    Adapter for Kimi CLI (Moonshot AI).
-
-    Command format: kimi -p <prompt> --print
-    Note: --print implicitly adds --yolo.
-    """
-
-    def build_command(self, prompt: str) -> List[str]:
-        # Based on Kimi CLI help: -p, --prompt TEXT.
-        # Also using --print for non-interactive mode (which enables yolo).
-        return ["kimi", "-p", prompt, "--print"]
-
-    @property
-    def name(self) -> str:
-        return "kimi"
-
-    @property
-    def supports_yolo_mode(self) -> bool:
-        return True
-
-
-class EngineFactory:
-    """
-    Factory for creating engine adapter instances.
-
-    Usage:
-        adapter = EngineFactory.create("gemini")
-        command = adapter.build_command("Write a test")
-    """
-
-    _adapters = {
-        "gemini": GeminiAdapter,
-        "claude": ClaudeAdapter,
-        "qwen": QwenAdapter,
-        "kimi": KimiAdapter,
-    }
-
-    @classmethod
-    def create(cls, engine_name: str) -> EngineAdapter:
-        """
-        Create an adapter instance for the specified engine.
-
-        Args:
-            engine_name: Name of the engine (e.g., "gemini", "claude")
-
-        Returns:
-            An instance of the appropriate EngineAdapter
-
-        Raises:
-            ValueError: If the engine is not supported
-        """
-        adapter_class = cls._adapters.get(engine_name.lower())
-        if not adapter_class:
-            supported = ", ".join(cls._adapters.keys())
-            raise ValueError(
-                f"Unsupported engine: '{engine_name}'. "
-                f"Supported engines: {supported}"
-            )
-        return adapter_class()
+Migration:
+    Old: from monoco.features.agent.engines import EngineAdapter, EngineFactory
+    New: from monoco.core.scheduler import EngineAdapter, EngineFactory
+"""
 
-    @classmethod
-    def supported_engines(cls) -> List[str]:
-        """Return a list of all supported engine names."""
-        return list(cls._adapters.keys())
+import warnings
+from monoco.core.scheduler import (
+    EngineAdapter,
+    EngineFactory,
+    GeminiAdapter,
+    ClaudeAdapter,
+    QwenAdapter,
+    KimiAdapter,
+)
+
+warnings.warn(
+    "monoco.features.agent.engines is deprecated. "
+    "Use monoco.core.scheduler instead.",
+    DeprecationWarning,
+    stacklevel=2
+)
+
+__all__ = [
+    "EngineAdapter",
+    "EngineFactory",
+    "GeminiAdapter",
+    "ClaudeAdapter",
+    "QwenAdapter",
+    "KimiAdapter",
+]

monoco/{core/resources/en/skills/monoco_core → features/agent/resources/en/skills/monoco_atom_core}/SKILL.md

@@ -1,7 +1,7 @@
 ---
-name: monoco-core
+name: monoco_atom_core
 description: Core skill for Monoco Toolkit. Provides essential commands for project initialization, configuration, and workspace management.
-type: standard
+type: atom
 version: 1.0.0
 ---
 

monoco/features/agent/resources/en/skills/{flow_engineer → monoco_workflow_agent_engineer}/SKILL.md

@@ -1,7 +1,7 @@
 ---
-name: flow-engineer
+name: monoco_workflow_agent_engineer
 description: Standardized workflow for the Engineer role (Flow Skill). Defines the standard operating procedure from requirement investigation to code submission, ensuring test coverage and code quality.
-type: flow
+type: workflow
 role: engineer
 version: 1.0.0
 ---

monoco/features/agent/resources/en/skills/{flow_manager → monoco_workflow_agent_manager}/SKILL.md

@@ -1,7 +1,7 @@
 ---
-name: flow-manager
+name: monoco_workflow_agent_manager
 description: Standardized workflow for the Manager role (Flow Skill). Defines the standard operating procedure from inbox organization to task assignment, ensuring clear requirements and reasonable task breakdown.
-type: flow
+type: workflow
 role: manager
 version: 1.0.0
 ---

monoco/features/agent/resources/en/skills/{flow_planner → monoco_workflow_agent_planner}/SKILL.md

@@ -1,7 +1,7 @@
 ---
-name: flow-planner
+name: monoco_workflow_agent_planner
 description: Standardized workflow for the Planner role (Flow Skill). Responsible for analysis, design, planning, and handoff.
-type: flow
+type: workflow
 role: planner
 version: 1.0.0
 ---

monoco/features/agent/resources/en/skills/{flow_reviewer → monoco_workflow_agent_reviewer}/SKILL.md

@@ -1,7 +1,7 @@
 ---
-name: flow-reviewer
+name: monoco_workflow_agent_reviewer
 description: Standardized workflow for the Reviewer role (Flow Skill). Defines the standard operating procedure from code checkout to adversarial testing to review completion, ensuring code quality and process compliance.
-type: flow
+type: workflow
 role: reviewer
 version: 1.0.0
 ---

monoco/features/agent/resources/{roles/role-engineer.yaml → zh/roles/monoco_role_engineer.yaml}

@@ -1,12 +1,12 @@
 ---
-name: role-engineer
+name: monoco_role_engineer
 type: role
-description: Engineer 角色 - 负责代码实现、测试和提交变更
+description: Engineer 角色 - 负责代码生成、测试和维护
 version: 1.0.0
 author: Monoco Toolkit
 
 # 默认工作流
-workflow: workflow-dev
+workflow: monoco_workflow_agent_engineer
 
 # 默认执行模式
 default_mode: autopilot

monoco/features/agent/resources/{roles/role-manager.yaml → zh/roles/monoco_role_manager.yaml}

@@ -1,26 +1,26 @@
 ---
-name: role-manager
+name: monoco_role_manager
 type: role
-description: Manager 角色 - 负责需求澄清、任务拆解和指派
+description: Manager 角色 - 负责 Issue 管理、进度跟踪和决策
 version: 1.0.0
 author: Monoco Toolkit
 
 # 默认工作流
-workflow: workflow-issue-create
+workflow: monoco_workflow_issue_creation
 
 # 默认执行模式
 default_mode: copilot
 
 # 触发条件
-trigger: "incoming.requirement"
+trigger: 'incoming.requirement'
 goal: 将模糊需求转化为清晰、可执行的任务
 
 # 角色偏好 / Mindset
 preferences:
-  - "5W2H: 使用 5W2H 分析法澄清需求"
-  - "Vertical Slicing: 垂直切片分解任务"
-  - "Clear Acceptance Criteria: 每个任务必须有清晰的验收标准"
-  - "No Unclear Assignment: 禁止指派没有澄清的需求给 Engineer"
+  - '5W2H: 使用 5W2H 分析法澄清需求'
+  - 'Vertical Slicing: 垂直切片分解任务'
+  - 'Clear Acceptance Criteria: 每个任务必须有清晰的验收标准'
+  - 'No Unclear Assignment: 禁止指派没有澄清的需求给 Engineer'
 
 # 系统提示
 system_prompt: |

monoco/features/agent/resources/{roles/role-planner.yaml → zh/roles/monoco_role_planner.yaml}

@@ -1,27 +1,27 @@
 ---
-name: role-planner
+name: monoco_role_planner
 type: role
 description: Planner 角色 - 负责架构设计、技术规划和交接
 version: 1.0.0
 author: Monoco Toolkit
 
 # 默认工作流
-workflow: workflow-dev
+workflow: monoco_workflow_agent_planner
 
 # 默认执行模式
 default_mode: copilot
 
 # 触发条件
-trigger: "issue.needs_refine"
+trigger: 'issue.needs_refine'
 goal: 产出清晰的架构设计和可执行的计划
 
 # 角色偏好 / Mindset
 preferences:
-  - "Evidence Based: 所有架构决策必须有代码或文档证据支持"
-  - "Incremental Design: 优先采用增量式设计，避免过度设计"
-  - "Clear Boundaries: 明确模块边界和接口契约"
-  - "Document First: 先写设计文档，再创建实现任务"
-  - "Review Loop: 复杂设计应经过 Review 后再交接"
+  - 'Evidence Based: 所有架构决策必须有代码或文档证据支持'
+  - 'Incremental Design: 优先采用增量式设计，避免过度设计'
+  - 'Clear Boundaries: 明确模块边界和接口契约'
+  - 'Document First: 先写设计文档，再创建实现任务'
+  - 'Review Loop: 复杂设计应经过 Review 后再交接'
 
 # 系统提示
 system_prompt: |

monoco/features/agent/resources/{roles/role-reviewer.yaml → zh/roles/monoco_role_reviewer.yaml}

@@ -1,26 +1,26 @@
 ---
-name: role-reviewer
+name: monoco_role_reviewer
 type: role
-description: Reviewer 角色 - 负责代码质量检查和对抗性测试
+description: Reviewer 角色 - 负责代码审计、架构合规检查和反馈
 version: 1.0.0
 author: Monoco Toolkit
 
 # 默认工作流
-workflow: workflow-review
+workflow: monoco_workflow_agent_reviewer
 
 # 默认执行模式
 default_mode: autopilot
 
 # 触发条件
-trigger: "issue.submitted"
+trigger: 'issue.submitted'
 goal: 确保代码质量和流程合规
 
 # 角色偏好 / Mindset
 preferences:
-  - "Double Defense: 双层防御体系 - Engineer 自证 (Verify) + Reviewer 对抗 (Challenge)"
-  - "Try to Break It: 尝试破坏代码，寻找边界情况"
-  - "No Approve Without Test: 禁止未经测试直接 Approve"
-  - "Challenge Tests: 保留有价值的 Challenge Tests 并提交到代码库"
+  - 'Double Defense: 双层防御体系 - Engineer 自证 (Verify) + Reviewer 对抗 (Challenge)'
+  - 'Try to Break It: 尝试破坏代码，寻找边界情况'
+  - 'No Approve Without Test: 禁止未经测试直接 Approve'
+  - 'Challenge Tests: 保留有价值的 Challenge Tests 并提交到代码库'
 
 # 系统提示
 system_prompt: |

monoco/{core/resources/zh/skills/monoco_core → features/agent/resources/zh/skills/monoco_atom_core}/SKILL.md

@@ -1,7 +1,7 @@
 ---
-name: monoco-core
+name: monoco_atom_core
 description: Monoco Toolkit 的核心技能。提供项目初始化、配置管理和工作空间管理的基础命令。
-type: standard
+type: atom
 version: 1.0.0
 ---
 

monoco/features/agent/resources/zh/skills/{flow_engineer → monoco_workflow_agent_engineer}/SKILL.md

@@ -1,7 +1,7 @@
 ---
-name: flow-engineer
+name: monoco_workflow_agent_engineer
 description: Engineer 角色的标准化工作流 (Flow Skill)。定义从需求调研到代码提交的标准操作流程，确保测试覆盖和代码质量。
-type: flow
+type: workflow
 role: engineer
 version: 1.0.0
 ---