monoco-toolkit 0.3.11__py3-none-any.whl → 0.4.0__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

@@ -5,10 +5,10 @@ from sse_starlette.sse import EventSourceResponse
 import asyncio
 import logging
 import os
-from typing import Optional, List, Dict
+from typing import Optional, 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.core.config import get_config
 from monoco.daemon.scheduler import SchedulerService
 from monoco.daemon.mailroom_service import MailroomService
 
@@ -18,11 +18,6 @@ logger = logging.getLogger("monoco.daemon")
 from pathlib import Path
 from monoco.core.config import get_config
 from monoco.features.issue.core import list_issues
-from monoco.core.execution import (
-    scan_execution_profiles,
-    get_profile_detail,
-    ExecutionProfile,
-)
 
 description = """
 Monoco Daemon Process
@@ -34,7 +29,6 @@ Monoco Daemon Process
 # Service Instances
 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
@@ -45,7 +39,7 @@ async def lifespan(app: FastAPI):
     # Startup
     logger.info("Starting Monoco Daemon services...")
 
-    global project_manager, git_monitor, config_monitors, scheduler_service, mailroom_service
+    global project_manager, git_monitor, 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()
@@ -55,26 +49,8 @@ async def lifespan(app: FastAPI):
     async def on_git_change(new_hash: str):
         await broadcaster.broadcast("HEAD_UPDATED", {"ref": "HEAD", "hash": new_hash})
 
-    async def on_config_change(path: str):
-        logger.info(f"Config file changed: {path}, broadcasting update...")
-        await broadcaster.broadcast(
-            "CONFIG_UPDATED", {"scope": "workspace", "path": path}
-        )
-
     git_monitor = GitMonitor(workspace_root, on_git_change)
 
-    project_config_path = get_config_path(ConfigScope.PROJECT, str(workspace_root))
-    workspace_config_path = get_config_path(ConfigScope.WORKSPACE, str(workspace_root))
-
-    config_monitors = [
-        ConfigMonitor(
-            project_config_path, lambda: on_config_change(str(project_config_path))
-        ),
-        ConfigMonitor(
-            workspace_config_path, lambda: on_config_change(str(workspace_config_path))
-        ),
-    ]
-
     await project_manager.start_all()
     # Start Scheduler
     scheduler_service = SchedulerService(project_manager)
@@ -88,15 +64,12 @@ async def lifespan(app: FastAPI):
     await mailroom_service.start()
     
     git_task = asyncio.create_task(git_monitor.start())
-    config_tasks = [asyncio.create_task(m.start()) for m in config_monitors]
 
     yield
     # Shutdown
     logger.info("Shutting down Monoco Daemon services...")
     if git_monitor:
         git_monitor.stop()
-    for m in config_monitors:
-        m.stop()
     if project_manager:
         project_manager.stop_all()
     if scheduler_service:
@@ -105,7 +78,6 @@ async def lifespan(app: FastAPI):
         await mailroom_service.stop()
 
     await git_task
-    await asyncio.gather(*config_tasks)
 
 
 app = FastAPI(
@@ -463,35 +435,6 @@ async def refresh_monitor():
     return {"status": "refreshed", "head": current_hash}
 
 
-# --- Execution Profiles ---
-
-
-@app.get("/api/v1/execution/profiles", response_model=List[ExecutionProfile])
-async def get_execution_profiles(project_id: Optional[str] = None):
-    """
-    List all execution profiles available for the project/workspace.
-    """
-    project = None
-    if project_id:
-        project = get_project_or_404(project_id)
-    elif project_manager and project_manager.projects:
-        # Fallback to first project if none specified
-        project = list(project_manager.projects.values())[0]
-
-    return scan_execution_profiles(project.path if project else None)
-
-
-@app.get("/api/v1/execution/profiles/detail", response_model=ExecutionProfile)
-async def get_execution_profile_detail(path: str):
-    """
-    Get full content of an execution profile.
-    """
-    profile = get_profile_detail(path)
-    if not profile:
-        raise HTTPException(status_code=404, detail="Profile not found")
-    return profile
-
-
 # --- Workspace State Management ---
 from monoco.core.state import WorkspaceState