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

monoco/features/agent/cli.py

@@ -0,0 +1,296 @@
+import typer
+import time
+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
+
+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")
+def list_roles():
+    """
+    List available agent roles and their sources.
+    """
+    from monoco.features.agent.config import RoleLoader
+
+    settings = get_config()
+    project_root = Path(settings.paths.root).resolve()
+
+    loader = RoleLoader(project_root)
+    roles = loader.load_all()
+
+    output = []
+    for name, role in roles.items():
+        output.append(
+            {
+                "role": name,
+                "engine": role.engine,
+                "source": loader.sources.get(name, "unknown"),
+                "description": role.description,
+            }
+        )
+
+    print_output(output, title="Agent Roles")
+
+
+@provider_app.command(name="list")
+def list_providers():
+    """
+    List available agent providers and their status.
+    """
+    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 "❌"
+        
+        output.append(
+            {
+                "key": key,
+                "name": integration.name,
+                "status": status_icon,
+                "binary": integration.bin_name or "-",
+                "enabled": integration.enabled,
+                "rules": integration.system_prompt_file,
+            }
+        )
+
+    print_output(output, title="Agent Providers")
+
+
+@provider_app.command(name="check")
+def check_providers():
+    """
+    Run health checks on available providers.
+    """
+    from monoco.core.integrations import get_all_integrations
+
+    integrations = get_all_integrations(enabled_only=True)
+
+    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 "-",
+            }
+        )
+
+    print_output(output, title="Provider Health Check")
+
+
+@app.command()
+def run(
+    prompt: Optional[list[str]] = typer.Argument(None, help="Instructions for the agent (e.g. 'Fix the bug')."),
+    issue: Optional[str] = typer.Option(
+        None, "--issue", "-i", help="Link to a specific Issue ID (e.g. FEAT-101)."
+    ),
+    role: str = typer.Option(
+        "Default", "--role", "-r", help="Specific role to use."
+    ),
+    detach: bool = typer.Option(
+        False, "--detach", "-d", help="Run in background (Daemon)"
+    ),
+    provider: Optional[str] = typer.Option(
+        None, "--provider", "-p", help="Override the default engine/provider for this session."
+    ),
+):
+    """
+    Start an agent session.
+
+    Usage:
+      monoco agent run "Check memos"
+      monoco agent run -i FEAT-101 "Implement feature"
+    """
+    settings = get_config()
+    project_root = Path(settings.paths.root).resolve()
+    
+    # 1. Resolve Inputs
+    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
+
+    if not description and not issue:
+        print_error("Please provide either a PROMPT or an --issue ID.")
+        raise typer.Exit(code=1)
+
+    # 2. Load Roles
+    roles = load_scheduler_config(project_root)
+    selected_role = roles.get(role)
+
+    if not selected_role:
+        print_error(f"Role '{role}' not found. Available: {list(roles.keys())}")
+        raise typer.Exit(code=1)
+
+    # 3. Provider Override & Fallback Logic
+    target_engine = provider or selected_role.engine
+    from monoco.core.integrations import get_integration, get_all_integrations
+    
+    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)
+            
+    # Auto-fallback if default provider is unavailable
+    if not is_available:
+        print_output(f"⚠️  Provider '{target_engine}' is not available. Searching for fallback...", style="yellow")
+        
+        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"
+             else:
+                 print_error("❌ No available agent providers found on this system.")
+                 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
+
+    display_target = issue if issue else (full_prompt[:50] + "..." if len(full_prompt) > 50 else full_prompt)
+    print_output(
+        f"Starting Agent Session for '{display_target}' as {role} (via {selected_role.engine})...",
+        title="Agent Framework",
+    )
+
+    # 4. Initialize Session
+    manager = SessionManager()
+    session = manager.create_session(issue_id, selected_role)
+
+
+    try:
+        # Pass description if it's a new task
+        context = {"description": description} if description else None
+        session.start(context=context)
+
+        if detach:
+            print_output(
+                 f"Session {session.model.id} started in background (detached)."
+            )
+            return
+
+        # Monitoring Loop
+        while session.refresh_status() == "running":
+            time.sleep(1)
+
+        if session.model.status == "failed":
+            print_error(
+                f"Session {session.model.id} FAILED. Review logs for details."
+            )
+        else:
+            print_output(
+                f"Session finished with status: {session.model.status}",
+                title="Agent Framework",
+            )
+
+    except KeyboardInterrupt:
+        print("\nStopping...")
+        session.terminate()
+        print_output("Session terminated.")
+
+
+@session_app.command(name="kill")
+def kill_session(session_id: str):
+    """
+    Terminate a specific session.
+    """
+    manager = SessionManager()
+    session = manager.get_session(session_id)
+    if session:
+        session.terminate()
+        print_output(f"Session {session_id} terminated.")
+    else:
+        print_output(f"Session {session_id} not found.", style="red")
+
+
+@session_app.command(name="list")
+def list_sessions():
+    """
+    List active agent sessions.
+    """
+    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",
+    )
+
+
+@session_app.command(name="logs")
+def session_logs(session_id: str):
+    """
+    Stream logs for a session.
+    """
+    print_output(f"Streaming logs for {session_id}...", title="Session Logs")
+    # Placeholder
+    print("[12:00:00] Session started")
+    print("[12:00:01] Worker initialized")

