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

monoco/cli/project.py

@@ -0,0 +1,87 @@
+import typer
+from pathlib import Path
+from typing import Optional, Annotated
+from rich.console import Console
+from rich.table import Table
+import yaml
+import json
+import os
+
+from monoco.core.workspace import find_projects, is_project_root
+from monoco.core.config import get_config
+from monoco.core.output import AgentOutput, OutputManager
+
+app = typer.Typer(help="Manage Monoco Projects")
+console = Console()
+
+@app.command("list")
+def list_projects(
+    json: AgentOutput = False,
+    root: Optional[str] = typer.Option(None, "--root", help="Workspace root")
+):
+    """List all discovered projects in the workspace."""
+    cwd = Path(root).resolve() if root else Path.cwd()
+    projects = find_projects(cwd)
+    
+    if OutputManager.is_agent_mode():
+        data = [
+            {
+                "id": p.id,
+                "name": p.name,
+                "path": str(p.path),
+                "key": p.config.project.key if p.config.project else ""
+            }
+            for p in projects
+        ]
+        OutputManager.print(data)
+    else:
+        table = Table(title=f"Projects in {cwd}")
+        table.add_column("ID", style="cyan")
+        table.add_column("Name", style="magenta")
+        table.add_column("Key", style="green")
+        table.add_column("Path", style="dim")
+        
+        for p in projects:
+            path_str = str(p.path.relative_to(cwd)) if p.path.is_relative_to(cwd) else str(p.path)
+            if path_str == ".":
+                path_str = "(root)"
+            key = p.config.project.key if p.config.project else "N/A"
+            table.add_row(p.id, p.name, key, path_str)
+            
+        console.print(table)
+
+@app.command("init")
+def init_project(
+    name: str = typer.Option(..., "--name", "-n", help="Project Name"),
+    key: str = typer.Option(..., "--key", "-k", help="Project Key"),
+    force: bool = typer.Option(False, "--force", "-f", help="Overwrite existing config"),
+    json: AgentOutput = False,
+):
+    """Initialize a new project in the current directory."""
+    cwd = Path.cwd()
+    project_config_path = cwd / ".monoco" / "project.yaml"
+    
+    if project_config_path.exists() and not force:
+        OutputManager.error(f"Project already initialized in {cwd}. Use --force to overwrite.")
+        raise typer.Exit(code=1)
+        
+    cwd.mkdir(parents=True, exist_ok=True)
+    (cwd / ".monoco").mkdir(exist_ok=True)
+    
+    config = {
+        "project": {
+            "name": name,
+            "key": key
+        }
+    }
+    
+    with open(project_config_path, "w") as f:
+        yaml.dump(config, f, default_flow_style=False)
+        
+    OutputManager.print({
+        "status": "initialized",
+        "name": name,
+        "key": key,
+        "path": str(cwd),
+        "config_file": str(project_config_path)
+    })

monoco/cli/workspace.py

@@ -0,0 +1,46 @@
+import typer
+from pathlib import Path
+from rich.console import Console
+from typing import Annotated
+import yaml
+import json
+
+from monoco.core.output import AgentOutput, OutputManager
+
+app = typer.Typer(help="Manage Monoco Workspace")
+console = Console()
+
+@app.command("init")
+def init_workspace(
+    force: bool = typer.Option(False, "--force", "-f", help="Overwrite existing config"),
+    json: AgentOutput = False,
+):
+    """Initialize a workspace environment in the current directory."""
+    cwd = Path.cwd()
+    workspace_config_path = cwd / ".monoco" / "workspace.yaml"
+    
+    if workspace_config_path.exists() and not force:
+        OutputManager.error(f"Workspace already initialized in {cwd}. Use --force to overwrite.")
+        raise typer.Exit(code=1)
+
+    cwd.mkdir(parents=True, exist_ok=True)
+    (cwd / ".monoco").mkdir(exist_ok=True)
+    
+    # Default workspace config
+    config = {
+        "paths": {
+            "issues": "Issues", # Default
+            "spikes": ".references",
+            "specs": "SPECS"
+        }
+    }
+    
+    with open(workspace_config_path, "w") as f:
+        yaml.dump(config, f, default_flow_style=False)
+        
+    OutputManager.print({
+        "status": "initialized",
+        "path": str(cwd),
+        "config_file": str(workspace_config_path)
+    })
+

monoco/core/agent/__init__.py

@@ -0,0 +1,5 @@
+"""
+Monoco Agent Execution Layer.
+"""
+
+from .state import AgentStateManager, AgentState, AgentProviderState

