monoco-toolkit 0.2.8__py3-none-any.whl → 0.3.0__py3-none-any.whl

monoco/daemon/app.py

@@ -16,7 +16,11 @@ 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
+from monoco.core.execution import (
+    scan_execution_profiles,
+    get_profile_detail,
+    ExecutionProfile,
+)
 
 description = """
 Monoco Daemon Process
@@ -31,45 +35,46 @@ git_monitor: GitMonitor | None = None
 config_monitors: List[ConfigMonitor] = []
 project_manager: ProjectManager | None = None
 
+
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     # Startup
     logger.info("Starting Monoco Daemon services...")
-    
+
     global project_manager, git_monitor, config_monitors
     # 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
-        })
-    
+        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
-        })
+        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)))
+        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()
     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...")
@@ -79,10 +84,11 @@ async def lifespan(app: FastAPI):
         m.stop()
     if project_manager:
         project_manager.stop_all()
-    
+
     await git_task
     await asyncio.gather(*config_tasks)
-    
+
+
 app = FastAPI(
     title="Monoco Daemon",
     description=description,
@@ -92,17 +98,18 @@ app = FastAPI(
     lifespan=lifespan,
 )
 
+
 def get_project_or_404(project_id: Optional[str] = None):
     if not project_manager:
         raise HTTPException(status_code=503, detail="Daemon not fully initialized")
-    
+
     # If project_id is not provided, try to use the first available project (default behavior)
     if not project_id:
         projects = list(project_manager.projects.values())
         if not projects:
-             # Fallback to legacy single-project mode if no sub-projects found? 
-             # Or maybe ProjectManager scan logic already covers CWD as a project.
-             raise HTTPException(status_code=404, detail="No projects found")
+            # Fallback to legacy single-project mode if no sub-projects found?
+            # Or maybe ProjectManager scan logic already covers CWD as a project.
+            raise HTTPException(status_code=404, detail="No projects found")
         return projects[0]
 
     project = project_manager.get_project(project_id)
@@ -110,6 +117,7 @@ def get_project_or_404(project_id: Optional[str] = None):
         raise HTTPException(status_code=404, detail=f"Project {project_id} not found")
     return project
 
+
 # CORS Configuration
 # Kanban may run on different ports (e.g. localhost:3000, tauri://localhost)
 app.add_middleware(
@@ -120,6 +128,7 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
+
 @app.get("/health")
 async def health_check():
     """
@@ -127,6 +136,7 @@ async def health_check():
     """
     return {"status": "ok", "component": "monoco-daemon"}
 
+
 @app.get("/api/v1/projects")
 async def list_projects():
     """
@@ -136,6 +146,7 @@ async def list_projects():
         return []
     return project_manager.list_projects()
 
+
 @app.get("/api/v1/info")
 async def get_project_info(project_id: Optional[str] = None):
     """
@@ -148,9 +159,10 @@ async def get_project_info(project_id: Optional[str] = None):
         "id": project.id,
         "version": "0.1.0",
         "mode": "daemon",
-        "head": current_hash
+        "head": current_hash,
     }
 
+
 @app.get("/api/v1/config/dictionary")
 async def get_ui_dictionary(project_id: Optional[str] = None) -> Dict[str, str]:
     """
@@ -161,29 +173,27 @@ async def get_ui_dictionary(project_id: Optional[str] = None) -> Dict[str, str]:
     config = get_config(str(project.path))
     return config.ui.dictionary
 
+
 @app.get("/api/v1/events")
 async def sse_endpoint(request: Request):
     """
     Server-Sent Events endpoint for real-time updates.
     """
     queue = await broadcaster.subscribe()
-    
+
     async def event_generator():
         try:
             # Quick ping to confirm connection
-            yield {
-                "event": "connect",
-                "data": "connected"
-            }
-            
+            yield {"event": "connect", "data": "connected"}
+
             while True:
                 if await request.is_disconnected():
                     break
