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

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 monoco.yaml or .monoco/config.yaml or an Issues 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()

monoco/features/agent/commands.py

@@ -0,0 +1,166 @@
+
+import typer
+from typing import Optional, Annotated
+from pathlib import Path
+from monoco.core.output import print_output, print_error, AgentOutput, OutputManager
+from monoco.core.agent.adapters import get_agent_client
+from monoco.core.agent.state import AgentStateManager
+from monoco.core.agent.action import ActionRegistry, ActionContext
+from monoco.core.config import get_config
+import asyncio
+import re
+import json as j
+
+app = typer.Typer()
+
+@app.command(name="run")
+def run_command(
+    prompt_or_task: str = typer.Argument(..., help="Prompt string OR execution task name (e.g. 'refine-issue')"),
+    target: Optional[str] = typer.Argument(None, help="Target file argument for the task"),
+    provider: Optional[str] = typer.Option(None, "--using", "-u", help="Override agent provider"),
+    instruction: Optional[str] = typer.Option(None, "--instruction", "-i", help="Additional instruction for the agent"),
+    json: AgentOutput = False,
+):
+    """
+    Execute a prompt or a named task using an Agent CLI.
+    """
+    # 0. Setup
+    settings = get_config()
+    state_manager = AgentStateManager()
+    registry = ActionRegistry(Path(settings.paths.root))
+    
+    # 1. Check if it's a named task
+    action = registry.get(prompt_or_task)
+    
+    final_prompt = prompt_or_task
+    context_files = []
+    
+    # Determine Provider Priority: CLI > Action Def > Config > Default
+    prov_name = provider 
+    
+    if action:
+        # It IS an action
+        if not OutputManager.is_agent_mode():
+            print(f"Running action: {action.name}")
+        
+        # Simple template substitution
+        final_prompt = action.template
+        
+        if "{{file}}" in final_prompt:
+             if not target:
+                 print_error("This task requires a target file argument.")
+                 raise typer.Exit(1)
+             
+             target_path = Path(target).resolve()
+             if not target_path.exists():
+                 print_error(f"Target file not found: {target}")
+                 raise typer.Exit(1)
+                 
+             final_prompt = final_prompt.replace("{{file}}", target_path.read_text())
+             # Also add to context files? Ideally the prompt has it.
+             # Let's add it to context files list to be safe if prompt didn't embed it fully
+             context_files.append(target_path)
+             
+        if not prov_name:
+            prov_name = action.provider
+
+    # 2. Append Instruction if provided
+    if instruction:
+        final_prompt = f"{final_prompt}\n\n[USER INSTRUCTION]\n{instruction}"
+
+    # 2. Provider Resolution Fallback
+    prov_name = prov_name or settings.agent.framework or "gemini"
+
+    # 3. State Check
+    state = state_manager.load()
+    if not state or state.is_stale:
+        if not OutputManager.is_agent_mode():
+            print("Agent state stale or missing, refreshing...")
+        state = state_manager.refresh()
+    
+    if prov_name not in state.providers:
+         print_error(f"Provider '{prov_name}' unknown.")
+         raise typer.Exit(1)
+         
+    if not state.providers[prov_name].available:
+         print_error(f"Provider '{prov_name}' is not available. Run 'monoco doctor' to diagnose.")
+         raise typer.Exit(1)
+
+    # 4. Execute
+    try:
+        client = get_agent_client(prov_name)
+        result = asyncio.run(client.execute(final_prompt, context_files=context_files))
+        
+        if OutputManager.is_agent_mode():
+            OutputManager.print({"result": result, "provider": prov_name})
+        else:
+            print(result)
+        
+    except Exception as e:
+        print_error(f"Execution failed: {e}")
+        raise typer.Exit(1)
+
+@app.command()
+def list(
+    json: AgentOutput = False,
+    context: Optional[str] = typer.Option(None, "--context", help="Context for filtering (JSON string)")
+):
+    """List available actions."""
+    settings = get_config()
+    registry = ActionRegistry(Path(settings.paths.root))
+    
+    action_context = None
+    if context:
+        try:
+            ctx_data = j.loads(context)
+            action_context = ActionContext(**ctx_data)
+        except Exception as e:
+            print_error(f"Invalid context JSON: {e}")
+
+    actions = registry.list_available(action_context)
+    # OutputManager handles list of Pydantic models automatically for both JSON and Table
+    print_output(actions, title="Available Actions")
+
+@app.command()
+def status(
+    json: AgentOutput = False,
+    force: bool = typer.Option(False, "--force", "-f", help="Force refresh of agent state")
+):
+    """View status of Agent Providers."""
+    state_manager = AgentStateManager()
+    state = state_manager.get_or_refresh(force=force)
+    
+    if OutputManager.is_agent_mode():
+        # Convert datetime to ISO string for JSON serialization
+        data = state.dict()
+        data["last_checked"] = data["last_checked"].isoformat()
+        OutputManager.print(data)
+    else:
+        # Standard output using existing print_output or custom formatting
+        from monoco.core.output import Table
+        from rich import print as rprint
+        
+        table = Table(title=f"Agent Status (Last Checked: {state.last_checked.strftime('%Y-%m-%d %H:%M:%S')})")
+        table.add_column("Provider")
+        table.add_column("Available")
+        table.add_column("Path")
+        table.add_column("Error")
+        
+        for name, p_state in state.providers.items():
+            table.add_row(
+                name,
+                "✅" if p_state.available else "❌",
+                p_state.path or "-",
+                p_state.error or "-"
+            )
+        rprint(table)
+
+@app.command()
+def doctor(
+    force: bool = typer.Option(False, "--force", "-f", help="Force refresh of agent state")
+):
+    """
+    Diagnose Agent Environment and refresh state.
+    """
+    from monoco.features.agent.doctor import doctor as doc_impl
+    doc_impl(force)