monoco/core/agent/action.py

@@ -0,0 +1,144 @@
+
+import re
+import yaml
+from pathlib import Path
+from typing import Dict, List, Optional, Any
+from pydantic import BaseModel, Field
+
+class ActionContext(BaseModel):
+    """Context information for matching actions."""
+    id: Optional[str] = None
+    type: Optional[str] = None
+    stage: Optional[str] = None
+    status: Optional[str] = None
+    file_path: Optional[str] = None
+    project_id: Optional[str] = None
+
+class ActionWhen(BaseModel):
+    """Conditions under which an action should be displayed/active."""
+    idMatch: Optional[str] = None
+    typeMatch: Optional[str] = None
+    stageMatch: Optional[str] = None
+    statusMatch: Optional[str] = None
+    fileMatch: Optional[str] = None
+
+    def matches(self, context: ActionContext) -> bool:
+        """Evaluate if the context matches these criteria."""
+        if self.idMatch and context.id and not re.match(self.idMatch, context.id):
+            return False
+        if self.typeMatch and context.type and not re.match(self.typeMatch, context.type):
+            return False
+        if self.stageMatch and context.stage and not re.match(self.stageMatch, context.stage):
+            return False
+        if self.statusMatch and context.status and not re.match(self.statusMatch, context.status):
+            return False
+        if self.fileMatch and context.file_path and not re.match(self.fileMatch, context.file_path):
+            return False
+        return True
+
+class PromptyAction(BaseModel):
+    name: str
+    description: str
+    version: Optional[str] = "1.0.0"
+    authors: List[str] = []
+    model: Dict[str, Any] = {}
+    inputs: Dict[str, Any] = {}
+    outputs: Dict[str, Any] = {}
+    template: str
+    when: Optional[ActionWhen] = None
+    
+    # Monoco specific metadata
+    path: Optional[str] = None
+    provider: Optional[str] = None # Derived from model.api or explicitly set
+
+class ActionRegistry:
+    def __init__(self, project_root: Optional[Path] = None):
+        self.project_root = project_root
+        self._actions: List[PromptyAction] = []
+
+    def scan(self) -> List[PromptyAction]:
+        """Scan user global and project local directories for .prompty files."""
+        self._actions = []
+        
+        # 1. User Global: ~/.monoco/actions/
+        user_dir = Path.home() / ".monoco" / "actions"
+        self._scan_dir(user_dir)
+
+        # 2. Project Local: {project_root}/.monoco/actions/
+        if self.project_root:
+            project_dir = self.project_root / ".monoco" / "actions"
+            self._scan_dir(project_dir)
+            
+        return self._actions
+
+    def _scan_dir(self, directory: Path):
+        if not directory.exists():
+            return
+
+        for prompty_file in directory.glob("*.prompty"):
+            try:
+                action = self._load_action(prompty_file)
+                if action:
+                    self._actions.append(action)
+            except Exception as e:
+                print(f"Failed to load action {prompty_file}: {e}")
+
+    def _load_action(self, file_path: Path) -> Optional[PromptyAction]:
+        content = file_path.read_text(encoding="utf-8")
+        
+        # Prompty Parser (Standard YAML Frontmatter + Body)
+        # We look for the first --- and the second ---
+        parts = re.split(r"^---\s*$", content, maxsplit=2, flags=re.MULTILINE)
+        
+        if len(parts) < 3:
+            return None
+
+        frontmatter_raw = parts[1]
+        body = parts[2].strip()
+        
+        try:
+            meta = yaml.safe_load(frontmatter_raw)
+            if not meta or "name" not in meta:
+                # Use filename as fallback name if missing? Prompty usually requires name.
+                if not meta: meta = {}
+                meta["name"] = meta.get("name", file_path.stem)
+
+            # Map Prompty 'when' if present
+            when_data = meta.get("when")
+            when = ActionWhen(**when_data) if when_data else None
+            
+            action = PromptyAction(
+                name=meta["name"],
+                description=meta.get("description", ""),
+                version=meta.get("version"),
+                authors=meta.get("authors", []),
+                model=meta.get("model", {}),
+                inputs=meta.get("inputs", {}),
+                outputs=meta.get("outputs", {}),
+                template=body,
+                when=when,
+                path=str(file_path.absolute()),
+                provider=meta.get("provider") or meta.get("model", {}).get("api")
+            )
+            return action
+            
+        except Exception as e:
+            print(f"Invalid Prompty in {file_path}: {e}")
+            return None
+
+    def list_available(self, context: Optional[ActionContext] = None) -> List[PromptyAction]:
+        if not self._actions:
+            self.scan()
+        
+        if not context:
+            return self._actions
+            
+        return [a for a in self._actions if not a.when or a.when.matches(context)]
+
+    def get(self, name: str) -> Optional[PromptyAction]:
+        if not self._actions:
+            self.scan()
+        for a in self._actions:
+            if a.name == name:
+                return a
+        return None