-                    
+
                 # Wait for new messages
                 message = await queue.get()
                 yield message
-                
+
         except asyncio.CancelledError:
             logger.debug("SSE connection cancelled")
         finally:
@@ -191,18 +201,21 @@ async def sse_endpoint(request: Request):
 
     return EventSourceResponse(event_generator())
 
+
 @app.get("/api/v1/issues")
 async def get_issues(
     project_id: Optional[str] = None,
-    path: Optional[str] = Query(None, description="Absolute file path for reverse lookup")
+    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.
     """
@@ -211,27 +224,45 @@ async def get_issues(
         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")
-            
+            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
 
-from monoco.features.issue.core import list_issues, create_issue_file, update_issue, delete_issue_file, find_issue_path, parse_issue, get_board_data, parse_issue_detail, update_issue_content
-from monoco.features.issue.models import IssueType, IssueStatus, IssueSolution, IssueStage, IssueMetadata, IssueDetail
-from monoco.daemon.models import CreateIssueRequest, UpdateIssueRequest, UpdateIssueContentRequest
+
+from monoco.features.issue.core import (
+    list_issues,
+    create_issue_file,
+    update_issue,
+    delete_issue_file,
+    find_issue_path,
+    parse_issue,
+    get_board_data,
+    parse_issue_detail,
+    update_issue_content,
+)
+from monoco.features.issue.models import IssueMetadata, IssueDetail
+from monoco.daemon.models import (
+    CreateIssueRequest,
+    UpdateIssueRequest,
+    UpdateIssueContentRequest,
+)
 from monoco.daemon.stats import calculate_dashboard_stats, DashboardStats
 from fastapi import FastAPI, Request, HTTPException
 from typing import Optional, List, Dict
 
 # ... existing code ...
 
+
 @app.get("/api/v1/board")
 async def get_board_endpoint(project_id: Optional[str] = None):
     """
@@ -241,6 +272,7 @@ async def get_board_endpoint(project_id: Optional[str] = None):
     board = get_board_data(project.issues_root)
     return board
 
+
 @app.get("/api/v1/stats/dashboard", response_model=DashboardStats)
 async def get_dashboard_stats_endpoint(project_id: Optional[str] = None):
     """
@@ -256,23 +288,24 @@ async def create_issue_endpoint(payload: CreateIssueRequest):
     Create a new issue.
     """
     project = get_project_or_404(payload.project_id)
-    
+
     try:
         issue, _ = create_issue_file(
-            project.issues_root, 
-            payload.type, 
-            payload.title, 
-            parent=payload.parent, 
-            status=payload.status, 
+            project.issues_root,
+            payload.type,
+            payload.title,
+            parent=payload.parent,
+            status=payload.status,
             stage=payload.stage,
-            dependencies=payload.dependencies, 
-            related=payload.related, 
-            subdir=payload.subdir
+            dependencies=payload.dependencies,
+            related=payload.related,
+            subdir=payload.subdir,
         )
         return issue
     except Exception as e:
         raise HTTPException(status_code=400, detail=str(e))
 
+
 @app.get("/api/v1/issues/{issue_id}", response_model=IssueDetail)
 async def get_issue_endpoint(issue_id: str, project_id: Optional[str] = None):
     """
@@ -286,19 +319,19 @@ async def get_issue_endpoint(issue_id: str, project_id: Optional[str] = None):
         # 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")
-        
+
     issue = parse_issue_detail(path)
     if not issue:
         raise HTTPException(status_code=500, detail=f"Failed to parse issue {issue_id}")
-        
+
     return issue
 
 
@@ -308,66 +341,68 @@ async def update_issue_endpoint(issue_id: str, payload: UpdateIssueRequest):
     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, 
+            project.issues_root,
+            issue_id,
+            status=payload.status,
+            stage=payload.stage,
             solution=payload.solution,
             parent=payload.parent,
             dependencies=payload.dependencies,
             related=payload.related,
-            tags=payload.tags
+            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'))
+            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")
     except ValueError as e:
-         raise HTTPException(status_code=400, detail=str(e))
+        raise HTTPException(status_code=400, detail=str(e))
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
+
 @app.put("/api/v1/issues/{issue_id}/content", response_model=IssueMetadata)
-async def update_issue_content_endpoint(issue_id: str, payload: UpdateIssueContentRequest):
+async def update_issue_content_endpoint(
+    issue_id: str, payload: UpdateIssueContentRequest
+):
     """
     Update raw content of an issue. Validates integrity before saving.
     """
     project = get_project_or_404(payload.project_id)
-    
+
     try:
         # Note: We use PUT because we are replacing the content representation
-        issue = update_issue_content(
-            project.issues_root,
-            issue_id,
-            payload.content
-        )
+        issue = update_issue_content(project.issues_root, issue_id, payload.content)
         return issue
     except FileNotFoundError:
         raise HTTPException(status_code=404, detail=f"Issue {issue_id} not found")
     except ValueError as e:
-         raise HTTPException(status_code=400, detail=str(e))
+        raise HTTPException(status_code=400, detail=str(e))
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
+
 @app.delete("/api/v1/issues/{issue_id}")
 async def delete_issue_endpoint(issue_id: str, project_id: Optional[str] = None):
     """
     Delete an issue (physical removal).
     """
     project = get_project_or_404(project_id)
-    
+
     try:
         delete_issue_file(project.issues_root, issue_id)
         return {"status": "deleted", "id": issue_id}
@@ -376,6 +411,7 @@ async def delete_issue_endpoint(issue_id: str, project_id: Optional[str] = None)
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
+
 @app.post("/api/v1/monitor/refresh")
 async def refresh_monitor():
     """
@@ -385,15 +421,17 @@ async def refresh_monitor():
     # In a real impl, we might force the monitor to wake up.
     # For now, just getting the hash is a good sanity check.
     current_hash = await git_monitor.get_head_hash()
-    
+
     # If we wanted to FORCE broadcast, we could do it here,
     # but the monitor loop will pick it up in <2s anyway.
     # To be "instant", we can manually broadcast if we know it changed?
     # Or just returning the hash confirms the daemon sees it.
     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):
     """
@@ -405,9 +443,10 @@ async def get_execution_profiles(project_id: Optional[str] = None):
     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):
     """
