monoco-toolkit 0.1.7__py3-none-any.whl → 0.2.0__py3-none-any.whl

monoco/core/workspace.py

@@ -1,36 +1,99 @@
 from pathlib import Path
-from typing import List, Optional
+from typing import List, Optional, Dict
+from pydantic import BaseModel, Field, ConfigDict
+
+from monoco.core.config import get_config, MonocoConfig
+
+class MonocoProject(BaseModel):
+    """
+    Representation of a single Monoco project.
+    """
+    id: str  # Unique ID within the workspace (usually the directory name)
+    name: str
+    path: Path
+    config: MonocoConfig
+
+    @property
+    def issues_root(self) -> Path:
+        issues_path = Path(self.config.paths.issues)
+        if issues_path.is_absolute():
+            return issues_path
+        return (self.path / issues_path).resolve()
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
 
 def is_project_root(path: Path) -> bool:
     """
     Check if a directory serves as a Monoco project root.
     Criteria:
-    - has .monoco/ directory
+    - has .monoco/ directory (which should contain config.yaml)
     """
     if not path.is_dir():
         return False
         
     return (path / ".monoco").is_dir()
 
-def find_projects(workspace_root: Path) -> List[Path]:
+def load_project(path: Path) -> Optional[MonocoProject]:
+    """Load a project from a path if it is a valid project root."""
+    if not is_project_root(path):
+        return None
+    
+    try:
+        config = get_config(str(path))
+        # If name is default, use directory name
+        name = config.project.name
+        if name == "Monoco Project":
+            name = path.name
+            
+        return MonocoProject(
+            id=path.name,
+            name=name,
+            path=path,
+            config=config
+        )
+    except Exception:
+        return None
+
+def find_projects(workspace_root: Path) -> List[MonocoProject]:
     """
     Scan for projects in a workspace.
-    Returns list of paths that are project roots.
+    Returns list of MonocoProject instances.
     """
     projects = []
     
     # 1. Check workspace root itself
-    if is_project_root(workspace_root):
-        projects.append(workspace_root)
+    root_project = load_project(workspace_root)
+    if root_project:
+        projects.append(root_project)
     
     # 2. Check first-level subdirectories
-    # Prevent scanning giant node_modules or .git
     for item in workspace_root.iterdir():
         if item.is_dir() and not item.name.startswith('.'):
-            if is_project_root(item):
-                # If workspace root is also a project, we might deduce duplicates
-                # But here we just append items. 
-                # If workspace_root == item (impossible for iterdir child), no risk.
-                projects.append(item)
+            # Avoid re-adding root if it was already added (unlikely due to iterdir)
+            if item == workspace_root: continue
+            
+            p = load_project(item)
+            if p:
+                projects.append(p)
                 
     return projects
+
+class Workspace(BaseModel):
+    """
+    Standardized Workspace primitive.
+    """
+    root: Path
+    projects: List[MonocoProject] = []
+    
+    @classmethod
+    def discover(cls, root: Path) -> "Workspace":
+        projects = find_projects(root)
+        return cls(root=root, projects=projects)
+
+    def get_project(self, project_id: str) -> Optional[MonocoProject]:
+        for p in self.projects:
+            if p.id == project_id:
+                return p
+        return None
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)

monoco/daemon/app.py

@@ -6,7 +6,9 @@ import asyncio
 import logging
 import os
 from typing import Optional, List, Dict
-from monoco.daemon.services import Broadcaster, GitMonitor, ProjectManager
+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 fastapi import FastAPI, Request, HTTPException, Query
 
 # Configure logging
@@ -15,6 +17,7 @@ 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
@@ -25,7 +28,8 @@ Monoco Daemon Process
 
 # Service Instances
 broadcaster = Broadcaster()
-git_monitor = GitMonitor(broadcaster)
+git_monitor: GitMonitor | None = None
+config_monitor: ConfigMonitor | None = None
 project_manager: ProjectManager | None = None
 
 @asynccontextmanager
@@ -33,23 +37,45 @@ async def lifespan(app: FastAPI):
     # Startup
     logger.info("Starting Monoco Daemon services...")
     
