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

monoco/daemon/services.py

@@ -2,10 +2,8 @@ import logging
 from typing import List, Optional, Dict, Any
 from asyncio import Queue
 from pathlib import Path
-from datetime import datetime, timedelta
-from threading import Lock
 
-import json
+from monoco.core.workspace import MonocoProject, Workspace
 
 logger = logging.getLogger("monoco.daemon.services")
 
@@ -33,6 +31,7 @@ class Broadcaster:
         if not self.subscribers:
             return
 
+        import json
         message = {"event": event_type, "data": json.dumps(payload)}
 
         # Dispatch to all queues
@@ -42,12 +41,6 @@ class Broadcaster:
         logger.debug(f"Broadcasted {event_type} to {len(self.subscribers)} clients.")
 
 
-# Monitors moved to monoco.core.git and monoco.features.issue.monitor
-
-
-from monoco.core.workspace import MonocoProject, Workspace
-
-
 class ProjectContext:
     """
     Holds the runtime state for a single project.
@@ -60,7 +53,31 @@ class ProjectContext:
         self.name = project.name
         self.path = project.path
         self.issues_root = project.issues_root
-        self.monitor = IssueMonitor(self.issues_root, broadcaster, project_id=self.id)
+
+        async def on_upsert(issue_data: dict):
+            await broadcaster.broadcast(
+                "issue_upserted", {"issue": issue_data, "project_id": self.id}
+            )
+
+        async def on_delete(issue_data: dict):
+            await broadcaster.broadcast(
+                "issue_deleted", {"id": issue_data["id"], "project_id": self.id}
+            )
+
+        from monoco.features.issue.monitor import IssueMonitor
+        self.monitor = IssueMonitor(self.issues_root, on_upsert, on_delete)
+
+    async def notify_move(self, old_path: str, new_path: str, issue_data: dict):
+        """Explicitly notify frontend about a logical move (Physical path changed)."""
+        await self.broadcaster.broadcast(
+            "issue_moved",
+            {
+                "old_path": old_path,
+                "new_path": new_path,
+                "issue": issue_data,
+                "project_id": self.id,
+            },
+        )
 
     async def start(self):
         await self.monitor.start()
@@ -69,189 +86,6 @@ class ProjectContext:
         self.monitor.stop()
 
 
-class SemaphoreManager:
-    """
-    Manages concurrency limits for agent sessions using role-based semaphores.
-    Prevents fork bomb by limiting concurrent agents per role and globally.
-    """
-
-    def __init__(self, config: Optional[Any] = None):
-        """
-        Initialize the SemaphoreManager.
-        
-        Args:
-            config: AgentConcurrencyConfig or dict with concurrency settings
-        """
-        self._lock = Lock()
-        self._active_sessions: Dict[str, str] = {}  # session_id -> role_name
-        self._role_counts: Dict[str, int] = {}  # role_name -> count
-        self._failure_registry: Dict[str, datetime] = {}  # issue_id -> last_failure_time
-        
-        # Default conservative limits
-        self._global_max = 3
-        self._role_limits: Dict[str, int] = {
-            "Engineer": 1,
-            "Architect": 1,
-            "Reviewer": 1,
-            "Planner": 1,
-        }
-        self._failure_cooldown_seconds = 60
-        
-        # Apply config if provided
-        if config:
-            self._apply_config(config)
-    
-    def _apply_config(self, config: Any) -> None:
-        """Apply configuration settings."""
-        # Handle both dict and Pydantic model
-        if hasattr(config, 'global_max'):
-            self._global_max = config.global_max
-        if hasattr(config, 'failure_cooldown_seconds'):
-            self._failure_cooldown_seconds = config.failure_cooldown_seconds
-        
-        # Role-specific limits
-        for role in ["Engineer", "Architect", "Reviewer", "Planner"]:
-            if hasattr(config, role.lower()):
-                self._role_limits[role] = getattr(config, role.lower())
-    
-    def can_acquire(self, role_name: str, issue_id: Optional[str] = None) -> bool:
-        """
-        Check if a new session can be acquired for the given role.
-        
-        Args:
-            role_name: The role to check (e.g., "Engineer", "Architect")
-            issue_id: Optional issue ID to check for failure cooldown
-            
-        Returns:
-            True if the session can be started, False otherwise
-        """
-        with self._lock:
-            # Check global limit
-            total_active = len(self._active_sessions)
-            if total_active >= self._global_max:
-                logger.warning(
-                    f"Global concurrency limit reached ({self._global_max}). "
-                    f"Cannot spawn {role_name}."
-                )
-                return False
-            
-            # Check role-specific limit
-            role_count = self._role_counts.get(role_name, 0)
-            role_limit = self._role_limits.get(role_name, 1)
-            if role_count >= role_limit:
-                logger.warning(
-                    f"Role concurrency limit reached for {role_name} "
-                    f"({role_count}/{role_limit})."
-                )
-                return False
-            
-            # Check failure cooldown for this issue
-            if issue_id and issue_id in self._failure_registry:
-                last_failure = self._failure_registry[issue_id]
-                cooldown = timedelta(seconds=self._failure_cooldown_seconds)
-                if datetime.now() - last_failure < cooldown:
-                    remaining = cooldown - (datetime.now() - last_failure)
-                    logger.warning(
-                        f"Issue {issue_id} is in cooldown period. "
-                        f"Remaining: {remaining.seconds}s. Skipping spawn."
-                    )
-                    return False
-            
-            return True
-    
-    def acquire(self, session_id: str, role_name: str) -> bool:
-        """
-        Acquire a slot for a new session.
-        
-        Args:
-            session_id: Unique identifier for the session
-            role_name: The role of the session
-            
-        Returns:
-            True if acquired successfully, False otherwise
-        """
-        with self._lock:
-            if session_id in self._active_sessions:
-                logger.warning(f"Session {session_id} already tracked")
-                return True
-            
-            self._active_sessions[session_id] = role_name
-            self._role_counts[role_name] = self._role_counts.get(role_name, 0) + 1
-            logger.info(
-                f"Acquired slot for {role_name} session {session_id}. "
-                f"Global: {len(self._active_sessions)}/{self._global_max}, "
-                f"Role: {self._role_counts[role_name]}/{self._role_limits.get(role_name, 1)}"
-            )
-            return True
-    
-    def release(self, session_id: str) -> None:
-        """
-        Release a slot when a session ends.
-        
-        Args:
-            session_id: The session ID to release
-        """
-        with self._lock:
-            if session_id not in self._active_sessions:
-                return
-            
-            role_name = self._active_sessions.pop(session_id)
-            self._role_counts[role_name] = max(0, self._role_counts.get(role_name, 0) - 1)
-            logger.info(
-                f"Released slot for {role_name} session {session_id}. "
-                f"Global: {len(self._active_sessions)}/{self._global_max}"
-            )
-    
-    def record_failure(self, issue_id: str, session_id: Optional[str] = None) -> None:
-        """
-        Record a failure for cooldown purposes.
-        
-        Args:
-            issue_id: The issue that failed
-            session_id: Optional session ID to release
-        """
-        with self._lock:
-            self._failure_registry[issue_id] = datetime.now()
-            logger.warning(
-                f"Recorded failure for issue {issue_id}. "
-                f"Cooldown: {self._failure_cooldown_seconds}s"
-            )
-        
-        # Release the slot if session_id provided
-        if session_id:
-            self.release(session_id)
-    
-    def get_status(self) -> Dict[str, Any]:
-        """
-        Get current semaphore status for monitoring.
-        
-        Returns:
-            Dict with current counts and limits
-        """
-        with self._lock:
-            return {
-                "global": {
-                    "active": len(self._active_sessions),
-                    "limit": self._global_max,
-                },
-                "roles": {
-                    role: {
-                        "active": self._role_counts.get(role, 0),
-                        "limit": limit,
-                    }
-                    for role, limit in self._role_limits.items()
-                },
-                "cooldown_issues": len(self._failure_registry),
-            }
-    
-    def clear_failure(self, issue_id: str) -> None:
-        """Clear failure record for an issue (e.g., after successful completion)."""
-        with self._lock:
-            if issue_id in self._failure_registry:
-                del self._failure_registry[issue_id]
-                logger.info(f"Cleared failure record for issue {issue_id}")
-
-
 class ProjectManager:
     """
     Discovers and manages multiple Monoco projects within a workspace.