@@ -418,30 +457,35 @@ async def get_execution_profile_detail(path: str):
         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():
     """
     Get the persisted workspace state (e.g. last active project).
     """
     if not project_manager:
-         raise HTTPException(status_code=503, detail="Daemon not initialized")
-    
+        raise HTTPException(status_code=503, detail="Daemon not initialized")
+
     return WorkspaceState.load(project_manager.workspace_root)
 
+
 @app.post("/api/v1/workspace/state", response_model=WorkspaceState)
 async def update_workspace_state(state: WorkspaceState):
     """
     Update the workspace state.
     """
     if not project_manager:
-         raise HTTPException(status_code=503, detail="Daemon not initialized")
+        raise HTTPException(status_code=503, detail="Daemon not initialized")
 
     try:
         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)}")
+        raise HTTPException(
+            status_code=500, detail=f"Failed to persist state: {str(e)}"
+        )

monoco/daemon/commands.py

@@ -7,30 +7,31 @@ from monoco.core.config import get_config
 
 from pathlib import Path
 
+
 def serve(
     host: str = typer.Option("127.0.0.1", "--host", "-h", help="Bind host"),
     port: int = typer.Option(8642, "--port", "-p", help="Bind port"),
-    reload: bool = typer.Option(False, "--reload", "-r", help="Enable auto-reload for dev"),
+    reload: bool = typer.Option(
+        False, "--reload", "-r", help="Enable auto-reload for dev"
+    ),
     root: Optional[str] = typer.Option(None, "--root", help="Workspace root directory"),
 ):
     """
     Start the Monoco Daemon server.
     """
     settings = get_config()
