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

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,106 @@
+"""
+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."""
+        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])
+
+
+_ADAPTERS = {
+    "gemini": GeminiClient,
+    "claude": ClaudeClient,
+    "qwen": QwenClient
+}
+
+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,117 @@
+"""
+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 the diagnostic script and update state file."""
+        logger.info("Refreshing agent state...")
+        
+        # Locate the shell script
+        # Assuming monoco is installed as a package, we need to find where the script lives.
+        # For dev environment: Toolkit/scripts/check_agents.sh
+        # For production: It might need to be packaged or generated.
+        
+        # Current strategy: Look in known relative locations
+        script_path = self._find_script()
+        if not script_path:
+            raise FileNotFoundError("Could not find check_agents.sh script")
+
+        try:
+            # Ensure the directory exists
+            self.state_path.parent.mkdir(parents=True, exist_ok=True)
+            
+            subprocess.run(
+                [str(script_path), str(self.state_path)], 
+                check=True, 
+                capture_output=True,
+                text=True
+            )
+            
+            # Reload to get the object
+            state = self.load()
+            if not state:
+                raise ValueError("Script ran but state file is invalid or empty")
+            
+            self._state = state
+            return state
+            
+        except subprocess.CalledProcessError as e:
+            logger.error(f"Agent check script failed: {e.stderr}")
+            raise RuntimeError(f"Agent check failed: {e.stderr}") from e
+
+    def _find_script(self) -> Optional[Path]:
+        """Find the check_agents.sh script."""
+        # Check dev path relative to this file
+        # this file: monoco/core/agent/state.py
+        # root: monoco/../../
+        
+        current_file = Path(__file__).resolve()
+        
+        # Strategy 1: Development logic (Toolkit/scripts/check_agents.sh)
+        dev_path = current_file.parents[3] / "scripts" / "check_agents.sh"
+        if dev_path.exists():
+            return dev_path
+            
+        # Strategy 2: If installed in site-packages, maybe we package scripts nearby?
+        # TODO: Define packaging strategy for scripts
+        
+        return None

monoco/core/config.py

@@ -1,11 +1,14 @@
 import os
 import yaml
 from pathlib import Path
-from typing import Optional, Dict, Any
+from typing import Optional, Dict, Any, Callable, Awaitable
 from enum import Enum
 from pydantic import BaseModel, Field
 
 import logging
+import asyncio
+from watchdog.observers import Observer
+from watchdog.events import FileSystemEventHandler
 
 # Import AgentIntegration for type hints
 from typing import TYPE_CHECKING