@@ -298,53 +132,3 @@ class ProjectManager:
             }
             for p in self.projects.values()
         ]
-
-
-from monoco.features.issue.monitor import IssueMonitor
-
-
-class ProjectContext:
-    """
-    Holds the runtime state for a single project.
-    Now wraps the core MonocoProject primitive.
-    """
-
-    def __init__(self, project: MonocoProject, broadcaster: Broadcaster):
-        self.project = project
-        self.id = project.id
-        self.name = project.name
-        self.path = project.path
-        self.issues_root = project.issues_root
-
-        async def on_upsert(issue_data: dict):
-            await broadcaster.broadcast(
-                "issue_upserted", {"issue": issue_data, "project_id": self.id}
-            )
-
-        async def on_delete(issue_data: dict):
-            # We skip broadcast here if it's part of a move?
-            # Actually, standard upsert/delete is fine, but we need a specialized event for MOVE
-            # to help VS Code redirect without closing/reopening.
-            await broadcaster.broadcast(
-                "issue_deleted", {"id": issue_data["id"], "project_id": self.id}
-            )
-
-        self.monitor = IssueMonitor(self.issues_root, on_upsert, on_delete)
-
-    async def notify_move(self, old_path: str, new_path: str, issue_data: dict):
-        """Explicitly notify frontend about a logical move (Physical path changed)."""
-        await self.broadcaster.broadcast(
-            "issue_moved",
-            {
-                "old_path": old_path,
-                "new_path": new_path,
-                "issue": issue_data,
-                "project_id": self.id,
-            },
-        )
-
-    async def start(self):
-        await self.monitor.start()
-
-    def stop(self):
-        self.monitor.stop()

