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

monoco/core/config.py

@@ -1,9 +1,19 @@
 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
+
+from monoco.core.integrations import AgentIntegration
+
+logger = logging.getLogger("monoco.core.config")
+
 class PathsConfig(BaseModel):
     """Configuration for directory paths."""
     root: str = Field(default=".", description="Project root directory")
@@ -13,7 +23,6 @@ class PathsConfig(BaseModel):
 
 class CoreConfig(BaseModel):
     """Core system configuration."""
-    editor: str = Field(default_factory=lambda: os.getenv("EDITOR", "vim"), description="Preferred text editor")
     log_level: str = Field(default="INFO", description="Logging verbosity")
     author: Optional[str] = Field(default=None, description="Default author for new artifacts")
 
@@ -37,6 +46,16 @@ class TelemetryConfig(BaseModel):
     """Configuration for Telemetry."""
     enabled: Optional[bool] = Field(default=None, description="Whether telemetry is enabled")
 
+class AgentConfig(BaseModel):
+    """Configuration for Agent Environment Integration."""
+    targets: Optional[list[str]] = Field(default=None, description="Specific target files to inject into (e.g. .cursorrules)")
+    framework: Optional[str] = Field(default=None, description="Manually specified agent framework (cursor, windsurf, etc.)")
+    includes: Optional[list[str]] = Field(default=None, description="List of specific features to include in injection")
+    integrations: Optional[Dict[str, "AgentIntegration"]] = Field(
+        default=None, 
+        description="Custom agent framework integrations (overrides defaults from monoco.core.integrations)"
+    )
+
 class MonocoConfig(BaseModel):
     """
     Main Configuration Schema.
@@ -48,6 +67,7 @@ class MonocoConfig(BaseModel):
     i18n: I18nConfig = Field(default_factory=I18nConfig)
     ui: UIConfig = Field(default_factory=UIConfig)
     telemetry: TelemetryConfig = Field(default_factory=TelemetryConfig)
+    agent: AgentConfig = Field(default_factory=AgentConfig)
 
     @staticmethod
     def _deep_merge(base: Dict[str, Any], update: Dict[str, Any]) -> Dict[str, Any]:
@@ -60,9 +80,13 @@ class MonocoConfig(BaseModel):
         return base
 
     @classmethod
-    def load(cls, project_root: Optional[str] = None) -> "MonocoConfig":
+    def load(cls, project_root: Optional[str] = None, require_project: bool = False) -> "MonocoConfig":
         """
         Load configuration from multiple sources.