monoco/features/agent/config.py

@@ -0,0 +1,96 @@
+from typing import Dict, Optional
+import yaml
+from pathlib import Path
+from .models import RoleTemplate, AgentRoleConfig as AgentConfig
+from .defaults import DEFAULT_ROLES
+
+
+class RoleLoader:
+    """
+    Tiered configuration loader for Agent Roles.
+    Level 1: Builtin Resources (monoco/features/agent/resources/roles/*.yaml)
+    Level 2: Global (~/.monoco/roles/*.yaml)
+    Level 3: Project (./.monoco/roles/*.yaml)
+    """
+
+    def __init__(self, project_root: Optional[Path] = None):
+        self.project_root = project_root
+        self.user_home = Path.home()
+        self.roles: Dict[str, RoleTemplate] = {}
+        self.sources: Dict[str, str] = {}  # role_name -> source description
+
+    def load_all(self) -> Dict[str, RoleTemplate]:
+        # Level 1: Defaults (Hardcoded)
+        for role in DEFAULT_ROLES:
+            if role.name not in self.roles:
+                self.roles[role.name] = role
+                self.sources[role.name] = "builtin (default)"
+
+        # Level 2: Global
+        global_monoco = self.user_home / ".monoco"
+        self._load_from_file(global_monoco / "roles.yaml", "global")
+        self._load_from_dir(global_monoco / "roles", "global")
+
+        # Level 3: Project
+        if self.project_root:
+            project_monoco = self.project_root / ".monoco"
+            self._load_from_file(project_monoco / "roles.yaml", "project")
+            self._load_from_dir(project_monoco / "roles", "project")
+
+        return self.roles
+
+    def _load_from_dir(self, directory: Path, source_label: str):
+        if not directory.exists() or not directory.is_dir():
+            return
+        
+        for file in directory.glob("*.yaml"):
+            self._load_from_file(file, source_label)
+
+    def _load_from_file(self, path: Path, source_label: str):
+        if not path.exists():
+            return
+
+        try:
+            with open(path, "r") as f:
+                data = yaml.safe_load(f) or {}
+
+            # Case A: Config object with "roles" list
+            if "roles" in data and isinstance(data["roles"], list):
+                config = AgentConfig(roles=data["roles"])
+                for role in config.roles:
+                    self._upsert_role(role, str(path))
+            
+            # Case B: Single Role object
+            elif "name" in data and "system_prompt" in data:
+                role = RoleTemplate(**data)
+                self._upsert_role(role, str(path))
+                
+        except Exception as e:
+            import sys
+            print(f"Warning: Failed to load roles from {path}: {e}", file=sys.stderr)
+
+    def _upsert_role(self, role: RoleTemplate, source: str):
+        self.roles[role.name] = role
+        self.sources[role.name] = source
+
+
+def load_scheduler_config(project_root: Path) -> Dict[str, RoleTemplate]:
+    """
+    Legacy compatibility wrapper for functional access.
+    """
+    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,12 @@
+from .models import RoleTemplate
+
+DEFAULT_ROLES = [
+    RoleTemplate(
+        name="Default",
+        description="A generic, jack-of-all-trades agent used when no specific role is configured.",
+        trigger="task.dispatch",
+        goal="Complete the assigned task.",
+        system_prompt="You are a helpful Agent. Complete the task assigned to you.",
+        engine="gemini",
+    )
+]

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

@@ -48,12 +48,13 @@ class GeminiAdapter(EngineAdapter):
     """
     Adapter for Google Gemini CLI.
 
-    Command format: gemini -y <prompt>
+    Command format: gemini -p <prompt> -y
     The -y flag enables "YOLO mode" (auto-approval of actions).
     """
 
     def build_command(self, prompt: str) -> List[str]:
-        return ["gemini", "-y", prompt]
+        # Based on Gemini CLI help: -p <prompt> for non-interactive
+        return ["gemini", "-p", prompt, "-y"]
 
     @property
     def name(self) -> str:
@@ -69,10 +70,12 @@ class ClaudeAdapter(EngineAdapter):
     Adapter for Anthropic Claude CLI.
 
     Command format: claude -p <prompt>
-    The -p/--print flag enables non-interactive mode (print response and exit).
+    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
@@ -89,12 +92,12 @@ class QwenAdapter(EngineAdapter):
     """
     Adapter for Qwen Code CLI.
 
-    Command format: qwen -y <prompt>
-    The -y flag enables "YOLO mode" (auto-approval of actions).
+    Command format: qwen -p <prompt> -y
     """
 
     def build_command(self, prompt: str) -> List[str]:
-        return ["qwen", "-y", prompt]
+        # Assuming Qwen follows similar patterns (based on user feedback)
+        return ["qwen", "-p", prompt, "-y"]
 
     @property
     def name(self) -> str:
@@ -105,6 +108,28 @@ class QwenAdapter(EngineAdapter):
         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.
@@ -118,6 +143,7 @@ class EngineFactory:
         "gemini": GeminiAdapter,
         "claude": ClaudeAdapter,
         "qwen": QwenAdapter,
+        "kimi": KimiAdapter,
     }
 
     @classmethod