monoco/core/agent/adapters.py

@@ -0,0 +1,129 @@
+"""
+CLI Adapters for Agent Frameworks.
+"""
+
+import shutil
+import subprocess
+from typing import List
+from pathlib import Path
+from .protocol import AgentClient
+
+class BaseCLIClient:
+    def __init__(self, executable: str):
+        self._executable = executable
+
+    @property
+    def name(self) -> str:
+        return self._executable
+
+    async def available(self) -> bool:
+        return shutil.which(self._executable) is not None
+
+    def _build_prompt(self, prompt: str, context_files: List[Path]) -> str:
+        """Concatenate prompt and context files."""
+        # Inject Language Rule
+        try:
+            from monoco.core.config import get_config
+            settings = get_config()
+            lang = settings.i18n.source_lang
+            if lang:
+                 prompt = f"{prompt}\n\n[SYSTEM: LANGUAGE CONSTRAINT]\nThe project source language is '{lang}'. You MUST use '{lang}' for all thinking and reporting unless explicitly instructed otherwise."
+        except Exception:
+            pass
+
+        full_prompt = [prompt]
+        if context_files:
+            full_prompt.append("\n\n--- CONTEXT FILES ---")
+            for file_path in context_files:
+                try:
+                    full_prompt.append(f"\nFile: {file_path}")
+                    full_prompt.append("```")
+                    # Read file content safely
+                    full_prompt.append(file_path.read_text(encoding="utf-8", errors="replace"))
+                    full_prompt.append("```")
+                except Exception as e:
+                    full_prompt.append(f"Error reading {file_path}: {e}")
+            full_prompt.append("--- END CONTEXT ---\n")
+        return "\n".join(full_prompt)
+
+    async def _run_command(self, args: List[str]) -> str:
+        """Run the CLI command and return stdout."""
+        # Using synchronous subprocess in async function for now
+        # Ideally this should use asyncio.create_subprocess_exec
+        import asyncio
+        
+        proc = await asyncio.create_subprocess_exec(
+            *args,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE
+        )
+        
+        stdout, stderr = await proc.communicate()
+        
+        if proc.returncode != 0:
+            error_msg = stderr.decode().strip()
+            raise RuntimeError(f"Agent CLI failed (code {proc.returncode}): {error_msg}")
+            
+        return stdout.decode().strip()
+
+
+class GeminiClient(BaseCLIClient, AgentClient):
+    """Adapter for Google Gemini CLI."""
+    
+    def __init__(self):
+        super().__init__("gemini")
+
+    async def execute(self, prompt: str, context_files: List[Path] = []) -> str:
+        full_prompt = self._build_prompt(prompt, context_files)
+        # Usage: gemini "prompt"
+        return await self._run_command([self._executable, full_prompt])
+
+
+class ClaudeClient(BaseCLIClient, AgentClient):
+    """Adapter for Anthropic Claude CLI."""
+    
+    def __init__(self):
+        super().__init__("claude")
+
+    async def execute(self, prompt: str, context_files: List[Path] = []) -> str:
+        full_prompt = self._build_prompt(prompt, context_files)
+        # Usage: claude -p "prompt"
+        return await self._run_command([self._executable, "-p", full_prompt])
+
+
+class QwenClient(BaseCLIClient, AgentClient):
+    """Adapter for Alibaba Qwen CLI."""
+    
+    def __init__(self):
+        super().__init__("qwen")
+
+    async def execute(self, prompt: str, context_files: List[Path] = []) -> str:
+        full_prompt = self._build_prompt(prompt, context_files)
+        # Usage: qwen "prompt"
+        return await self._run_command([self._executable, full_prompt])
+
+
+class KimiClient(BaseCLIClient, AgentClient):
+    """Adapter for Moonshot Kimi CLI."""
+    
+    def __init__(self):
+        super().__init__("kimi")
+
+    async def execute(self, prompt: str, context_files: List[Path] = []) -> str:
+        full_prompt = self._build_prompt(prompt, context_files)
+        # Usage: kimi "prompt"
+        return await self._run_command([self._executable, full_prompt])
+
+
+_ADAPTERS = {
+    "gemini": GeminiClient,
+    "claude": ClaudeClient,
+    "qwen": QwenClient,
+    "kimi": KimiClient
+}
+
+def get_agent_client(name: str) -> AgentClient:
+    """Factory to get agent client by name."""
+    if name not in _ADAPTERS:
+        raise ValueError(f"Unknown agent provider: {name}")
+    return _ADAPTERS[name]()

