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

monoco/features/{scheduler → agent}/__init__.py

@@ -1,6 +1,6 @@
-from .models import RoleTemplate, SchedulerConfig
+from .models import RoleTemplate, AgentConfig, SchedulerConfig
 from .worker import Worker
-from .config import load_scheduler_config
+from .config import load_scheduler_config, load_agent_config
 from .defaults import DEFAULT_ROLES
 from .session import Session, RuntimeSession
 from .manager import SessionManager
@@ -8,7 +8,9 @@ from .reliability import ApoptosisManager
 
 __all__ = [
     "RoleTemplate",
+    "AgentConfig",
     "SchedulerConfig",
+    "load_agent_config",
     "Worker",
     "load_scheduler_config",
     "DEFAULT_ROLES",

monoco/features/{scheduler → agent}/cli.py

@@ -4,10 +4,16 @@ from pathlib import Path
 from typing import Optional
 from monoco.core.output import print_output
 from monoco.core.config import get_config
-from monoco.features.scheduler import SessionManager, load_scheduler_config
+from monoco.features.agent import SessionManager, load_scheduler_config
 
-app = typer.Typer(name="agent", help="Manage agent sessions")
-role_app = typer.Typer(name="role", help="Manage agent roles")
+app = typer.Typer(name="agent", help="Manage agent sessions and roles")
+session_app = typer.Typer(name="session", help="Manage active agent sessions")
+role_app = typer.Typer(name="role", help="Manage agent roles (CRUD)")
+provider_app = typer.Typer(name="provider", help="Manage agent providers (Engines)")
+
+app.add_typer(session_app, name="session")
+app.add_typer(role_app, name="role")
+app.add_typer(provider_app, name="provider")
 
 
 @role_app.command(name="list")
@@ -15,7 +21,7 @@ def list_roles():
     """
     List available agent roles and their sources.
     """
-    from monoco.features.scheduler.config import RoleLoader
+    from monoco.features.agent.config import RoleLoader
 
     settings = get_config()
     project_root = Path(settings.paths.root).resolve()
@@ -37,70 +43,67 @@ def list_roles():
     print_output(output, title="Agent Roles")
 
 
-@app.command()
-def draft(
-    desc: str = typer.Option(..., "--desc", "-d", help="Description of the task"),
-    type: str = typer.Option(
-        "feature", "--type", "-t", help="Issue type (feature/chore/fix)"
-    ),
-):
+@provider_app.command(name="list")
+def list_providers():
     """
-    Draft a new issue based on a natural language description.
-    This creates a temporary 'drafter' agent session.
+    List available agent providers and their status.
     """
-    from monoco.core.output import print_error
+    from monoco.core.integrations import get_all_integrations
 
     settings = get_config()
-    project_root = Path(settings.paths.root).resolve()
-
-    # Load Roles
-    roles = load_scheduler_config(project_root)
-    # Use 'crafter' as the role for drafting (it handles new tasks)
-    role_name = "crafter"
-    selected_role = roles.get(role_name)
-
-    if not selected_role:
-        print_error(f"Role '{role_name}' not found.")
-        raise typer.Exit(code=1)
+    # Ideally we'd pass project-specific integrations here if they existed in config objects
+    integrations = get_all_integrations(enabled_only=False)
 
-    print_output(
-        f"Drafting {type} from description: '{desc}'",
-        title="Agent Drafter",
-    )
+    output = []
+    for key, integration in integrations.items():
+        output.append(
+            {
+                "key": key,
+                "name": integration.name,
+                "binary": integration.bin_name or "-",
+                "enabled": integration.enabled,
+                "rules": integration.system_prompt_file,
+            }
+        )
 
-    manager = SessionManager()
-    # We use a placeholder ID as we don't know the ID yet.
-    # The agent is expected to create the file, so the ID will be generated then.
-    session = manager.create_session("NEW_TASK", selected_role)
+    print_output(output, title="Agent Providers")
 
-    context = {"description": desc, "type": type}
 
-    try:
-        session.start(context=context)
+@provider_app.command(name="check")
+def check_providers():
+    """
+    Run health checks on available providers.
+    """
+    from monoco.core.integrations import get_all_integrations
 
-        # Monitoring Loop
-        while session.refresh_status() == "running":
-            time.sleep(1)
+    integrations = get_all_integrations(enabled_only=True)
 
-        if session.model.status == "failed":
-            print_error("Drafting failed.")
-        else:
-            print_output("Drafting completed.", title="Agent Drafter")
+    output = []
+    for key, integration in integrations.items():
+        health = integration.check_health()
+        output.append(
+            {
+                "provider": integration.name,
+                "available": "✅" if health.available else "❌",
+                "latency": f"{health.latency_ms}ms" if health.latency_ms else "-",
+                "error": health.error or "-",
+            }
+        )
 
-    except KeyboardInterrupt:
-        print("\nStopping...")
-        session.terminate()
-        print_output("Drafting cancelled.")
+    print_output(output, title="Provider Health Check")
 
 
 @app.command()
 def run(
-    target: str = typer.Argument(
-        ..., help="Issue ID (e.g. FEAT-101) or a Task Description in quotes."
+    target: Optional[str] = typer.Argument(
+        None, help="Issue ID (e.g. FEAT-101) or a Task Description in quotes."
     ),
     role: Optional[str] = typer.Option(
         None,
-        help="Specific role to use (crafter/builder/auditor). Default: intelligent selection.",
+        help="Specific role to use (Planner/Builder/Reviewer). Default: intelligent selection.",
+    ),
+    type: str = typer.Option(
+        "feature", "--type", "-t", help="Issue type for new tasks (feature/chore/fix)."
     ),
     detach: bool = typer.Option(
         False, "--detach", "-d", help="Run in background (Daemon)"
@@ -111,11 +114,19 @@ def run(
 ):
     """
     Start an agent session.
-    - If TARGET is an Issue ID: Work on that issue.
-    - If TARGET is a text description: Create a new issue (Crafter).
+
+    If TARGET is an Issue ID, it starts a session for that issue.
+    If TARGET is a description, it starts a 'Planner' session to draft a new issue.
     """
-    settings = get_config()
-    project_root = Path(settings.paths.root).resolve()
+    from monoco.core.output import print_error
+
+    # Normal run mode - target is required
+    if not target:
+        from monoco.core.output import print_error
+
+        print_error("TARGET (Issue ID or Task Description) is required.")
+        raise typer.Exit(code=1)
+        raise typer.Exit(code=1)
 
     # 1. Smart Intent Recognition
     import re
@@ -124,12 +135,12 @@ def run(
 
     if is_id:
         issue_id = target.upper()
-        role_name = role or "builder"
+        role_name = role or "Builder"
         description = None
     else:
-        # Implicit Draft Mode via run command
+        # Implicit Draft Mode via run command (target is description)
         issue_id = "NEW_TASK"
-        role_name = role or "crafter"
+        role_name = role or "Planner"
         description = target
 
     # 2. Load Roles
@@ -137,8 +148,6 @@ def run(
     selected_role = roles.get(role_name)
 
     if not selected_role:
-        from monoco.core.output import print_error
-
         print_error(f"Role '{role_name}' not found. Available: {list(roles.keys())}")
         raise typer.Exit(code=1)
 
@@ -173,10 +182,8 @@ def run(
             time.sleep(1)
 
         if session.model.status == "failed":
-            from monoco.core.output import print_error
-
             print_error(
-                f"Session {session.model.id} FAILED. Use 'monoco agent autopsy {session.model.id}' for analysis."
+                f"Session {session.model.id} FAILED. Use 'monoco agent session autopsy {session.model.id}' for analysis."
             )
         else:
             print_output(
@@ -190,10 +197,10 @@ def run(
         print_output("Session terminated.")
 
 
-@app.command()
-def kill(session_id: str):
+@session_app.command(name="kill")
+def kill_session(session_id: str):
     """
-    Terminate a session.
+    Terminate a specific session.
     """
     manager = SessionManager()
     session = manager.get_session(session_id)
@@ -204,14 +211,16 @@ def kill(session_id: str):
         print_output(f"Session {session_id} not found.", style="red")
 
 
-@app.command()
-def autopsy(
-    target: str = typer.Argument(..., help="Session ID or Issue ID to analyze."),
-):
-    """
-    Execute Post-Mortem analysis on a failed session or target Issue.
-    """
+@session_app.command(name="autopsy")
+def autopsy_command(target: str):
+    """Execute Post-Mortem analysis on a failed session or target Issue."""
+    _run_autopsy(target)
+
+
+def _run_autopsy(target: str):
+    """Execute Post-Mortem analysis on a failed session or target Issue."""
     from .reliability import ApoptosisManager
+    from monoco.core.output import print_error
 
     manager = SessionManager()
 
@@ -229,25 +238,70 @@ def autopsy(
             settings = get_config()
             project_root = Path(settings.paths.root).resolve()
             roles = load_scheduler_config(project_root)
-            builder_role = roles.get("builder")
+            builder_role = roles.get("Builder")
 
             if not builder_role:
-                print_output("Builder role not found.", style="red")
+                print_error("Builder role not found.")
                 raise typer.Exit(code=1)
 
             session = manager.create_session(target.upper(), builder_role)
             session.model.status = "failed"
         else:
-            print_output(
-                f"Could not find session or valid Issue ID for '{target}'", style="red"
-            )
+            print_error(f"Could not find session or valid Issue ID for '{target}'")
             raise typer.Exit(code=1)
 
     apoptosis = ApoptosisManager(manager)
     apoptosis.trigger_apoptosis(session.model.id)
 
 
-@app.command(name="list")
+def _run_draft(desc: str, type: str, detach: bool):
+    """Draft a new issue based on a natural language description."""
+    from monoco.core.output import print_error
+
+    settings = get_config()
+    project_root = Path(settings.paths.root).resolve()
+
+    # Load Roles
+    roles = load_scheduler_config(project_root)
+    # Use 'Planner' as the role for drafting (it handles new tasks)
+    role_name = "Planner"
+    selected_role = roles.get(role_name)
+
+    if not selected_role:
+        print_error(f"Role '{role_name}' not found.")
+        raise typer.Exit(code=1)
+
+    print_output(
+        f"Drafting {type} from description: '{desc}'",
+        title="Agent Drafter",
+    )
+
+    manager = SessionManager()
+    # We use a placeholder ID as we don't know the ID yet.
+    # The agent is expected to create the file, so the ID will be generated then.
+    session = manager.create_session("NEW_TASK", selected_role)
+
+    context = {"description": desc, "type": type}
+
+    try:
+        session.start(context=context)
+
+        # Monitoring Loop
+        while session.refresh_status() == "running":
+            time.sleep(1)
+
+        if session.model.status == "failed":
+            print_error("Drafting failed.")
+        else:
+            print_output("Drafting completed.", title="Agent Drafter")
+
+    except KeyboardInterrupt:
+        print("\nStopping...")
+        session.terminate()
+        print_output("Drafting cancelled.")
+
+
+@session_app.command(name="list")
 def list_sessions():
     """
     List active agent sessions.
@@ -274,8 +328,8 @@ def list_sessions():
     )
 
 
-@app.command()
-def logs(session_id: str):
+@session_app.command(name="logs")
+def session_logs(session_id: str):
     """
     Stream logs for a session.
     """

monoco/features/{scheduler → agent}/config.py

@@ -1,7 +1,7 @@
 from typing import Dict, Optional
 import yaml
 from pathlib import Path
-from .models import RoleTemplate, SchedulerConfig
+from .models import RoleTemplate, AgentConfig
 from .defaults import DEFAULT_ROLES
 
 
@@ -45,8 +45,8 @@ class RoleLoader:
                 data = yaml.safe_load(f) or {}
 
             if "roles" in data:
-                # Validate using SchedulerConfig
-                config = SchedulerConfig(roles=data["roles"])
+                # Validate using AgentConfig
+                config = AgentConfig(roles=data["roles"])
                 for role in config.roles:
                     # Level 3 > Level 2 > Level 1 (名字相同的 Role 进行覆盖/Merge)
                     # Currently we do total replacement for same-named roles
@@ -66,3 +66,17 @@ def load_scheduler_config(project_root: Path) -> Dict[str, RoleTemplate]:
     """
     loader = RoleLoader(project_root)
     return loader.load_all()
+
+
+def load_agent_config(project_root: Path) -> Dict[str, RoleTemplate]:
+    """
+    Load agent configuration from tiered sources.
+    
+    Args:
+        project_root: Path to the project root directory
+        
+    Returns:
+        Dictionary mapping role names to RoleTemplate objects
+    """
+    loader = RoleLoader(project_root)
+    return loader.load_all()

monoco/features/agent/defaults.py

@@ -0,0 +1,55 @@
+from .models import RoleTemplate
+
+DEFAULT_ROLES = [
+    RoleTemplate(
+        name="Planner",
+        description="Responsible for requirement analysis, design documents, and issue drafting.",
+        trigger="task.received",
+        goal="Produce a structured design document or issue ticket.",
+        system_prompt=(
+            "You are a Planner agent. Your goal is to transform requirements into structured plans.\n"
+            "Analyze the workspace context and produce detailed issue tickets or design documents."
+        ),
+        engine="gemini",
+    ),
+    RoleTemplate(
+        name="Builder",
+        description="Responsible for implementing code and tests based on the design.",
+        trigger="design.approved",
+        goal="Implement functional code and passing tests.",
+        system_prompt="You are a Builder agent. Your job is to implement the solution as specified in the issue.",
+        engine="gemini",
+    ),
+    RoleTemplate(
+        name="Reviewer",
+        description="Responsible for code quality, architectural consistency, and linting.",
+        trigger="implementation.submitted",
+        goal="Provide critical feedback and approve or reject submissions.",
+        system_prompt="You are a Reviewer agent. Analyze code changes for bugs, style, and correctness.",
+        engine="gemini",
+    ),
+    RoleTemplate(
+        name="Merger",
+        description="Responsible for branch management and merging verified changes into trunk.",
+        trigger="review.passed",
+        goal="Safely merge feature branches and prune resources.",
+        system_prompt="You are a Merger agent. Handle the final integration of features and clean up environment.",
+        engine="gemini",
+    ),
+    RoleTemplate(
+        name="Coroner",
+        description="Responsible for post-mortem analysis and root cause identification on failure.",
+        trigger="session.crashed",
+        goal="Generate a detailed autopsy report.",
+        system_prompt="You are a Coroner agent. Analyze the failure state and generate a ## Post-mortem report.",
+        engine="gemini",
+    ),
+    RoleTemplate(
+        name="Manager",
+        description="The central orchestrator that processes memos and schedules other roles.",
+        trigger="daily.check / memo.added",
+        goal="Orchestrate the development workflow and manage team priorities.",
+        system_prompt="You are the Manager agent. You act as the scheduler and coordinator for the entire agentic system.",
+        engine="gemini",
+    ),
+]