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

monoco/core/sync.py

@@ -10,10 +10,11 @@ from rich.console import Console
 
 console = Console()
 
+
 def _get_targets(root: Path, config, cli_target: Optional[Path]) -> List[Path]:
     """Helper to determine target files."""
     targets = []
-    
+
     # 1. CLI Target
     if cli_target:
         targets.append(cli_target)
@@ -27,11 +28,9 @@ def _get_targets(root: Path, config, cli_target: Optional[Path]) -> List[Path]:
 
     # 3. Registry Defaults (Dynamic Detection)
     integrations = get_active_integrations(
-        root,
-        config_overrides=config.agent.integrations,
-        auto_detect=True
+        root, config_overrides=config.agent.integrations, auto_detect=True
     )
-    
+
     if integrations:
         for integration in integrations.values():
             targets.append(root / integration.system_prompt_file)
@@ -40,34 +39,40 @@ def _get_targets(root: Path, config, cli_target: Optional[Path]) -> List[Path]:
         # but we usually want at least one target for a generic sync.
         defaults = ["GEMINI.md", "CLAUDE.md"]
         targets.extend([root / fname for fname in defaults])
-    
-    return list(set(targets)) # Unique paths
+
+    return list(set(targets))  # Unique paths
+
 
 def sync_command(
     ctx: typer.Context,
-    target: Optional[Path] = typer.Option(None, "--target", "-t", help="Specific file to update (default: auto-detect from config or standard files)"),
-    check: bool = typer.Option(False, "--check", help="Dry run check mode")
+    target: Optional[Path] = typer.Option(
+        None,
+        "--target",
+        "-t",
+        help="Specific file to update (default: auto-detect from config or standard files)",
+    ),
+    check: bool = typer.Option(False, "--check", help="Dry run check mode"),
 ):
     """
     Synchronize Agent Environment (System Prompts & Skills).
     Aggregates prompts from all active features and injects them into the agent configuration files.
     """
-    root = Path.cwd() # TODO: Use workspace root detection properly if needed
-    
+    root = Path.cwd()  # TODO: Use workspace root detection properly if needed
+
     # 0. Load Config
     config = get_config(str(root))
-    
+
     # 1. Register Features
     registry = FeatureRegistry()
     registry.load_defaults()
-    
+
     # 2. Collect Data
     collected_prompts = {}
-    
+
     # Filter features based on config if specified
     all_features = registry.get_features()
     active_features = []
-    
+
     if config.agent.includes:
         for f in all_features:
             if f.name in config.agent.includes:
@@ -84,52 +89,64 @@ def sync_command(
                     if data.system_prompts:
                         collected_prompts.update(data.system_prompts)
             except Exception as e:
-                console.print(f"[red]Error integrating feature {feature.name}: {e}[/red]")
-                
-    console.print(f"[blue]Collected {len(collected_prompts)} prompts from {len(active_features)} features.[/blue]")
+                console.print(
+                    f"[red]Error integrating feature {feature.name}: {e}[/red]"
+                )
+
+    console.print(
+        f"[blue]Collected {len(collected_prompts)} prompts from {len(active_features)} features.[/blue]"
+    )
 
     # 3. Distribute Skills
-    console.print(f"[bold blue]Distributing skills to agent frameworks...[/bold blue]")
-    
+    console.print("[bold blue]Distributing skills to agent frameworks...[/bold blue]")
+
     # Determine language from config
-    skill_lang = config.i18n.source_lang if config.i18n.source_lang else 'en'
+    skill_lang = config.i18n.source_lang if config.i18n.source_lang else "en"
     console.print(f"[dim]  Using language: {skill_lang}[/dim]")
-    
+
     # Initialize SkillManager with active features
     skill_manager = SkillManager(root, active_features)
-    
+
     # Get active integrations
     integrations = get_active_integrations(
-        root,
-        config_overrides=config.agent.integrations,
-        auto_detect=True
+        root, config_overrides=config.agent.integrations, auto_detect=True
     )
-    
+
     if integrations:
         for framework_key, integration in integrations.items():
             skill_target_dir = root / integration.skill_root_dir
-            console.print(f"[dim]  Distributing to {integration.name} ({skill_target_dir})...[/dim]")
-            
+            console.print(
+                f"[dim]  Distributing to {integration.name} ({skill_target_dir})...[/dim]"
+            )
+
             try:
                 # Distribute only the configured language version
-                results = skill_manager.distribute(skill_target_dir, lang=skill_lang, force=False)
+                results = skill_manager.distribute(
+                    skill_target_dir, lang=skill_lang, force=False
+                )
                 success_count = sum(1 for v in results.values() if v)
-                console.print(f"[green]  ✓ Distributed {success_count}/{len(results)} skills to {integration.name}[/green]")
+                console.print(
+                    f"[green]  ✓ Distributed {success_count}/{len(results)} skills to {integration.name}[/green]"
+                )
             except Exception as e:
-                console.print(f"[red]  Failed to distribute skills to {integration.name}: {e}[/red]")
+                console.print(
+                    f"[red]  Failed to distribute skills to {integration.name}: {e}[/red]"
+                )
     else:
-        console.print(f"[yellow]No agent frameworks detected. Skipping skill distribution.[/yellow]")
+        console.print(
+            "[yellow]No agent frameworks detected. Skipping skill distribution.[/yellow]"
+        )
 
     # 4. Determine Targets
     targets = _get_targets(root, config, target)
-    
+
     # Ensure targets exist for sync
     final_targets = []
     for t in targets:
         if not t.exists():
             # If explicit target, fail? Or create?
             # If default, create.
-            if target: 
+            if target:
                 # CLI target
                 console.print(f"[yellow]Creating {t.name}...[/yellow]")
                 try:
@@ -152,9 +169,9 @@ def sync_command(
     # 5. Inject System Prompts
     for t in final_targets:
         injector = PromptInjector(t)
-        
+
         if check:
-             console.print(f"[dim][Dry Run] Would check/update {t.name}[/dim]")
+            console.print(f"[dim][Dry Run] Would check/update {t.name}[/dim]")
         else:
             try:
                 changed = injector.inject(collected_prompts)
@@ -165,60 +182,72 @@ def sync_command(
             except Exception as e:
                 console.print(f"[red]Failed to update {t.name}: {e}[/red]")
 
+
 def uninstall_command(
     ctx: typer.Context,
-    target: Optional[Path] = typer.Option(None, "--target", "-t", help="Specific file to clean (default: auto-detect from config or standard files)")
+    target: Optional[Path] = typer.Option(
+        None,
+        "--target",
+        "-t",
+        help="Specific file to clean (default: auto-detect from config or standard files)",
+    ),
 ):
     """
     Remove Monoco Managed Block from Agent Environment files and clean up distributed skills.
     """
     root = Path.cwd()
     config = get_config(str(root))
-    
+
     # 1. Clean up System Prompts
     targets = _get_targets(root, config, target)
-    
+
     for t in targets:
         if not t.exists():
             if target:
-                 console.print(f"[yellow]Target {t} does not exist.[/yellow]")
+                console.print(f"[yellow]Target {t} does not exist.[/yellow]")
             continue
-            
+
         injector = PromptInjector(t)
         try:
             changed = injector.remove()
             if changed:
-                console.print(f"[green]✓ Removed Monoco Managed Block from {t.name}[/green]")
+                console.print(
+                    f"[green]✓ Removed Monoco Managed Block from {t.name}[/green]"
+                )
             else:
                 console.print(f"[dim]= No Monoco Block found in {t.name}[/dim]")
         except Exception as e:
             console.print(f"[red]Failed to uninstall from {t.name}: {e}[/red]")
-    
+
     # 2. Clean up Skills
-    console.print(f"[bold blue]Cleaning up distributed skills...[/bold blue]")
-    
+    console.print("[bold blue]Cleaning up distributed skills...[/bold blue]")
+
     # Load features to get skill list
     registry = FeatureRegistry()
     registry.load_defaults()
     active_features = registry.get_features()
-    
+
     skill_manager = SkillManager(root, active_features)
-    
+
     # Get active integrations
     integrations = get_active_integrations(
-        root,
-        config_overrides=config.agent.integrations,
-        auto_detect=True
+        root, config_overrides=config.agent.integrations, auto_detect=True
     )
-    
+
     if integrations:
         for framework_key, integration in integrations.items():
             skill_target_dir = root / integration.skill_root_dir
-            console.print(f"[dim]  Cleaning {integration.name} ({skill_target_dir})...[/dim]")
-            
+            console.print(
+                f"[dim]  Cleaning {integration.name} ({skill_target_dir})...[/dim]"
+            )
+
             try:
                 skill_manager.cleanup(skill_target_dir)
             except Exception as e:
-                console.print(f"[red]  Failed to clean skills from {integration.name}: {e}[/red]")
+                console.print(
+                    f"[red]  Failed to clean skills from {integration.name}: {e}[/red]"
+                )
     else:
-        console.print(f"[yellow]No agent frameworks detected. Skipping skill cleanup.[/yellow]")
+        console.print(
+            "[yellow]No agent frameworks detected. Skipping skill cleanup.[/yellow]"
+        )

monoco/core/telemetry.py

@@ -7,14 +7,15 @@ from pathlib import Path
 from typing import Optional, Dict, Any
 from monoco.core.config import get_config
 
-POSTHOG_API_KEY = "phc_MndV8H8v0W3P7Yv1P7Z8X7X7X7X7X7X7X7X7" 
+POSTHOG_API_KEY = "phc_MndV8H8v0W3P7Yv1P7Z8X7X7X7X7X7X7X7X7"
 POSTHOG_HOST = "https://app.posthog.com"
 
+
 class Telemetry:
     def __init__(self):
         self.config = get_config()
         self._device_id = self._get_or_create_device_id()
-    
+
     def _get_or_create_device_id(self) -> str:
         state_path = Path.home() / ".monoco" / "state.json"
         if state_path.exists():
@@ -25,7 +26,7 @@ class Telemetry:
                         return state["device_id"]
             except Exception:
                 pass
-        
+
         device_id = str(uuid.uuid4())
         state_path.parent.mkdir(parents=True, exist_ok=True)
         try:
@@ -44,7 +45,7 @@ class Telemetry:
         # Notify user on first use if not configured
         if self.config.telemetry.enabled is None:
             # We don't want to spam, but we must be transparent
-            # This is a one-time notice in a session via a class-level flag? 
+            # This is a one-time notice in a session via a class-level flag?
             # Or just rely on the fact that 'init' will fix it.
             # To be safe and minimal, we'll just skip capture if not explicitly enabled
             return
@@ -68,20 +69,23 @@ class Telemetry:
             "api_key": POSTHOG_API_KEY,
             "event": namespaced_event,
             "properties": props,
-            "timestamp": time.strftime("%Y-%m-%dT%H:%M:%S%z")
+            "timestamp": time.strftime("%Y-%m-%dT%H:%M:%S%z"),
         }
 
         # Send asynchronously? For now, we'll do a simple non-blocking-ish call
         try:
             import httpx
+
             httpx.post(f"{POSTHOG_HOST}/capture/", json=data, timeout=1.0)
         except ImportError:
-            pass # Telemetry is optional
+            pass  # Telemetry is optional
         except Exception:
             pass
 
+
 _instance = None
 
+
 def capture_event(event: str, properties: Optional[Dict[str, Any]] = None):
     global _instance
     if _instance is None:

monoco/core/workspace.py

@@ -1,14 +1,16 @@
 import os
 from pathlib import Path
-from typing import List, Optional, Dict
-from pydantic import BaseModel, Field, ConfigDict
+from typing import List, Optional
+from pydantic import BaseModel, ConfigDict
 
 from monoco.core.config import get_config, MonocoConfig
 
+
 class MonocoProject(BaseModel):
     """
     Representation of a single Monoco project.
     """
+
     id: str  # Unique ID within the workspace (usually the directory name)
     name: str
     path: Path
@@ -23,6 +25,7 @@ class MonocoProject(BaseModel):
 
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
+
 def is_project_root(path: Path) -> bool:
     """
     Check if a directory serves as a Monoco project root.
@@ -31,66 +34,70 @@ def is_project_root(path: Path) -> bool:
     """
     if not path.is_dir():
         return False
-        
+
     return (path / ".monoco").is_dir()
 
+
 def load_project(path: Path) -> Optional[MonocoProject]:
     """Load a project from a path if it is a valid project root."""
     if not is_project_root(path):
         return None
-    
+
     try:
         config = get_config(str(path))
         # If name is default, use directory name
         name = config.project.name
         if name == "Monoco Project":
             name = path.name
-            
-        return MonocoProject(
-            id=path.name,
-            name=name,
-            path=path,
-            config=config
-        )
+
+        return MonocoProject(id=path.name, name=name, path=path, config=config)
     except Exception:
         return None
 
+
 def find_projects(workspace_root: Path) -> List[MonocoProject]:
     """
     Scan for projects in a workspace.
     Returns list of MonocoProject instances.
     """
     projects = []
-    
+
     # 1. Check workspace root itself
     root_project = load_project(workspace_root)
     if root_project:
         projects.append(root_project)
-    
+
     # 2. Recursive Scan
     for root, dirs, files in os.walk(workspace_root):
         # Skip hidden directories and node_modules
-        dirs[:] = [d for d in dirs if not d.startswith('.') and d != 'node_modules' and d != 'venv']
-        
+        dirs[:] = [
+            d
+            for d in dirs
+            if not d.startswith(".") and d != "node_modules" and d != "venv"
+        ]
+
         for d in dirs:
             project_path = Path(root) / d
             # Avoid re-adding root if it was somehow added (unlikely here)
-            if project_path == workspace_root: continue
-            
+            if project_path == workspace_root:
+                continue
+
             if is_project_root(project_path):
                 p = load_project(project_path)
                 if p:
                     projects.append(p)
-                
+
     return projects
 
+
 class Workspace(BaseModel):
     """
     Standardized Workspace primitive.
     """
+
     root: Path
     projects: List[MonocoProject] = []
-    
+
     @classmethod
     def discover(cls, root: Path) -> "Workspace":
         projects = find_projects(root)