monoco/features/agent/doctor.py

@@ -0,0 +1,30 @@
+import typer
+from monoco.core.output import print_output, print_error
+from monoco.core.agent.state import AgentStateManager
+
+app = typer.Typer()
+
+@app.command()
+def doctor(
+    force: bool = typer.Option(False, "--force", "-f", help="Force refresh of agent state")
+):
+    """
+    Diagnose Agent Environment and refresh state.
+    """
+    manager = AgentStateManager()
+    try:
+        if force:
+            print("Force refreshing agent state...")
+            state = manager.refresh()
+        else:
+            state = manager.get_or_refresh()
+            
+        print_output(state, title="Agent Diagnosis Report")
+        
+        # Simple summary
+        available = [k for k, v in state.providers.items() if v.available]
+        print(f"\n✅ Available Agents: {', '.join(available) if available else 'None'}")
+        
+    except Exception as e:
+        print_error(f"Doctor failed: {e}")
+        raise typer.Exit(1)

monoco/features/config/commands.py

@@ -1,70 +1,151 @@
 import typer
 import yaml
+import json
 from pathlib import Path
-from typing import Optional
-from monoco.core.config import get_config, MonocoConfig
-from monoco.core.output import print_output
+from typing import Optional, Any, Annotated
 from rich.console import Console
+from rich.syntax import Syntax
+from pydantic import ValidationError
+
+from monoco.core.config import (
+    get_config,
+    MonocoConfig,
+    ConfigScope,
+    load_raw_config,
+    save_raw_config,
+    get_config_path
+)
+from monoco.core.output import AgentOutput, OutputManager
 
 app = typer.Typer(help="Manage Monoco configuration")
 console = Console()
 
+def _parse_value(value: str) -> Any:
+    """Parse string value into appropriate type (bool, int, float, str)."""
+    if value.lower() in ("true", "yes", "on"):
+        return True
+    if value.lower() in ("false", "no", "off"):
+        return False
+    if value.lower() == "null":
+        return None
+    try:
+        return int(value)
+    except ValueError:
+        try:
+            return float(value)
+        except ValueError:
+            return value
+
+@app.command()
+def show(
+    output: str = typer.Option("yaml", "--output", "-o", help="Output format: yaml or json"),
+    json_output: AgentOutput = False,
+):
+    """Show the currently active (merged) configuration."""
+    config = get_config()
+    # Pydantic v1/v2 compat: use dict() or model_dump()
+    data = config.dict()
+    
+    if OutputManager.is_agent_mode():
+        OutputManager.print(data)
+        return
+
+    if output == "json":
+        print(json.dumps(data, indent=2))
+    else:
+        yaml_str = yaml.dump(data, default_flow_style=False)
+        syntax = Syntax(yaml_str, "yaml")
+        console.print(syntax)
+
 @app.command()
-def show():
-    """Show current configuration."""
-    settings = get_config()
-    print_output(settings, title="Current Configuration")
+def get(
+    key: str = typer.Argument(..., help="Configuration key (e.g. project.name)"),
+    json_output: AgentOutput = False,
+):
+    """Get a specific configuration value."""
+    config = get_config()
+    data = config.dict()
+    
+    parts = key.split(".")
+    current = data
+    
+    for part in parts:
+        if isinstance(current, dict) and part in current:
+            current = current[part]
+        else:
+            OutputManager.error(f"Key '{key}' not found.")
+            raise typer.Exit(code=1)
+            
+    if OutputManager.is_agent_mode():
+        OutputManager.print({"key": key, "value": current})
+    else:
+        if isinstance(current, (dict, list)):
+            if isinstance(current, dict):
+                print(yaml.dump(current, default_flow_style=False))
+            else:
+                print(json.dumps(current))
+        else:
+            print(current)
 
 @app.command(name="set")
 def set_val(
     key: str = typer.Argument(..., help="Config key (e.g. telemetry.enabled)"),
     value: str = typer.Argument(..., help="Value to set"),
-    scope: str = typer.Option("global", "--scope", "-s", help="Configuration scope: global or project")
+    global_scope: bool = typer.Option(False, "--global", "-g", help="Update global configuration"),
+    json_output: AgentOutput = False,
 ):
