monoco-toolkit 0.2.7__py3-none-any.whl → 0.3.0__py3-none-any.whl

monoco/core/config.py

@@ -1,4 +1,3 @@
-import os
 import yaml
 from pathlib import Path
 from typing import Optional, Dict, Any, Callable, Awaitable, List
@@ -11,41 +10,66 @@ from watchdog.observers import Observer
 from watchdog.events import FileSystemEventHandler
 
 
-
 logger = logging.getLogger("monoco.core.config")
 
+
 class PathsConfig(BaseModel):
     """Configuration for directory paths."""
+
     root: str = Field(default=".", description="Project root directory")
     issues: str = Field(default="Issues", description="Directory for issues")
-    spikes: str = Field(default=".references", description="Directory for spikes/research")
-    specs: str = Field(default="SPECS", description="Directory for specifications")
+    spikes: str = Field(
+        default=".references", description="Directory for spikes/research"
+    )
+
 
 class CoreConfig(BaseModel):
     """Core system configuration."""
+
     log_level: str = Field(default="INFO", description="Logging verbosity")
-    author: Optional[str] = Field(default=None, description="Default author for new artifacts")
+    author: Optional[str] = Field(
+        default=None, description="Default author for new artifacts"
+    )
+
 
 class ProjectConfig(BaseModel):
     """Project identity configuration."""
+
     name: str = Field(default="Monoco Project", description="Project name")
     key: str = Field(default="MON", description="Project key/prefix for IDs")
-    spike_repos: Dict[str, str] = Field(default_factory=dict, description="Managed external research repositories (name -> url)")
-    members: Dict[str, str] = Field(default_factory=dict, description="Workspace member projects (name -> relative_path)")
+    spike_repos: Dict[str, str] = Field(
+        default_factory=dict,
+        description="Managed external research repositories (name -> url)",
+    )
+    members: Dict[str, str] = Field(
+        default_factory=dict,
+        description="Workspace member projects (name -> relative_path)",
+    )
+
 
 class I18nConfig(BaseModel):
     """Configuration for internationalization."""
+
     source_lang: str = Field(default="en", description="Source language code")
-    target_langs: list[str] = Field(default_factory=lambda: ["zh"], description="Target language codes")
+    target_langs: list[str] = Field(
+        default_factory=lambda: ["zh"], description="Target language codes"
+    )
+
 
 class UIConfig(BaseModel):
     """Configuration for UI customizations."""
-    dictionary: Dict[str, str] = Field(default_factory=dict, description="Custom domain terminology mapping")
+
+    dictionary: Dict[str, str] = Field(
+        default_factory=dict, description="Custom domain terminology mapping"
+    )
+
 
 class TelemetryConfig(BaseModel):
     """Configuration for Telemetry."""
-    enabled: Optional[bool] = Field(default=None, description="Whether telemetry is enabled")
 
+    enabled: Optional[bool] = Field(
+        default=None, description="Whether telemetry is enabled"
+    )
 
 
 class IssueTypeConfig(BaseModel):
@@ -55,6 +79,7 @@ class IssueTypeConfig(BaseModel):
     folder: str
     description: Optional[str] = None
 
+
 class TransitionConfig(BaseModel):
     name: str
     label: str
@@ -67,6 +92,7 @@ class TransitionConfig(BaseModel):
     description: str = ""
     command_template: Optional[str] = None
 
+
 class IssueSchemaConfig(BaseModel):
     types: List[IssueTypeConfig] = Field(default_factory=list)
     statuses: List[str] = Field(default_factory=list)
@@ -77,49 +103,56 @@ class IssueSchemaConfig(BaseModel):
     def merge(self, other: "IssueSchemaConfig") -> "IssueSchemaConfig":
         if not other:
             return self
-        
+
         # Types: merge by name
         if other.types:
             type_map = {t.name: t for t in self.types}
             for ot in other.types:
                 type_map[ot.name] = ot
             self.types = list(type_map.values())
-        
+
         # Statuses: replace if provided
         if other.statuses:
             self.statuses = other.statuses
-        
+
         # Stages: replace if provided
         if other.stages:
             self.stages = other.stages
-            
+
         # Solutions: replace if provided
         if other.solutions:
             self.solutions = other.solutions
-            
+
         # Workflows (Transitions): merge by name
         if other.workflows:
             wf_map = {w.name: w for w in self.workflows}
             for ow in other.workflows:
                 wf_map[ow.name] = ow
             self.workflows = list(wf_map.values())
-                
+
         return self
 
+
 class StateMachineConfig(BaseModel):
     transitions: List[TransitionConfig]
 
+
 class MonocoConfig(BaseModel):
     """
     Main Configuration Schema.
     Hierarchy: Defaults < User Config (~/.monoco/config.yaml) < Project Config (./.monoco/config.yaml)
     """