-    
+
     if root:
         os.environ["MONOCO_SERVER_ROOT"] = str(Path(root).resolve())
-        print_output(f"Workspace Root: {os.environ['MONOCO_SERVER_ROOT']}", title="Monoco Serve")
+        print_output(
+            f"Workspace Root: {os.environ['MONOCO_SERVER_ROOT']}", title="Monoco Serve"
+        )
+
+    print_output(
+        f"Starting Monoco Daemon on http://{host}:{port}", title="Monoco Serve"
+    )
 
-    print_output(f"Starting Monoco Daemon on http://{host}:{port}", title="Monoco Serve")
-    
     # We pass the import string to uvicorn to enable reload if needed
     app_str = "monoco.daemon.app:app"
-    
-    uvicorn.run(
-        app_str, 
-        host=host, 
-        port=port, 
-        reload=reload,
-        log_level="info"
-    )
+
+    uvicorn.run(app_str, host=host, port=port, reload=reload, log_level="info")

monoco/daemon/models.py

@@ -1,6 +1,12 @@
 from pydantic import BaseModel
 from typing import Optional, List
-from monoco.features.issue.models import IssueType, IssueStatus, IssueSolution, IssueStage
+from monoco.features.issue.models import (
+    IssueType,
+    IssueStatus,
+    IssueSolution,
+    IssueStage,
+)
+
 
 class CreateIssueRequest(BaseModel):
     type: IssueType
@@ -11,8 +17,9 @@ class CreateIssueRequest(BaseModel):
     dependencies: List[str] = []
     related: List[str] = []
     subdir: Optional[str] = None
-    project_id: Optional[str] = None # Added for multi-project support
-    
+    project_id: Optional[str] = None  # Added for multi-project support
+
+
 class UpdateIssueRequest(BaseModel):
     status: Optional[IssueStatus] = None
     stage: Optional[IssueStage] = None
@@ -23,6 +30,7 @@ class UpdateIssueRequest(BaseModel):
     tags: Optional[List[str]] = None
     project_id: Optional[str] = None
 
+
 class UpdateIssueContentRequest(BaseModel):
     content: str
     project_id: Optional[str] = None

monoco/daemon/reproduce_stats.py

@@ -1,41 +1,41 @@
-
 import sys
 from pathlib import Path
-from datetime import datetime
 
 # Add Toolkit to sys.path
 sys.path.append("/Users/indenscale/Documents/Projects/Monoco/Toolkit")
 
 from monoco.daemon.stats import calculate_dashboard_stats
 
+
 def run():
     issues_root = Path("/Users/indenscale/Documents/Projects/Monoco/Toolkit/Issues")
     print(f"Scanning {issues_root}...")
-    
+
     stats = calculate_dashboard_stats(issues_root)
-    
+
     print(f"Found {len(stats.recent_activities)} activities.")
-    
+
     seen_ids = set()
     for act in stats.recent_activities:
         print(f"[{act.type}] {act.id} - {act.issue_title} ({act.timestamp})")
         if act.id in seen_ids:
             print(f"!!! DUPLICATE ID FOUND: {act.id}")
         seen_ids.add(act.id)
-        
+
         # Check for duplicate issue + type
         # e.g. multiple UPDATED for same issue
-        
+
     # Group by issue
     by_issue = {}
     for act in stats.recent_activities:
         if act.issue_id not in by_issue:
             by_issue[act.issue_id] = []
         by_issue[act.issue_id].append(act)
-        
+
     for issue_id, acts in by_issue.items():
         if len(acts) > 1:
             print(f"Issue {issue_id} has multiple activities: {[a.type for a in acts]}")
 
+
 if __name__ == "__main__":
     run()