-    """Set a configuration value."""
-    # This is a simplified implementation of config setting
-    # In a real system, we'd want to validate the key against the schema
+    """Set a configuration value in specific scope (project by default)."""
+    scope = ConfigScope.GLOBAL if global_scope else ConfigScope.PROJECT
     
-    if scope == "global":
-        config_path = Path.home() / ".monoco" / "config.yaml"
-    else:
-        # Check project root
-        cwd = Path.cwd()
-        config_path = cwd / ".monoco" / "config.yaml"
-        if not (cwd / ".monoco").exists():
-             config_path = cwd / "monoco.yaml"
-
-    config_data = {}
-    if config_path.exists():
-        with open(config_path, "r") as f:
-            config_data = yaml.safe_load(f) or {}
-
-    # Simple nested key support (e.g. telemetry.enabled)
+    # 1. Load Raw Config for the target scope
+    raw_data = load_raw_config(scope)
+    
+    # 2. Parse Key & Update Data
     parts = key.split(".")
-    target = config_data
-    for part in parts[:-1]:
+    target = raw_data
+    
+    # Context management for nested updates
+    for i, part in enumerate(parts[:-1]):
         if part not in target:
             target[part] = {}
         target = target[part]
+        if not isinstance(target, dict):
+            parent_key = ".".join(parts[:i+1])
+            OutputManager.error(f"Cannot set '{key}': '{parent_key}' is not a dictionary ({type(target)}).")
+            raise typer.Exit(code=1)
+            
+    parsed_val = _parse_value(value)
+    target[parts[-1]] = parsed_val
     
-    # Type conversion
-    if value.lower() in ("true", "yes", "on"):
-        val = True
-    elif value.lower() in ("false", "no", "off"):
-        val = False
-    else:
-        try:
-            val = int(value)
-        except ValueError:
-            val = value
+    # 3. Validate against Schema
+    # We simulate a full load by creating a temporary MonocoConfig with these overrides.
+    # Note: This validation is "active" - we want to ensure the resulting config WOULD be valid.
+    # However, raw_data is partial. Pydantic models with defaults will accept partials.
+    try:
+        # We can try to validate just the relevant model part if we knew which one it was.
+        # But simpler is to check if MonocoConfig accepts this structure.
+        MonocoConfig(**raw_data)
+    except ValidationError as e:
+        OutputManager.error(f"Validation failed for key '{key}':\n{e}")
+        raise typer.Exit(code=1)
+    except Exception as e:
+        OutputManager.error(f"Unexpected validation error: {e}")
+        raise typer.Exit(code=1)
 
-    target[parts[-1]] = val
-
-    config_path.parent.mkdir(parents=True, exist_ok=True)
-    with open(config_path, "w") as f:
-        yaml.dump(config_data, f, default_flow_style=False)
+    # 4. Save
+    save_raw_config(scope, raw_data)
+    
+    scope_display = "Global" if global_scope else "Project"
     
-    console.print(f"[green]✓ Set {key} = {val} in {scope} config.[/green]")
+    if OutputManager.is_agent_mode():
+        OutputManager.print({
+            "status": "updated",
+            "scope": scope_display.lower(),
+            "key": key,
+            "value": parsed_val
+        })
+    else:
+        console.print(f"[green]✓ Set {key} = {parsed_val} in {scope_display} config.[/green]")
 
 if __name__ == "__main__":
     app()

monoco/features/i18n/adapter.py

@@ -0,0 +1,29 @@
+from pathlib import Path
+from typing import Dict
+from monoco.core.feature import MonocoFeature, IntegrationData
+from monoco.features.i18n import core
+
+class I18nFeature(MonocoFeature):
+    @property
+    def name(self) -> str:
+        return "i18n"
+
+    def initialize(self, root: Path, config: Dict) -> None:
+        core.init(root)
+
+    def integrate(self, root: Path, config: Dict) -> IntegrationData:
+        # Determine language from config, default to 'en'
+        lang = config.get("i18n", {}).get("source_lang", "en")
+        base_dir = Path(__file__).parent / "resources"
+        
+        prompt_file = base_dir / lang / "AGENTS.md"
+        if not prompt_file.exists():
+            prompt_file = base_dir / "en" / "AGENTS.md"
+            
+        content = ""
+        if prompt_file.exists():
+            content = prompt_file.read_text(encoding="utf-8").strip()
+
+        return IntegrationData(
+            system_prompts={"Documentation I18n": content}
+        )