-    global project_manager
+    global project_manager, git_monitor, config_monitor
     # 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()
     logger.info(f"Workspace Root: {workspace_root}")
     project_manager = ProjectManager(workspace_root, broadcaster)
     
+    async def on_git_change(new_hash: str):
+        await broadcaster.broadcast("HEAD_UPDATED", {
+            "ref": "HEAD",
+            "hash": new_hash
+        })
+    
+    async def on_config_change():
+        logger.info("Config file changed, broadcasting update...")
+        await broadcaster.broadcast("CONFIG_UPDATED", {
+            "scope": "workspace",
+            "path": str(workspace_root / ".monoco" / "config.yaml")
+        })
+
+    git_monitor = GitMonitor(workspace_root, on_git_change)
+    
+    config_path = get_config_path(ConfigScope.PROJECT, workspace_root)
+    config_monitor = ConfigMonitor(config_path, on_config_change)
+    
     await project_manager.start_all()
-    monitor_task = asyncio.create_task(git_monitor.start())
+    git_task = asyncio.create_task(git_monitor.start())
+    config_task = asyncio.create_task(config_monitor.start())
     
     yield
     # Shutdown
     logger.info("Shutting down Monoco Daemon services...")
-    git_monitor.stop()
+    if git_monitor:
+        git_monitor.stop()
+    if config_monitor:
+        config_monitor.stop()
     if project_manager:
         project_manager.stop_all()
