monoco-toolkit 0.1.0__py3-none-any.whl → 0.2.5__py3-none-any.whl

monoco/core/sync.py

@@ -0,0 +1,224 @@
+import typer
+from pathlib import Path
+from typing import Optional, List
+from monoco.core.registry import FeatureRegistry
+from monoco.core.injection import PromptInjector
+from monoco.core.config import get_config
+from monoco.core.skills import SkillManager
+from monoco.core.integrations import get_active_integrations
+from rich.console import Console
+
+console = Console()
+
+def _get_targets(root: Path, config, cli_target: Optional[Path]) -> List[Path]:
+    """Helper to determine target files."""
+    targets = []
+    
+    # 1. CLI Target
+    if cli_target:
+        targets.append(cli_target)
+        return targets
+
+    # 2. Config Targets
+    if config.agent.targets:
+        for t in config.agent.targets:
+            targets.append(root / t)
+        return targets
+
+    # 3. Registry Defaults (Dynamic Detection)
+    integrations = get_active_integrations(
+        root,
+        config_overrides=config.agent.integrations,
+        auto_detect=True
+    )
+    
+    if integrations:
+        for integration in integrations.values():
+            targets.append(root / integration.system_prompt_file)
+    else:
+        # Fallback to standard Monoco header if nothing is detected
+        # but we usually want at least one target for a generic sync.
+        defaults = ["GEMINI.md", "CLAUDE.md"]
+        targets.extend([root / fname for fname in defaults])
+    
+    return list(set(targets)) # Unique paths
+
+def sync_command(
+    ctx: typer.Context,
+    target: Optional[Path] = typer.Option(None, "--target", "-t", help="Specific file to update (default: auto-detect from config or standard files)"),
+    check: bool = typer.Option(False, "--check", help="Dry run check mode")
+):
+    """
+    Synchronize Agent Environment (System Prompts & Skills).
+    Aggregates prompts from all active features and injects them into the agent configuration files.
+    """
+    root = Path.cwd() # TODO: Use workspace root detection properly if needed
+    
+    # 0. Load Config
+    config = get_config(str(root))
+    
+    # 1. Register Features
+    registry = FeatureRegistry()
+    registry.load_defaults()
+    
+    # 2. Collect Data
+    collected_prompts = {}
+    
+    # Filter features based on config if specified
+    all_features = registry.get_features()
+    active_features = []
+    
+    if config.agent.includes:
+        for f in all_features:
+            if f.name in config.agent.includes:
+                active_features.append(f)
+    else:
+        active_features = all_features
+
+    with console.status("[bold green]Collecting feature integration data...") as status:
+        for feature in active_features:
+            status.update(f"Scanning Feature: {feature.name}")
+            try:
+                data = feature.integrate(root, config.model_dump())
+                if data:
+                    if data.system_prompts:
+                        collected_prompts.update(data.system_prompts)
+            except Exception as e:
+                console.print(f"[red]Error integrating feature {feature.name}: {e}[/red]")
+                
+    console.print(f"[blue]Collected {len(collected_prompts)} prompts from {len(active_features)} features.[/blue]")
+
+    # 3. Distribute Skills
+    console.print(f"[bold blue]Distributing skills to agent frameworks...[/bold blue]")
+    
+    # Determine language from config
+    skill_lang = config.i18n.source_lang if config.i18n.source_lang else 'en'
+    console.print(f"[dim]  Using language: {skill_lang}[/dim]")
+    
+    # Initialize SkillManager with active features
+    skill_manager = SkillManager(root, active_features)
+    
+    # Get active integrations
+    integrations = get_active_integrations(
+        root,
+        config_overrides=config.agent.integrations,
+        auto_detect=True
+    )
+    
+    if integrations:
+        for framework_key, integration in integrations.items():
+            skill_target_dir = root / integration.skill_root_dir
+            console.print(f"[dim]  Distributing to {integration.name} ({skill_target_dir})...[/dim]")
+            
+            try:
+                # Distribute only the configured language version
+                results = skill_manager.distribute(skill_target_dir, lang=skill_lang, force=False)
+                success_count = sum(1 for v in results.values() if v)
+                console.print(f"[green]  ✓ Distributed {success_count}/{len(results)} skills to {integration.name}[/green]")
+            except Exception as e:
+                console.print(f"[red]  Failed to distribute skills to {integration.name}: {e}[/red]")
+    else:
+        console.print(f"[yellow]No agent frameworks detected. Skipping skill distribution.[/yellow]")
+
+    # 4. Determine Targets
+    targets = _get_targets(root, config, target)
+    
+    # Ensure targets exist for sync
+    final_targets = []
+    for t in targets:
+        if not t.exists():
+            # If explicit target, fail? Or create?
+            # If default, create.
+            if target: 
+                # CLI target
+                console.print(f"[yellow]Creating {t.name}...[/yellow]")
+                try:
+                    t.touch()
+                    final_targets.append(t)
+                except Exception as e:
+                    console.print(f"[red]Failed to create {t}: {e}[/red]")
+            else:
+                # Default/Config target -> only create if it's one of the defaults we manage?
+                # For now, let's just create it to be safe, assuming user wants it.
+                console.print(f"[yellow]Creating {t.name}...[/yellow]")
+                try:
+                    t.touch()
+                    final_targets.append(t)
+                except Exception as e:
+                    console.print(f"[red]Failed to create {t}: {e}[/red]")
+        else:
+            final_targets.append(t)
+
+    # 5. Inject System Prompts
+    for t in final_targets:
+        injector = PromptInjector(t)
+        
+        if check:
+             console.print(f"[dim][Dry Run] Would check/update {t.name}[/dim]")
+        else:
+            try:
+                changed = injector.inject(collected_prompts)
+                if changed:
+                    console.print(f"[green]✓ Updated {t.name}[/green]")
+                else:
+                    console.print(f"[dim]= {t.name} is up to date[/dim]")
+            except Exception as e:
+                console.print(f"[red]Failed to update {t.name}: {e}[/red]")
+
+def uninstall_command(
+    ctx: typer.Context,
+    target: Optional[Path] = typer.Option(None, "--target", "-t", help="Specific file to clean (default: auto-detect from config or standard files)")
+):
+    """
+    Remove Monoco Managed Block from Agent Environment files and clean up distributed skills.
+    """
+    root = Path.cwd()
+    config = get_config(str(root))
+    
+    # 1. Clean up System Prompts
+    targets = _get_targets(root, config, target)
+    
+    for t in targets:
+        if not t.exists():
+            if target:
+                 console.print(f"[yellow]Target {t} does not exist.[/yellow]")
+            continue
+            
+        injector = PromptInjector(t)
+        try:
+            changed = injector.remove()
+            if changed:
+                console.print(f"[green]✓ Removed Monoco Managed Block from {t.name}[/green]")
+            else:
+                console.print(f"[dim]= No Monoco Block found in {t.name}[/dim]")
+        except Exception as e:
+            console.print(f"[red]Failed to uninstall from {t.name}: {e}[/red]")
+    
+    # 2. Clean up Skills
+    console.print(f"[bold blue]Cleaning up distributed skills...[/bold blue]")
+    
+    # Load features to get skill list
+    registry = FeatureRegistry()
+    registry.load_defaults()
+    active_features = registry.get_features()
+    
+    skill_manager = SkillManager(root, active_features)
+    
+    # Get active integrations
+    integrations = get_active_integrations(
+        root,
+        config_overrides=config.agent.integrations,
+        auto_detect=True
+    )
+    
+    if integrations:
+        for framework_key, integration in integrations.items():
+            skill_target_dir = root / integration.skill_root_dir
+            console.print(f"[dim]  Cleaning {integration.name} ({skill_target_dir})...[/dim]")
+            
+            try:
+                skill_manager.cleanup(skill_target_dir)
+            except Exception as e:
+                console.print(f"[red]  Failed to clean skills from {integration.name}: {e}[/red]")
+    else:
+        console.print(f"[yellow]No agent frameworks detected. Skipping skill cleanup.[/yellow]")