+        
+        Args:
+            project_root: Explicit root path. If None, uses CWD.
+            require_project: If True, raises error if .monoco directory is missing.
         """
         # 1. Start with empty dict (will use defaults via Pydantic)
         config_data = {}
@@ -72,8 +96,13 @@ class MonocoConfig(BaseModel):
         
         # Determine project path
         cwd = Path(project_root) if project_root else Path.cwd()
-        proj_path_hidden = cwd / ".monoco" / "config.yaml"
-        proj_path_root = cwd / "monoco.yaml"
+        # FIX-0009: strict separation of workspace and project config
+        workspace_config_path = cwd / ".monoco" / "workspace.yaml"
+        project_config_path = cwd / ".monoco" / "project.yaml"
+        
+        # Strict Workspace Check
+        if require_project and not (cwd / ".monoco").exists():
+            raise FileNotFoundError(f"Monoco workspace not found in {cwd}. (No .monoco directory)")
 
         # 3. Load User Config
         if home_path.exists():
@@ -86,17 +115,35 @@ class MonocoConfig(BaseModel):
                 # We don't want to crash on config load fail, implementing simple warning equivalent
                 pass
 
-        # 4. Load Project Config (prefer .monoco/config.yaml, fallback to monoco.yaml)
-        target_proj_conf = proj_path_hidden if proj_path_hidden.exists() else (
-            proj_path_root if proj_path_root.exists() else None
-        )
+        # 4. Load Project/Workspace Config
+        
+        # 4a. Load workspace.yaml (Global Environment)
+        if workspace_config_path.exists():
+            try:
+                with open(workspace_config_path, "r") as f:
+                    ws_config = yaml.safe_load(f)
+                    if ws_config:
+                        # workspace.yaml contains core, paths, i18n, ui, telemetry, agent
+                        cls._deep_merge(config_data, ws_config)
+            except Exception:
+                pass
 
-        if target_proj_conf:
+        # 4b. Load project.yaml (Identity)
+        if project_config_path.exists():
             try:
-                with open(target_proj_conf, "r") as f:
-                    proj_config = yaml.safe_load(f)
-                    if proj_config:
-                        cls._deep_merge(config_data, proj_config)
+                with open(project_config_path, "r") as f:
+                    pj_config = yaml.safe_load(f)
+                    if pj_config:
+                        # project.yaml contains 'project' fields directly? or under 'project' key?
+                        # Design decision: project.yaml should be clean, e.g. "name: foo".
+                        # But to simplify merging, let's check if it has a 'project' key or is flat.
+                        if "project" in pj_config:
+                            cls._deep_merge(config_data, pj_config)
+                        else:
+                            # Assume flat structure mapping to 'project' section
+                            if "project" not in config_data:
+                                config_data["project"] = {}
+                            cls._deep_merge(config_data["project"], pj_config)
             except Exception:
                 pass
 
@@ -106,8 +153,96 @@ class MonocoConfig(BaseModel):
 # Global singleton
 _settings = None
 
-def get_config(project_root: Optional[str] = None) -> MonocoConfig:
+def get_config(project_root: Optional[str] = None, require_project: bool = False) -> MonocoConfig:
     global _settings
-    if _settings is None or project_root is not None:
-        _settings = MonocoConfig.load(project_root)
+    # If explicit root provided, always reload.
+    # If require_project is True, we must reload to ensure validation happens (in case a previous loose load occurred).
+    if _settings is None or project_root is not None or require_project:
+        _settings = MonocoConfig.load(project_root, require_project=require_project)
     return _settings
+
+class ConfigScope(str, Enum):
+    GLOBAL = "global"
+    PROJECT = "project"
+    WORKSPACE = "workspace"
+
+def get_config_path(scope: ConfigScope, project_root: Optional[str] = None) -> Path:
+    """Get the path to the configuration file for a given scope."""
+    if scope == ConfigScope.GLOBAL:
+        return Path.home() / ".monoco" / "config.yaml"
+    elif scope == ConfigScope.WORKSPACE:
+        cwd = Path(project_root) if project_root else Path.cwd()
+        return cwd / ".monoco" / "workspace.yaml"
+    else:
+        # ConfigScope.PROJECT
+        cwd = Path(project_root) if project_root else Path.cwd()
+        return cwd / ".monoco" / "project.yaml"
+
+def find_monoco_root(start_path: Optional[Path] = None) -> Path:
+    """Recursively find the .monoco directory upwards."""
+    current = (start_path or Path.cwd()).resolve()
+    # Check if we are inside a .monoco folder (unlikely but possible)
+    if current.name == ".monoco":
+        return current.parent
+        
+    for parent in [current] + list(current.parents):
+        if (parent / ".monoco").exists():
+            return parent
+    return current
+
+def load_raw_config(scope: ConfigScope, project_root: Optional[str] = None) -> Dict[str, Any]:
+    """Load raw configuration dictionary from a specific scope."""
+    path = get_config_path(scope, project_root)
+    if not path.exists():
+        return {}
+    try:
+        with open(path, "r") as f:
+            return yaml.safe_load(f) or {}
+    except Exception as e:
+        logger.warning(f"Failed to load config from {path}: {e}")
+        return {}
+
+def save_raw_config(scope: ConfigScope, data: Dict[str, Any], project_root: Optional[str] = None) -> None:
+    """Save raw configuration dictionary to a specific scope."""
+    path = get_config_path(scope, project_root)
+    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/feature.py

@@ -0,0 +1,58 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Dict, List, Optional
+
+@dataclass
+class IntegrationData:
+    """
+    Data collection returned by a feature for integration into the Agent environment.
+    """
+    # System Prompts to be injected into agent configuration (e.g., .cursorrules)
+    # Key: Section Title (e.g., "Issue Management"), Value: Markdown Content
+    system_prompts: Dict[str, str] = field(default_factory=dict)
+    
+    # Paths to skill directories or files to be copied/symlinked
+    # DEPRECATED: Skill distribution is cancelled. Only prompts are synced.
+    skills: List[Path] = field(default_factory=list)
+
+class MonocoFeature(ABC):
+    """
+    Abstract base class for all Monoco features.
+    Features must implement this protocol to participate in init and sync lifecycles.
+    """
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Unique identifier for the feature (e.g., 'issue', 'spike')."""
+        pass
+
+    @abstractmethod
+    def initialize(self, root: Path, config: Dict) -> None:
+        """
+        Lifecycle hook: Physical Structure Initialization.
+        Called during `monoco init`.
+        Responsible for creating necessary directories, files, and config templates.
+        
+        Args:
+            root: The root directory of the project.
+            config: The full project configuration dictionary.
+        """
+        pass
+
+    @abstractmethod
+    def integrate(self, root: Path, config: Dict) -> IntegrationData:
+        """
+        Lifecycle hook: Agent Environment Integration.
+        Called during `monoco sync`.
+        Responsible for returning data (prompts, skills) needed for the Agent Setup.
+        
+        Args:
+            root: The root directory of the project.
+            config: The full project configuration dictionary.
+            
+        Returns:
+            IntegrationData object containing prompts and skills.
+        """
+        pass

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/injection.py