monoco/features/agent/__init__.py

@@ -1,10 +1,25 @@
+"""
+Agent feature module - CLI interface for agent operations.
+
+Note: The old SessionManager/RuntimeSession/ApoptosisManager architecture
+has been removed in FEAT-0164. This module now provides CLI commands that
+use the new AgentScheduler abstraction from core.scheduler.
+"""
+
 from .models import RoleTemplate, AgentRoleConfig as AgentConfig, SchedulerConfig
 from .worker import Worker
 from .config import load_scheduler_config, load_agent_config
 from .defaults import DEFAULT_ROLES
-from .session import Session, RuntimeSession
-from .manager import SessionManager
-from .apoptosis import ApoptosisManager
+
+# Re-export engines from core.scheduler for backward compatibility
+from monoco.core.scheduler import (
+    EngineAdapter,
+    EngineFactory,
+    GeminiAdapter,
+    ClaudeAdapter,
+    QwenAdapter,
+    KimiAdapter,
+)
 
 __all__ = [
     "RoleTemplate",
@@ -14,8 +29,11 @@ __all__ = [
     "Worker",
     "load_scheduler_config",
     "DEFAULT_ROLES",
-    "Session",
-    "RuntimeSession",
-    "SessionManager",
-    "ApoptosisManager",
+    # Re-exported from core.scheduler
+    "EngineAdapter",
+    "EngineFactory",
+    "GeminiAdapter",
+    "ClaudeAdapter",
+    "QwenAdapter",
+    "KimiAdapter",
 ]

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