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

monoco/cli/project.py

@@ -1,35 +1,33 @@
 import typer
 from pathlib import Path
-from typing import Optional, Annotated
+from typing import Optional
 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.workspace import find_projects
 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")
+    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 ""
+                "key": p.config.project.key if p.config.project else "",
             }
             for p in projects
         ]
@@ -40,48 +38,54 @@ def list_projects(
         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)
+            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"),
+    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.")
+        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
-        }
-    }
-    
+
+    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)
-    })
+
+    OutputManager.print(
+        {
+            "status": "initialized",
+            "name": name,
+            "key": key,
+            "path": str(cwd),
+            "config_file": str(project_config_path),
+        }
+    )

monoco/cli/workspace.py

@@ -1,46 +1,56 @@
 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
+from monoco.core.hooks import install_hooks
 
 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"),
+    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.")
+        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
+            "issues": "Issues",  # Default
             "spikes": ".references",
-            "specs": "SPECS"
-        }
+        },
+        "hooks": {"pre-commit": "monoco issue lint --recursive"},
     }
-    
+
     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)
-    })
 
+    try:
+        install_hooks(cwd, config["hooks"])
+    except Exception as e:
+        OutputManager.warning(f"Failed to install hooks: {e}")
+
+    OutputManager.print(
+        {
+            "status": "initialized",
+            "path": str(cwd),
+            "config_file": str(workspace_config_path),
+        }
+    )

monoco/core/agent/__init__.py

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

monoco/core/agent/action.py

@@ -1,12 +1,13 @@
-
 import re
 import yaml
 from pathlib import Path
 from typing import Dict, List, Optional, Any
-from pydantic import BaseModel, Field
+from pydantic import BaseModel
+
 
 class ActionContext(BaseModel):
     """Context information for matching actions."""
+
     id: Optional[str] = None
     type: Optional[str] = None
     stage: Optional[str] = None
@@ -14,8 +15,10 @@ class ActionContext(BaseModel):
     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
@@ -26,16 +29,33 @@ class ActionWhen(BaseModel):
         """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):
+        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):
+        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):
+        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):
+        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
@@ -46,10 +66,11 @@ class PromptyAction(BaseModel):
     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
+    provider: Optional[str] = None  # Derived from model.api or explicitly set
+
 
 class ActionRegistry:
     def __init__(self, project_root: Optional[Path] = None):
@@ -59,7 +80,7 @@ class ActionRegistry:
     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)
@@ -68,7 +89,7 @@ class ActionRegistry:
         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):
@@ -85,28 +106,29 @@ class ActionRegistry:
 
     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 = {}
+                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", ""),
@@ -118,21 +140,23 @@ class ActionRegistry:
                 template=body,
                 when=when,
                 path=str(file_path.absolute()),
-                provider=meta.get("provider") or meta.get("model", {}).get("api")
+                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]:
+    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]:

monoco/core/agent/adapters.py

@@ -3,11 +3,11 @@ 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
@@ -24,10 +24,11 @@ class BaseCLIClient:
         # 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."
+                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
 
@@ -39,7 +40,9 @@ class BaseCLIClient:
                     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(
+                        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}")
@@ -51,25 +54,25 @@ class BaseCLIClient:
         # 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
+            *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}")
-            
+            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")
 
@@ -81,7 +84,7 @@ class GeminiClient(BaseCLIClient, AgentClient):
 
 class ClaudeClient(BaseCLIClient, AgentClient):
     """Adapter for Anthropic Claude CLI."""
-    
+
     def __init__(self):
         super().__init__("claude")
 
@@ -93,7 +96,7 @@ class ClaudeClient(BaseCLIClient, AgentClient):
 
 class QwenClient(BaseCLIClient, AgentClient):
     """Adapter for Alibaba Qwen CLI."""
-    
+
     def __init__(self):
         super().__init__("qwen")
 
@@ -105,7 +108,7 @@ class QwenClient(BaseCLIClient, AgentClient):
 
 class KimiClient(BaseCLIClient, AgentClient):
     """Adapter for Moonshot Kimi CLI."""
-    
+
     def __init__(self):
         super().__init__("kimi")
 
@@ -119,9 +122,10 @@ _ADAPTERS = {
     "gemini": GeminiClient,
     "claude": ClaudeClient,
     "qwen": QwenClient,
-    "kimi": KimiClient
+    "kimi": KimiClient,
 }
 
+
 def get_agent_client(name: str) -> AgentClient:
     """Factory to get agent client by name."""
     if name not in _ADAPTERS:

monoco/core/agent/protocol.py

@@ -2,12 +2,13 @@
 Protocol definition for Agent Clients.
 """
 
-from typing import Protocol, List, Optional
+from typing import Protocol, List
 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')."""
@@ -20,11 +21,11 @@ class AgentClient(Protocol):
     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

@@ -5,22 +5,22 @@ 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
+from pydantic import BaseModel
 
 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]
@@ -31,6 +31,7 @@ class AgentState(BaseModel):
         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
@@ -40,7 +41,7 @@ class AgentStateManager:
         """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)
@@ -58,46 +59,45 @@ class AgentStateManager:
             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)
-        
+
+        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
-            
+                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
+                latency_ms=health.latency_ms,
             )
-            
-        state = AgentState(
-            last_checked=datetime.now(timezone.utc),
-            providers=providers
-        )
-        
+
+        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)
-            
+            yaml.dump(state.model_dump(mode="json"), f)
+
         self._state = state
         return state