@@ -0,0 +1,196 @@
+import re
+from pathlib import Path
+from typing import Dict, List, Optional
+
+class PromptInjector:
+    """
+    Engine for injecting managed content into Markdown-like files (e.g., .cursorrules, GEMINI.md).
+    Maintains a 'Managed Block' defined by a specific header.
+    """
+
+    MANAGED_HEADER = "## Monoco Toolkit"
+    
+    def __init__(self, target_file: Path):
+        self.target_file = target_file
+
+    def inject(self, prompts: Dict[str, str]) -> bool:
+        """
+        Injects the provided prompts into the target file.
+        
+        Args:
+            prompts: A dictionary where key is the section title and value is the content.
+            
+        Returns:
+            True if changes were written, False otherwise.
+        """
+        current_content = ""
+        if self.target_file.exists():
+            current_content = self.target_file.read_text(encoding="utf-8")
+
+        new_content = self._merge_content(current_content, prompts)
+        
+        if new_content != current_content:
+            self.target_file.write_text(new_content, encoding="utf-8")
+            return True
+        return False
+
+    def _merge_content(self, original: str, prompts: Dict[str, str]) -> str:
+        """
+        Merges the generated prompts into the original content within the managed block.
+        """
+        # 1. Generate the new managed block content
+        managed_block = [self.MANAGED_HEADER, ""]
+        managed_block.append("> **Auto-Generated**: This section is managed by Monoco. Do not edit manually.\n")
+        
+        for title, content in prompts.items():
+            managed_block.append(f"### {title}")
+            managed_block.append("") # Blank line after header
+            
+            # Sanitize content: remove leading header if it matches the title
+            clean_content = content.strip()
+            # Regex to match optional leading hash header matching the title (case insensitive)
+            # e.g. "### Issue Management" or "# Issue Management"
+            pattern = r"^(#+\s*)" + re.escape(title) + r"\s*\n"
+            match = re.match(pattern, clean_content, re.IGNORECASE)
+            
+            if match:
+                clean_content = clean_content[match.end():].strip()
+            
+            managed_block.append(clean_content)
+            managed_block.append("") # Blank line after section
+
+        managed_block_str = "\n".join(managed_block).strip() + "\n"
+
+        # 2. Find and replace/append in the original content
+        lines = original.splitlines()
+        start_idx = -1
+        end_idx = -1
+        
+        # Find start
+        for i, line in enumerate(lines):
+            if line.strip() == self.MANAGED_HEADER:
+                start_idx = i
+                break
+        
+        if start_idx == -1:
+            # Block not found, append to end
+            if original and not original.endswith("\n"):
+                return original + "\n\n" + managed_block_str
+            elif original:
+                return original + "\n" + managed_block_str
+            else:
+                return managed_block_str
+
+        # Find end: Look for next header of level 1 (assuming Managed Header is H1)
+        # Or EOF
+        # Note: If MANAGED_HEADER is "# ...", we look for next "# ..."
+        # But allow "## ..." as children.
+        
+        header_level_match = re.match(r"^(#+)\s", self.MANAGED_HEADER)
+        header_level_prefix = header_level_match.group(1) if header_level_match else "#"
+        
+        for i in range(start_idx + 1, len(lines)):
+            line = lines[i]
+            # Check if this line is a header of the same level or higher (fewer #s)
+            # e.g. if Managed is "###", then "#" and "##" are higher/parents, "###" is sibling.
+            # We treat siblings as end of block too.
+            if line.startswith("#"):
+                 # Match regex to get level
+                 match = re.match(r"^(#+)\s", line)
+                 if match:
+                     level = match.group(1)
+                     if len(level) <= len(header_level_prefix):
+                         end_idx = i
+                         break
+        
+        if end_idx == -1:
+            end_idx = len(lines)
+
+        # 3. Construct result
+        pre_block = "\n".join(lines[:start_idx])
+        post_block = "\n".join(lines[end_idx:])
+        
+        result = pre_block
+        if result:
+             result += "\n\n"
+        
+        result += managed_block_str
+        
+        if post_block:
+            # Ensure separation if post block exists and isn't just empty lines
+            if post_block.strip():
+                result += "\n" + post_block
+            else:
+                result += post_block # Keep trailing newlines if any, or normalize?
+                
+        return result.strip() + "\n"
+
+    def remove(self) -> bool:
+        """
+        Removes the managed block from the target file.
+
+        Returns:
+            True if changes were written (block removed), False otherwise.
+        """
+        if not self.target_file.exists():
+            return False
+
+        current_content = self.target_file.read_text(encoding="utf-8")
+        lines = current_content.splitlines()
+
+        start_idx = -1
+        end_idx = -1
+
+        # Find start
+        for i, line in enumerate(lines):
+            if line.strip() == self.MANAGED_HEADER:
+                start_idx = i
+                break
+
+        if start_idx == -1:
+            return False
+
+        # Find end: exact logic as in _merge_content
+        header_level_match = re.match(r"^(#+)\s", self.MANAGED_HEADER)
+        header_level_prefix = header_level_match.group(1) if header_level_match else "#"
+
+        for i in range(start_idx + 1, len(lines)):
+            line = lines[i]
+            if line.startswith("#"):
+                 match = re.match(r"^(#+)\s", line)
+                 if match:
+                     level = match.group(1)
+                     if len(level) <= len(header_level_prefix):
+                         end_idx = i
+                         break
+        
+        if end_idx == -1:
+            end_idx = len(lines)
+
+        # Reconstruct content without the block
+        # We also need to be careful about surrounding newlines to avoid leaving gaps
+        
+        # Check lines before start_idx
+        while start_idx > 0 and not lines[start_idx-1].strip():
+            start_idx -= 1
+        
+        # Check lines after end_idx (optional, but good for cleanup)
+        # Usually end_idx points to the next header or EOF.
+        # If it points to next header, we keep it.
+
+        pre_block = lines[:start_idx]
+        post_block = lines[end_idx:]
+
+        # If we removed everything, the file might become empty or just newlines
+        
+        new_lines = pre_block + post_block
+        if not new_lines:
+             new_content = ""
+        else:
+             new_content = "\n".join(new_lines).strip() + "\n"
+
+        if new_content != current_content:
+            self.target_file.write_text(new_content, encoding="utf-8")
+            return True
+
+        return False