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

monoco/core/watcher/task.py

@@ -0,0 +1,238 @@
+"""
+TaskWatcher - Monitors task files for changes.
+
+Part of Layer 1 (File Watcher) in the event automation framework.
+Emits events for task status changes and completion.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Set
+
+from monoco.core.scheduler import AgentEventType, EventBus, event_bus
+
+from .base import (
+    ChangeType,
+    FieldChange,
+    FileEvent,
+    FilesystemWatcher,
+    WatchConfig,
+    PollingWatcher,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class TaskFileEvent(FileEvent):
+    """FileEvent specific to Task files."""
+    
+    def __init__(
+        self,
+        path: Path,
+        change_type: ChangeType,
+        task_changes: Optional[List[Dict[str, Any]]] = None,
+        **kwargs,
+    ):
+        super().__init__(
+            path=path,
+            change_type=change_type,
+            watcher_name="TaskWatcher",
+            **kwargs,
+        )
+        self.task_changes = task_changes or []
+    
+    def to_agent_event_type(self) -> Optional[AgentEventType]:
+        """Tasks map to issue updates for now."""
+        return AgentEventType.ISSUE_UPDATED
+    
+    def to_payload(self) -> Dict[str, Any]:
+        """Convert to payload with Task-specific fields."""
+        payload = super().to_payload()
+        payload["task_changes"] = self.task_changes
+        return payload
+
+
+@dataclass
+class TaskItem:
+    """Represents a single task item."""
+    content: str
+    state: str  # " ", "x", "X", "-", "/"
+    line_number: int
+    level: int = 0
+    
+    @property
+    def is_completed(self) -> bool:
+        return self.state.lower() == "x"
+    
+    @property
+    def is_in_progress(self) -> bool:
+        return self.state in ("-", "/")
+
+
+class TaskWatcher(PollingWatcher):
+    """
+    Watcher for task files.
+    
+    Monitors task files (e.g., tasks.md, TODO.md) for:
+    - Task creation
+    - Task status changes (todo -> doing -> done)
+    - Task completion
+    
+    Example:
+        >>> config = WatchConfig(
+        ...     path=Path("./tasks.md"),
+        ...     patterns=["*.md"],
+        ... )
+        >>> watcher = TaskWatcher(config)
+        >>> await watcher.start()
+    """
+    
+    # Regex to match task items
+    TASK_PATTERN = re.compile(
+        r"^(\s*)-\s*\[([ xX\-/])\]\s*(.+)$",
+        re.MULTILINE,
+    )
+    
+    def __init__(
+        self,
+        config: WatchConfig,
+        event_bus: Optional[EventBus] = None,
+        name: str = "TaskWatcher",
+    ):
+        super().__init__(config, event_bus, name)
+        self._task_cache: Dict[str, TaskItem] = {}  # task_id -> TaskItem
+    
+    async def _check_changes(self) -> None:
+        """Check for task file changes."""
+        if not self.config.path.exists():
+            return
+        
+        try:
+            content = self._read_file_content(self.config.path) or ""
+            current_tasks = self._parse_tasks(content)
+            
+            # Detect changes
+            task_changes = self._detect_task_changes(current_tasks)
+            
+            if task_changes:
+                await self._emit_task_changes(task_changes)
+            
+            # Update cache
+            self._task_cache = current_tasks
+        
+        except Exception as e:
+            logger.error(f"Error checking task file: {e}")
+    
+    def _parse_tasks(self, content: str) -> Dict[str, TaskItem]:
+        """Parse task items from content."""
+        tasks = {}
+        lines = content.split("\n")
+        
+        for line_num, line in enumerate(lines, 1):
+            match = self.TASK_PATTERN.match(line)
+            if match:
+                indent = match.group(1)
+                state = match.group(2)
+                task_content = match.group(3).strip()
+                
+                # Generate task ID from content hash
+                import hashlib
+                task_id = hashlib.md5(
+                    f"{line_num}:{task_content}".encode()
+                ).hexdigest()[:12]
+                
+                tasks[task_id] = TaskItem(
+                    content=task_content,
+                    state=state,
+                    line_number=line_num,
+                    level=len(indent) // 2,
+                )
+        
+        return tasks
+    
+    def _detect_task_changes(
+        self,
+        current_tasks: Dict[str, TaskItem],
+    ) -> List[Dict[str, Any]]:
+        """Detect changes between cached and current tasks."""
+        changes = []
+        current_ids = set(current_tasks.keys())
+        cached_ids = set(self._task_cache.keys())
+        
+        # New tasks
+        for task_id in current_ids - cached_ids:
+            task = current_tasks[task_id]
+            changes.append({
+                "type": "created",
+                "task_id": task_id,
+                "content": task.content,
+                "state": task.state,
+            })
+        
+        # Deleted tasks
+        for task_id in cached_ids - current_ids:
+            task = self._task_cache[task_id]
+            changes.append({
+                "type": "deleted",
+                "task_id": task_id,
+                "content": task.content,
+            })
+        
+        # Modified tasks
+        for task_id in current_ids & cached_ids:
+            current = current_tasks[task_id]
+            cached = self._task_cache[task_id]
+            
+            if current.state != cached.state:
+                changes.append({
+                    "type": "state_changed",
+                    "task_id": task_id,
+                    "content": current.content,
+                    "old_state": cached.state,
+                    "new_state": current.state,
+                    "is_completed": current.is_completed,
+                })
+        
+        return changes
+    
+    async def _emit_task_changes(self, changes: List[Dict[str, Any]]) -> None:
+        """Emit events for task changes."""
+        event = TaskFileEvent(
+            path=self.config.path,
+            change_type=ChangeType.MODIFIED,
+            task_changes=changes,
+            metadata={
+                "total_changes": len(changes),
+                "completed_tasks": sum(1 for c in changes if c.get("is_completed")),
+            },
+        )
+        await self.emit(event)
+        
+        # Log summary
+        created = sum(1 for c in changes if c["type"] == "created")
+        completed = sum(1 for c in changes if c["type"] == "state_changed" and c.get("is_completed"))
+        logger.debug(f"Task changes: {created} created, {completed} completed")
+    
+    def get_task_stats(self) -> Dict[str, int]:
+        """Get task statistics."""
+        total = len(self._task_cache)
+        completed = sum(1 for t in self._task_cache.values() if t.is_completed)
+        in_progress = sum(1 for t in self._task_cache.values() if t.is_in_progress)
+        
+        return {
+            "total": total,
+            "completed": completed,
+            "in_progress": in_progress,
+            "pending": total - completed - in_progress,
+        }
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """Get watcher statistics."""
+        stats = super().get_stats()
+        stats.update(self.get_task_stats())
+        return stats

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"

monoco/daemon/events.py

@@ -0,0 +1,34 @@
+"""
+EventBus - Central event system for Agent scheduling.
+
+DEPRECATED: This module has been moved to monoco.core.scheduler.
+This file is kept for backward compatibility and re-exports from the new location.
+
+Migration:
+    Old: from monoco.daemon.events import AgentEventType, event_bus
+    New: from monoco.core.scheduler import AgentEventType, event_bus
+"""
+
+import warnings
+from monoco.core.scheduler import (
+    AgentEventType,
+    AgentEvent,
+    EventBus,
+    event_bus,
+    EventHandler,
+)
+
+warnings.warn(
+    "monoco.daemon.events is deprecated. "
+    "Use monoco.core.scheduler instead.",
+    DeprecationWarning,
+    stacklevel=2
+)
+
+__all__ = [
+    "AgentEventType",
+    "AgentEvent",
+    "EventBus",
+    "event_bus",
+    "EventHandler",
+]

monoco/daemon/mailroom_service.py

@@ -0,0 +1,196 @@
+"""
+Mailroom Service for Monoco Daemon.
+
+Manages automated document ingestion with concurrent processing,
+environment discovery, and artifact registration.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from pathlib import Path
+from typing import Optional, Dict, Any
+
+from monoco.core.ingestion.discovery import EnvironmentDiscovery
+from monoco.core.ingestion.worker import ConversionWorker
+from monoco.core.ingestion.watcher import DropzoneWatcher, IngestionEvent
+from monoco.core.artifacts.manager import ArtifactManager
+
+logger = logging.getLogger(__name__)
+
+
+class MailroomService:
+    """
+    Service for automated document ingestion in Monoco Daemon.
+    
+    Features:
+    - Environment discovery for conversion tools
+    - Dropzone monitoring for new files
+    - Concurrent conversion processing
+    - Artifact registration
+    - SSE event broadcasting
+    """
+
+    def __init__(
+        self,
+        workspace_root: Path,
+        broadcaster: Optional[Any] = None,
+        dropzone_path: Optional[Path] = None,
+        max_concurrent: int = 4,
+    ):
+        """
+        Initialize the Mailroom service.
+        
+        Args:
+            workspace_root: Root directory of the workspace
+            broadcaster: SSE broadcaster for events
+            dropzone_path: Path to dropzone directory (default: workspace/.monoco/dropzone)
+            max_concurrent: Maximum concurrent conversion tasks
+        """
+        self.workspace_root = Path(workspace_root)
+        self.broadcaster = broadcaster
+        
+        # Default dropzone location
+        self.dropzone_path = dropzone_path or (self.workspace_root / ".monoco" / "dropzone")
+        
+        # Initialize components
+        self.discovery = EnvironmentDiscovery()
+        self.conversion_worker = ConversionWorker(
+            discovery=self.discovery,
+            max_concurrent=max_concurrent,
+        )
+        
+        # Artifact manager (lazy init)
+        self._artifact_manager: Optional[ArtifactManager] = None
+        
+        # Watcher (lazy init)
+        self._watcher: Optional[DropzoneWatcher] = None
+        
+        # State
+        self._running = False
+        self._stats: Dict[str, Any] = {
+            "files_detected": 0,
+            "conversions_success": 0,
+            "conversions_failed": 0,
+            "artifacts_registered": 0,
+        }
+
+    @property
+    def artifact_manager(self) -> ArtifactManager:
+        """Get or create the artifact manager."""
+        if self._artifact_manager is None:
+            self._artifact_manager = ArtifactManager(self.workspace_root)
+        return self._artifact_manager
+
+    async def start(self) -> None:
+        """Start the Mailroom service."""
+        if self._running:
+            return
+
+        logger.info("Starting Mailroom service...")
+
+        # Perform environment discovery
+        tools = self.discovery.discover()
+        total_tools = sum(len(t) for t in tools.values())
+        logger.info(f"Discovered {total_tools} conversion tools")
+
+        # Log discovered capabilities
+        capabilities = self.discovery.get_capabilities_summary()
+        logger.info(f"Capabilities: {capabilities}")
+
+        # Initialize and start dropzone watcher
+        self._watcher = DropzoneWatcher(
+            dropzone_path=self.dropzone_path,
+            artifact_manager=self.artifact_manager,
+            conversion_worker=self.conversion_worker,
+            process_existing=False,  # Don't process existing files on startup
+        )
+        
+        # Set up event callback
+        self._watcher.set_event_callback(self._on_ingestion_event)
+        
+        # Start watching (this is synchronous, runs in background thread)
+        self._watcher.start()
+        
+        self._running = True
+        logger.info(f"Mailroom service started. Dropzone: {self.dropzone_path}")
+
+    async def stop(self) -> None:
+        """Stop the Mailroom service."""
+        if not self._running:
+            return
+
+        logger.info("Stopping Mailroom service...")
+
+        if self._watcher:
+            self._watcher.stop()
+            self._watcher = None
+
+        self._running = False
+        logger.info("Mailroom service stopped")
+
+    def _on_ingestion_event(self, event: IngestionEvent) -> None:
+        """Handle ingestion events from the watcher."""
+        # Update stats
+        if event.event_type.value == "file_detected":
+            self._stats["files_detected"] += 1
+        elif event.event_type.value == "conversion_completed":
+            self._stats["conversions_success"] += 1
+        elif event.event_type.value == "conversion_failed":
+            self._stats["conversions_failed"] += 1
+        elif event.event_type.value == "artifact_registered":
+            self._stats["artifacts_registered"] += 1
+
+        # Broadcast via SSE if broadcaster available
+        if self.broadcaster:
+            asyncio.create_task(self._broadcast_event(event))
+
+    async def _broadcast_event(self, event: IngestionEvent) -> None:
+        """Broadcast ingestion event to SSE clients."""
+        try:
+            payload = {
+                "type": event.event_type.value,
+                "file_path": str(event.file_path),
+                "task_id": event.task_id,
+                "artifact_id": event.artifact_id,
+                "error_message": event.error_message,
+                "metadata": event.metadata,
+                "timestamp": event.timestamp.isoformat(),
+            }
+            await self.broadcaster.broadcast("MAILROOM_EVENT", payload)
+        except Exception as e:
+            logger.error(f"Failed to broadcast mailroom event: {e}")
+
+    def get_status(self) -> Dict[str, Any]:
+        """Get current service status and statistics."""
+        capabilities = self.discovery.get_capabilities_summary()
+        
+        return {
+            "running": self._running,
+            "dropzone_path": str(self.dropzone_path),
+            "capabilities": capabilities,
+            "supported_extensions": self.conversion_worker.get_supported_extensions(),
+            "stats": self._stats.copy(),
+            "tools": [
+                {
+                    "name": tool.name,
+                    "type": tool.tool_type.value,
+                    "version": tool.version,
+                    "capabilities": [c.value for c in tool.capabilities],
+                }
+                for tool in self.discovery.get_all_tools()
+            ],
+        }
+
+    def is_running(self) -> bool:
+        """Check if the service is running."""
+        return self._running
+
+    def get_discovery(self) -> EnvironmentDiscovery:
+        """Get the environment discovery instance."""
+        return self.discovery
+
+    def get_worker(self) -> ConversionWorker:
+        """Get the conversion worker instance."""
+        return self.conversion_worker

monoco/daemon/models.py

@@ -18,6 +18,7 @@ class CreateIssueRequest(BaseModel):
     related: List[str] = []
     subdir: Optional[str] = None
     project_id: Optional[str] = None  # Added for multi-project support
+    from_memos: List[str] = []  # Memo IDs to link to this issue
 
 
 class UpdateIssueRequest(BaseModel):