monoco/core/agent/protocol.py

@@ -0,0 +1,31 @@
+"""
+Protocol definition for Agent Clients.
+"""
+
+from typing import Protocol, List, Optional
+from pathlib import Path
+
+class AgentClient(Protocol):
+    """Protocol for interacting with CLI-based agents."""
+    
+    @property
+    def name(self) -> str:
+        """Name of the agent provider (e.g. 'gemini', 'claude')."""
+        ...
+
+    async def available(self) -> bool:
+        """Check if the agent is available in the current environment."""
+        ...
+
+    async def execute(self, prompt: str, context_files: List[Path] = []) -> str:
+        """
+        Execute a prompt against the agent.
+        
+        Args:
+            prompt: The main instructions.
+            context_files: List of files to provide as context.
+            
+        Returns:
+            The raw string response from the agent.
+        """
+        ...

monoco/core/agent/state.py

@@ -0,0 +1,106 @@
+"""
+Agent State Management.
+
+Handles persistence and retrieval of agent availability state.
+"""
+
+import yaml
+import shutil
+import subprocess
+import logging
+from pathlib import Path
+from datetime import datetime, timezone
+from typing import Dict, Optional
+from pydantic import BaseModel, Field
+
+logger = logging.getLogger("monoco.core.agent.state")
+
+class AgentProviderState(BaseModel):
+    available: bool
+    path: Optional[str] = None
+    error: Optional[str] = None
+    latency_ms: Optional[int] = None
+
+class AgentState(BaseModel):
+    last_checked: datetime
+    providers: Dict[str, AgentProviderState]
+
+    @property
+    def is_stale(self) -> bool:
+        """Check if the state is older than 7 days."""
+        delta = datetime.now(timezone.utc) - self.last_checked
+        return delta.days > 7
+
+class AgentStateManager:
+    def __init__(self, state_path: Path = Path.home() / ".monoco" / "agent_state.yaml"):
+        self.state_path = state_path
+        self._state: Optional[AgentState] = None
+
+    def load(self) -> Optional[AgentState]:
+        """Load state from file, returning None if missing or invalid."""
+        if not self.state_path.exists():
+            return None
+        
+        try:
+            with open(self.state_path, "r") as f:
+                data = yaml.safe_load(f)
+                if not data:
+                    return None
+                # Handle ISO string to datetime conversion if needed provided by Pydantic mostly
+                return AgentState(**data)
+        except Exception as e:
+            logger.warning(f"Failed to load agent state: {e}")
+            return None
+
+    def get_or_refresh(self, force: bool = False) -> AgentState:
+        """Get current state, refreshing if missing, stale, or forced."""
+        if not force:
+            self._state = self.load()
+            if self._state and not self._state.is_stale:
+                return self._state
+        
+        return self.refresh()
+
+    def refresh(self) -> AgentState:
+        """Run diagnostics on all integrations and update state."""
+        logger.info("Refreshing agent state...")
+        
+        from monoco.core.integrations import get_all_integrations
+        from monoco.core.config import get_config
+        
+        # Load config to get possible overrides
+        # Determine root (hacky for now, should be passed)
+        root = Path.cwd()
+        config = get_config(str(root))
+        
+        integrations = get_all_integrations(config_overrides=config.agent.integrations, enabled_only=True)
+        
+        providers = {}
+        for key, integration in integrations.items():
+            if not integration.bin_name:
+                continue # Skip integrations that don't have a binary component
+            
+            health = integration.check_health()
+            providers[key] = AgentProviderState(
+                available=health.available,
+                path=health.path,
+                error=health.error,
+                latency_ms=health.latency_ms
+            )
+            
+        state = AgentState(
+            last_checked=datetime.now(timezone.utc),
+            providers=providers
+        )
+        
+        # Save state
+        self.state_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(self.state_path, "w") as f:
+            yaml.dump(state.model_dump(mode='json'), f)
+            
+        self._state = state
+        return state
+
+    def _find_script(self) -> Optional[Path]:
+        """[Deprecated] No longer used."""
+        return None