+
     core: CoreConfig = Field(default_factory=CoreConfig)
     paths: PathsConfig = Field(default_factory=PathsConfig)
     project: ProjectConfig = Field(default_factory=ProjectConfig)
     i18n: I18nConfig = Field(default_factory=I18nConfig)
     ui: UIConfig = Field(default_factory=UIConfig)
     telemetry: TelemetryConfig = Field(default_factory=TelemetryConfig)
+    hooks: Dict[str, str] = Field(
+        default_factory=dict,
+        description="Git hooks configuration (hook_name -> command)",
+    )
 
     issue: IssueSchemaConfig = Field(default_factory=IssueSchemaConfig)
 
@@ -134,10 +167,12 @@ class MonocoConfig(BaseModel):
         return base
 
     @classmethod
-    def load(cls, project_root: Optional[str] = None, require_project: bool = False) -> "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.
@@ -147,16 +182,18 @@ class MonocoConfig(BaseModel):
 
         # 2. Define config paths
         home_path = Path.home() / ".monoco" / "config.yaml"
-        
+
         # Determine project path
         cwd = Path(project_root) if project_root else Path.cwd()
         # 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)")
+            raise FileNotFoundError(
+                f"Monoco workspace not found in {cwd}. (No .monoco directory)"
+            )
 
         # 3. Load User Config
         if home_path.exists():
@@ -165,12 +202,12 @@ class MonocoConfig(BaseModel):
                     user_config = yaml.safe_load(f)
                     if user_config:
                         cls._deep_merge(config_data, user_config)
-            except Exception as e:
+            except Exception:
                 # We don't want to crash on config load fail, implementing simple warning equivalent
                 pass
 
         # 4. Load Project/Workspace Config
-        
+
         # 4a. Load workspace.yaml (Global Environment)
         if workspace_config_path.exists():
             try:
@@ -204,10 +241,14 @@ class MonocoConfig(BaseModel):
         # 5. Instantiate Model
         return cls(**config_data)
 
+
 # Global singleton
 _settings = None
 
-def get_config(project_root: Optional[str] = None, require_project: bool = False) -> MonocoConfig:
+
+def get_config(
+    project_root: Optional[str] = None, require_project: bool = False
+) -> MonocoConfig:
     global _settings
     # 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).
@@ -215,11 +256,13 @@ def get_config(project_root: Optional[str] = None, require_project: bool = False
         _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:
@@ -232,6 +275,7 @@ def get_config_path(scope: ConfigScope, project_root: Optional[str] = None) -> P
         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:
     """
     Find the Monoco Workspace root.
@@ -239,18 +283,21 @@ def find_monoco_root(start_path: Optional[Path] = None) -> Path:
     Recursive upward lookup is disabled per FIX-0009.
     """
     current = (start_path or Path.cwd()).resolve()
-    
+
     # Check if we are inside a .monoco folder
     if current.name == ".monoco":
         return current.parent
-        
+
     # Check if current directory has .monoco
     if (current / ".monoco").exists():
         return current
-        
+
     return current
 
-def load_raw_config(scope: ConfigScope, project_root: Optional[str] = None) -> Dict[str, Any]:
+
+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():
@@ -262,15 +309,21 @@ def load_raw_config(scope: ConfigScope, project_root: Optional[str] = None) -> D
         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:
+
+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):
+    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
@@ -279,10 +332,12 @@ class ConfigEventHandler(FileSystemEventHandler):
         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
@@ -291,13 +346,15 @@ class ConfigMonitor:
     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.schedule(
+            event_handler, str(self.config_path.parent), recursive=False
+        )
         self.observer.start()
         logger.info(f"Config Monitor started for {self.config_path}")
 

monoco/core/execution.py

@@ -1,62 +1,67 @@
-import os
 from pathlib import Path
-from typing import List, Dict, Optional
+from typing import List, Optional
 from pydantic import BaseModel
 
+
 class ExecutionProfile(BaseModel):
     name: str
-    source: str # "Global" or "Project"
+    source: str  # "Global" or "Project"
     path: str
     content: Optional[str] = None
 
-def scan_execution_profiles(project_root: Optional[Path] = None) -> List[ExecutionProfile]:
+
+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())
-                ))
+                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')
+        content=path.read_text(encoding="utf-8"),
     )

monoco/core/feature.py

@@ -1,21 +1,24 @@
 from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Dict, List, Optional
+from typing import Dict, List
+
 
 @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.
@@ -34,7 +37,7 @@ class MonocoFeature(ABC):
         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.
@@ -47,11 +50,11 @@ class MonocoFeature(ABC):
         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.
         """