-    await monitor_task
+    await asyncio.gather(git_task, config_task)
     
 app = FastAPI(
     title="Monoco Daemon",
@@ -160,10 +186,33 @@ async def sse_endpoint(request: Request):
     return EventSourceResponse(event_generator())
 
 @app.get("/api/v1/issues")
-async def get_issues(project_id: Optional[str] = None):
-    """
-    List all issues in the project.
+async def get_issues(
+    project_id: Optional[str] = None,
+    path: Optional[str] = Query(None, description="Absolute file path for reverse lookup")
+):
     """
+    List all issues in the project, or get a single issue by file path.
+    
+    Query Parameters:
+    - project_id: Optional project filter
+    - path: Optional absolute file path for reverse lookup (returns single issue)
+    
+    If 'path' is provided, returns a single IssueMetadata object.
+    Otherwise, returns a list of all issues.
+    """
+    # Reverse lookup by path
+    if path:
+        p = Path(path)
+        if not p.exists():
+            raise HTTPException(status_code=404, detail=f"File {path} not found")
+            
+        issue = parse_issue(p)
+        if not issue:
+            raise HTTPException(status_code=400, detail=f"File {path} is not a valid Monoco issue")
+            
+        return issue
+    
+    # Standard list operation
     project = get_project_or_404(project_id)
     issues = list_issues(project.issues_root)
     return issues
@@ -221,11 +270,22 @@ async def create_issue_endpoint(payload: CreateIssueRequest):
 @app.get("/api/v1/issues/{issue_id}", response_model=IssueDetail)
 async def get_issue_endpoint(issue_id: str, project_id: Optional[str] = None):
     """
-    Get issue details by ID.
+    Get issue details by ID. Supports cross-project search if project_id is omitted.
     """
-    project = get_project_or_404(project_id)
-    
-    path = find_issue_path(project.issues_root, issue_id)
+    path = None
+    if project_id:
+        project = get_project_or_404(project_id)
+        path = find_issue_path(project.issues_root, issue_id)
+    else:
+        # Global Search across all projects in the workspace
+        if not project_manager:
+            raise HTTPException(status_code=503, detail="Daemon not fully initialized")
+        
+        for p_ctx in project_manager.projects.values():
+            path = find_issue_path(p_ctx.issues_root, issue_id)
+            if path:
+                break
+                
     if not path:
         raise HTTPException(status_code=404, detail=f"Issue {issue_id} not found")
         
@@ -235,21 +295,36 @@ async def get_issue_endpoint(issue_id: str, project_id: Optional[str] = None):
         
     return issue
 
+
 @app.patch("/api/v1/issues/{issue_id}", response_model=IssueMetadata)
 async def update_issue_endpoint(issue_id: str, payload: UpdateIssueRequest):
     """
-    Update an issue logic state (Status, Stage, Solution).
+    Update an issue's metadata (Status, Stage, Solution, Parent, Dependencies, etc.).
     """
     project = get_project_or_404(payload.project_id)
     
     try:
+        # Pre-lookup to get the current path for move detection
+        old_path_obj = find_issue_path(project.issues_root, issue_id)
+        old_path = str(old_path_obj.absolute()) if old_path_obj else None
+
         issue = update_issue(
             project.issues_root, 
             issue_id, 
             status=payload.status, 
             stage=payload.stage, 
-            solution=payload.solution
+            solution=payload.solution,
+            parent=payload.parent,
+            dependencies=payload.dependencies,
+            related=payload.related,
+            tags=payload.tags
         )
+
+        # Post-update: check if path changed
+        if old_path and issue.path != old_path:
+            # Trigger a specialized move event to help editors redirect
+            await project.notify_move(old_path, issue.path, issue.model_dump(mode='json'))
+
         return issue
     except FileNotFoundError:
         raise HTTPException(status_code=404, detail=f"Issue {issue_id} not found")
@@ -311,12 +386,34 @@ async def refresh_monitor():
     # Or just returning the hash confirms the daemon sees it.
     return {"status": "refreshed", "head": current_hash}
 
-# --- Workspace State Management ---
-import json
-from pydantic import BaseModel
+# --- Execution Profiles ---
 
-class WorkspaceState(BaseModel):
-    last_active_project_id: Optional[str] = None
+@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
 
 @app.get("/api/v1/workspace/state", response_model=WorkspaceState)
 async def get_workspace_state():
@@ -326,21 +423,7 @@ async def get_workspace_state():
     if not project_manager:
          raise HTTPException(status_code=503, detail="Daemon not initialized")
     
-    state_file = project_manager.workspace_root / ".monoco" / "state.json"
-    if not state_file.exists():
-        # Default empty state
-        return WorkspaceState()
-        
-    try:
-        content = state_file.read_text(encoding='utf-8')
-        if not content.strip():
-            return WorkspaceState()
-        data = json.loads(content)
-        return WorkspaceState(**data)
-    except Exception as e:
-        logger.error(f"Failed to read state file: {e}")
-        # Return empty state instead of crashing, so frontend can fallback
-        return WorkspaceState()
+    return WorkspaceState.load(project_manager.workspace_root)
 
 @app.post("/api/v1/workspace/state", response_model=WorkspaceState)
 async def update_workspace_state(state: WorkspaceState):
@@ -350,29 +433,9 @@ async def update_workspace_state(state: WorkspaceState):
     if not project_manager:
          raise HTTPException(status_code=503, detail="Daemon not initialized")
 
-    state_file = project_manager.workspace_root / ".monoco" / "state.json"
-    
-    # Ensure directory exists
-    if not state_file.parent.exists():
-        state_file.parent.mkdir(parents=True, exist_ok=True)
-    
     try:
-        # We merge with existing state to avoid data loss if we extend model later
-        current_data = {}
-        if state_file.exists():
-            try:
-                content = state_file.read_text(encoding='utf-8')
-                if content.strip():
-                    current_data = json.loads(content)
-            except:
-                pass # ignore read errors on write
-        
-        # Update with new values
-        new_data = state.model_dump(exclude_unset=True)
-        current_data.update(new_data)
-        
-        state_file.write_text(json.dumps(current_data, indent=2), encoding='utf-8')
-        return WorkspaceState(**current_data)
+        state.save(project_manager.workspace_root)
+        return state
     except Exception as e:
         logger.error(f"Failed to write state file: {e}")
         raise HTTPException(status_code=500, detail=f"Failed to persist state: {str(e)}")

monoco/daemon/models.py

@@ -17,6 +17,10 @@ class UpdateIssueRequest(BaseModel):
     status: Optional[IssueStatus] = None
     stage: Optional[IssueStage] = None
     solution: Optional[IssueSolution] = None
+    parent: Optional[str] = None
+    dependencies: Optional[List[str]] = None
+    related: Optional[List[str]] = None
+    tags: Optional[List[str]] = None
     project_id: Optional[str] = None
 
 class UpdateIssueContentRequest(BaseModel):

monoco/daemon/services.py

@@ -46,69 +46,25 @@ class Broadcaster:
         logger.debug(f"Broadcasted {event_type} to {len(self.subscribers)} clients.")
 
 
-class GitMonitor:
-    """
-    Polls the Git repository for HEAD changes and triggers updates.
-    """
-    def __init__(self, broadcaster: Broadcaster, poll_interval: float = 2.0):
-        self.broadcaster = broadcaster
-        self.poll_interval = poll_interval
-        self.last_head_hash: Optional[str] = None
-        self.is_running = False
-
-    async def get_head_hash(self) -> Optional[str]:
-        try:
-            # Run git rev-parse HEAD asynchronously
-            process = await asyncio.create_subprocess_exec(
-                "git", "rev-parse", "HEAD",
-                stdout=asyncio.subprocess.PIPE,
-                stderr=asyncio.subprocess.PIPE
-            )
-            stdout, _ = await process.communicate()
-            if process.returncode == 0:
-                return stdout.decode().strip()
-            return None
-        except Exception as e:
-            logger.error(f"Git polling error: {e}")
-            return None
-
-    async def start(self):
-        self.is_running = True
-        logger.info("Git Monitor started.")
-        
-        # Initial check
-        self.last_head_hash = await self.get_head_hash()
-        
-        while self.is_running:
-            await asyncio.sleep(self.poll_interval)
-            current_hash = await self.get_head_hash()
-            
-            if current_hash and current_hash != self.last_head_hash:
-                logger.info(f"Git HEAD changed: {self.last_head_hash} -> {current_hash}")
-                self.last_head_hash = current_hash
-                await self.broadcaster.broadcast("HEAD_UPDATED", {
-                    "ref": "HEAD",
-                    "hash": current_hash
-                })
-
-    def stop(self):
-        self.is_running = False
-        logger.info("Git Monitor stopping...")
+# Monitors moved to monoco.core.git and monoco.features.issue.monitor
 
 from watchdog.observers import Observer
 from watchdog.events import FileSystemEventHandler
 from monoco.core.config import MonocoConfig, get_config
 
+from monoco.core.workspace import MonocoProject, Workspace
+
 class ProjectContext:
     """
     Holds the runtime state for a single project.
+    Now wraps the core MonocoProject primitive.
     """
-    def __init__(self, path: Path, config: MonocoConfig, broadcaster: Broadcaster):
-        self.path = path
-        self.config = config
-        self.id = path.name  # Use directory name as ID for now
-        self.name = config.project.name
-        self.issues_root = path / config.paths.issues
+    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
         self.monitor = IssueMonitor(self.issues_root, broadcaster, project_id=self.id)
 
     async def start(self):
@@ -120,6 +76,7 @@ class ProjectContext:
 class ProjectManager:
     """
     Discovers and manages multiple Monoco projects within a workspace.
+    Uses core Workspace primitive for discovery.
     """
     def __init__(self, workspace_root: Path, broadcaster: Broadcaster):
         self.workspace_root = workspace_root
@@ -128,28 +85,16 @@ class ProjectManager:
 
     def scan(self):
         """
-        Scans workspace for potential Monoco projects.
-        A directory is a project if it has a .monoco/ directory.
+        Scans workspace for Monoco projects using core logic.
         """
         logger.info(f"Scanning workspace: {self.workspace_root}")
-        from monoco.core.workspace import find_projects
+        workspace = Workspace.discover(self.workspace_root)
         
-        projects = find_projects(self.workspace_root)
-        for p in projects:
-            self._register_project(p)
-
-    def _register_project(self, path: Path):
-        try:
-            config = get_config(str(path))
-            # If name is default, try to use directory name
-            if config.project.name == "Monoco Project":
-                config.project.name = path.name
-            
-            ctx = ProjectContext(path, config, self.broadcaster)
-            self.projects[ctx.id] = ctx
-            logger.info(f"Registered project: {ctx.id} ({ctx.path})")
-        except Exception as e:
-            logger.error(f"Failed to register project at {path}: {e}")
+        for project in workspace.projects:
+            if project.id not in self.projects:
+                ctx = ProjectContext(project, self.broadcaster)
+                self.projects[ctx.id] = ctx
+                logger.info(f"Registered project: {ctx.id} ({ctx.path})")
 
     async def start_all(self):
         self.scan()
@@ -174,92 +119,48 @@ class ProjectManager:
             for p in self.projects.values()
         ]
 
-class IssueEventHandler(FileSystemEventHandler):
-    def __init__(self, loop, broadcaster: Broadcaster, project_id: str):
-        self.loop = loop
-        self.broadcaster = broadcaster
-        self.project_id = project_id
-
-    def _process_upsert(self, path_str: str):
-        if not path_str.endswith(".md"):
-            return
-        asyncio.run_coroutine_threadsafe(self._handle_upsert(path_str), self.loop)
-    
-    async def _handle_upsert(self, path_str: str):
-        try:
-            path = Path(path_str)
-            if not path.exists():
-                return
-            issue = parse_issue(path)
-            if issue:
-                await self.broadcaster.broadcast("issue_upserted", {
-                    "issue": issue.model_dump(mode='json'),
-                    "project_id": self.project_id
-                })
-        except Exception as e:
-            logger.error(f"Error handling upsert for {path_str}: {e}")
+from monoco.features.issue.monitor import IssueMonitor
 
-    def _process_delete(self, path_str: str):
-        if not path_str.endswith(".md"):
-            return
-        asyncio.run_coroutine_threadsafe(self._handle_delete(path_str), self.loop)
-
-    async def _handle_delete(self, path_str: str):
-        try:
-            filename = Path(path_str).name
-            match = re.match(r"([A-Z]+-\d{4})", filename)
-            if match:
-                issue_id = match.group(1)
-                await self.broadcaster.broadcast("issue_deleted", {
-                    "id": issue_id,
-                    "project_id": self.project_id
-                })
-        except Exception as e:
-            logger.error(f"Error handling delete for {path_str}: {e}")
-
-    def on_created(self, event):
-        if not event.is_directory:
-            self._process_upsert(event.src_path)
-
-    def on_modified(self, event):
-        if not event.is_directory:
-            self._process_upsert(event.src_path)
-            
-    def on_deleted(self, event):
-        if not event.is_directory:
-            self._process_delete(event.src_path)
-
-    def on_moved(self, event):
-        if not event.is_directory:
-            self._process_delete(event.src_path)
-            self._process_upsert(event.dest_path)
-
-class IssueMonitor:
+class ProjectContext:
     """
-    Monitor the Issues directory for changes using Watchdog and broadcast update events.
+    Holds the runtime state for a single project.
+    Now wraps the core MonocoProject primitive.
     """
-    def __init__(self, issues_root: Path, broadcaster: Broadcaster, project_id: str):
-        self.issues_root = issues_root
-        self.broadcaster = broadcaster
-        self.project_id = project_id
-        self.observer = Observer()
-        self.loop = None
-
-    async def start(self):
-        self.loop = asyncio.get_running_loop()
-        event_handler = IssueEventHandler(self.loop, self.broadcaster, self.project_id)
+    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
         
-        # Ensure directory exists
-        if not self.issues_root.exists():
-            logger.warning(f"Issues root {self.issues_root} does not exist. creating...")
-            self.issues_root.mkdir(parents=True, exist_ok=True)
+        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
+        })
 
-        self.observer.schedule(event_handler, str(self.issues_root), recursive=True)
-        self.observer.start()
-        logger.info(f"Issue Monitor started (Watchdog). Watching {self.issues_root}")
+    async def start(self):
+        await self.monitor.start()
 
     def stop(self):
-        if self.observer.is_alive():
-            self.observer.stop()
-            self.observer.join()
-        logger.info("Issue Monitor stopped.")
+        self.monitor.stop()