monoco/core/telemetry.py

@@ -1,7 +1,7 @@
 import os
 import uuid
 import json
-import httpx
+
 import time
 from pathlib import Path
 from typing import Optional, Dict, Any
@@ -73,7 +73,10 @@ class Telemetry:
 
         # Send asynchronously? For now, we'll do a simple non-blocking-ish call
         try:
+            import httpx
             httpx.post(f"{POSTHOG_HOST}/capture/", json=data, timeout=1.0)
+        except ImportError:
+            pass # Telemetry is optional
         except Exception:
             pass
 

monoco/core/workspace.py

@@ -1,40 +1,105 @@
+import os
 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.yaml
-    - OR has .monoco/config.yaml
-    - OR has Issues/ directory
+    - has .monoco/ directory (which should contain project.yaml)
     """
     if not path.is_dir():
         return False
         
-    return (path / "monoco.yaml").exists() or \
-           (path / ".monoco" / "config.yaml").exists() or \
-           (path / "Issues").exists()
+    return (path / ".monoco").is_dir()
+
+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[Path]:
+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)
+    # 2. Recursive Scan
+    for root, dirs, files in os.walk(workspace_root):
+        # Skip hidden directories and node_modules
+        dirs[:] = [d for d in dirs if not d.startswith('.') and d != 'node_modules' and d != 'venv']
+        
+        for d in dirs:
+            project_path = Path(root) / d
+            # Avoid re-adding root if it was somehow added (unlikely here)
+            if project_path == workspace_root: continue
+            
+            if is_project_root(project_path):
+                p = load_project(project_path)
+                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,8 +6,9 @@ import asyncio
 import logging
 import os
 from typing import Optional, List, Dict
-from monoco.daemon.services import Broadcaster, GitMonitor, ProjectManager
-from fastapi import FastAPI, Request, HTTPException, Query
+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
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
@@ -15,6 +16,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 +27,8 @@ Monoco Daemon Process
 
 # Service Instances
 broadcaster = Broadcaster()
-git_monitor = GitMonitor(broadcaster)
+git_monitor: GitMonitor | None = None
+config_monitors: List[ConfigMonitor] = []
 project_manager: ProjectManager | None = None
 
 @asynccontextmanager
@@ -33,23 +36,52 @@ async def lifespan(app: FastAPI):
     # Startup
     logger.info("Starting Monoco Daemon services...")
     
-    global project_manager
+    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
+        })
+    
+    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()
-    monitor_task = asyncio.create_task(git_monitor.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...")
-    git_monitor.stop()
+    if git_monitor:
+        git_monitor.stop()
+    for m in config_monitors:
+        m.stop()
     if project_manager:
         project_manager.stop_all()
-    await monitor_task
+    
+    await git_task
+    await asyncio.gather(*config_tasks)
     
 app = FastAPI(
     title="Monoco Daemon",
@@ -160,10 +192,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 +276,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 +301,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 +392,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 ---
+
+@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)
 
-class WorkspaceState(BaseModel):
-    last_active_project_id: Optional[str] = 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 +429,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 +439,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):