@@ -163,3 +166,41 @@ def save_raw_config(scope: ConfigScope, data: Dict[str, Any], project_root: Opti
     path.parent.mkdir(parents=True, exist_ok=True)
     with open(path, "w") as f:
         yaml.dump(data, f, default_flow_style=False)
+
+class ConfigEventHandler(FileSystemEventHandler):
+    def __init__(self, loop, on_change: Callable[[], Awaitable[None]], config_path: Path):
+        self.loop = loop
+        self.on_change = on_change
+        self.config_path = config_path
+
+    def on_modified(self, event):
+        if event.src_path == str(self.config_path):
+            asyncio.run_coroutine_threadsafe(self.on_change(), self.loop)
+
+class ConfigMonitor:
+    """
+    Monitors a configuration file for changes.
+    """
+    def __init__(self, config_path: Path, on_change: Callable[[], Awaitable[None]]):
+        self.config_path = config_path
+        self.on_change = on_change
+        self.observer = Observer()
+
+    async def start(self):
+        loop = asyncio.get_running_loop()
+        event_handler = ConfigEventHandler(loop, self.on_change, self.config_path)
+        
+        if not self.config_path.exists():
+            # Ensure parent exists at least
+            self.config_path.parent.mkdir(parents=True, exist_ok=True)
+            
+        # We watch the parent directory for the specific file
+        self.observer.schedule(event_handler, str(self.config_path.parent), recursive=False)
+        self.observer.start()
+        logger.info(f"Config Monitor started for {self.config_path}")
+
+    def stop(self):
+        if self.observer.is_alive():
+            self.observer.stop()
+            self.observer.join()
+        logger.info(f"Config Monitor stopped for {self.config_path}")

monoco/core/execution.py

@@ -0,0 +1,62 @@
+import os
+from pathlib import Path
+from typing import List, Dict, Optional
+from pydantic import BaseModel
+
+class ExecutionProfile(BaseModel):
+    name: str
+    source: str # "Global" or "Project"
+    path: str
+    content: Optional[str] = None
+
+def scan_execution_profiles(project_root: Optional[Path] = None) -> List[ExecutionProfile]:
+    """
+    Scan for execution profiles (SOPs) in global and project scopes.
+    """
+    profiles = []
+    
+    # 1. Global Scope
+    global_path = Path.home() / ".monoco" / "execution"
+    if global_path.exists():
+        profiles.extend(_scan_dir(global_path, "Global"))
+        
+    # 2. Project Scope
+    if project_root:
+        project_path = project_root / ".monoco" / "execution"
+        if project_path.exists():
+            profiles.extend(_scan_dir(project_path, "Project"))
+            
+    return profiles
+
+def _scan_dir(base_path: Path, source: str) -> List[ExecutionProfile]:
+    profiles = []
+    if not base_path.is_dir():
+        return profiles
+        
+    for item in base_path.iterdir():
+        if item.is_dir():
+            sop_path = item / "SOP.md"
+            if sop_path.exists():
+                profiles.append(ExecutionProfile(
+                    name=item.name,
+                    source=source,
+                    path=str(sop_path.absolute())
+                ))
+    return profiles
+
+def get_profile_detail(profile_path: str) -> Optional[ExecutionProfile]:
+    path = Path(profile_path)
+    if not path.exists():
+        return None
+        
+    # Determine source (rough heuristic)
+    source = "Project"
+    if str(path).startswith(str(Path.home() / ".monoco")):
+        source = "Global"
+        
+    return ExecutionProfile(
+        name=path.parent.name,
+        source=source,
+        path=str(path.absolute()),
+        content=path.read_text(encoding='utf-8')
+    )

monoco/core/git.py

@@ -1,7 +1,10 @@
+from typing import List, Tuple, Optional, Dict, Callable, Awaitable
+import asyncio
+import logging
 import subprocess
-import shutil
 from pathlib import Path
-from typing import List, Tuple, Optional, Dict
+
+logger = logging.getLogger("monoco.core.git")
 
 def _run_git(args: List[str], cwd: Path) -> Tuple[int, str, str]:
     """Run a raw git command."""
@@ -182,3 +185,49 @@ def worktree_remove(path: Path, worktree_path: Path, force: bool = False):
     code, _, stderr = _run_git(cmd, path)
     if code != 0:
         raise RuntimeError(f"Failed to remove worktree: {stderr}")
+
+class GitMonitor:
+    """
+    Polls the Git repository for HEAD changes and triggers updates.
+    """
+    def __init__(self, path: Path, on_head_change: Callable[[str], Awaitable[None]], poll_interval: float = 2.0):
+        self.path = path
+        self.on_head_change = on_head_change
+        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:
+            process = await asyncio.create_subprocess_exec(
+                "git", "rev-parse", "HEAD",
+                cwd=self.path,
+                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(f"Git Monitor started for {self.path}.")
+        
+        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.on_head_change(current_hash)
+
+    def stop(self):
+        self.is_running = False
+        logger.info(f"Git Monitor stopping for {self.path}...")

monoco/core/output.py

@@ -24,8 +24,8 @@ class OutputManager:
         """
         Check if running in Agent Mode.
         Triggers:
-        1. Environment variable AGENT_FLAG=true (or 1)
-        2. Environment variable MONOCO_AGENT=true (or 1)
+            1. Environment variable AGENT_FLAG=true (or 1)
+            2. Environment variable MONOCO_AGENT=true (or 1)
         """
         return os.getenv("AGENT_FLAG", "").lower() in ("true", "1") or \
                os.getenv("MONOCO_AGENT", "").lower() in ("true", "1")
@@ -40,6 +40,16 @@ class OutputManager:
         else:
             OutputManager._render_human(data, title)
 
+    @staticmethod
+    def error(message: str):
+        """
+        Print error message.
+        """
+        if OutputManager.is_agent_mode():
+            print(json.dumps({"error": message}))
+        else:
+            rprint(f"[bold red]Error:[/bold red] {message}")
+
     @staticmethod
     def _render_agent(data: Any):
         """
@@ -95,3 +105,4 @@ class OutputManager:
 
 # Global helper
 print_output = OutputManager.print
+print_error = OutputManager.error

monoco/core/state.py

@@ -0,0 +1,53 @@
+from pathlib import Path
+from typing import Optional, Any, Dict
+import json
+import logging
+from pydantic import BaseModel, Field
+
+logger = logging.getLogger("monoco.core.state")
+
+class WorkspaceState(BaseModel):
+    """
+    Persisted state for a Monoco workspace (collection of projects).
+    Stored in <workspace_root>/.monoco/state.json
+    """
+    last_active_project_id: Optional[str] = None
+    
+    @classmethod
+    def load(cls, workspace_root: Path) -> "WorkspaceState":
+        state_file = workspace_root / ".monoco" / "state.json"
+        if not state_file.exists():
+            return cls()
+            
+        try:
+            content = state_file.read_text(encoding='utf-8')
+            if not content.strip():
+                return cls()
+            data = json.loads(content)
+            return cls(**data)
+        except Exception as e:
+            logger.error(f"Failed to load workspace state from {state_file}: {e}")
+            return cls()
+
+    def save(self, workspace_root: Path):
+        state_file = workspace_root / ".monoco" / "state.json"
+        state_file.parent.mkdir(parents=True, exist_ok=True)
+        
+        try:
+            # We merge with existing on disk if possible to preserve unknown keys
+            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
+            
+            new_data = self.model_dump(exclude_unset=True)
+            current_data.update(new_data)
+            
+            state_file.write_text(json.dumps(current_data, indent=2), encoding='utf-8')
+        except Exception as e:
+            logger.error(f"Failed to save workspace state to {state_file}: {e}")
+            raise