monoco-toolkit 0.1.4__py3-none-any.whl → 0.1.6__py3-none-any.whl

monoco/core/sync.py

@@ -0,0 +1,224 @@
+import typer
+from pathlib import Path
+from typing import Optional, List
+from monoco.core.registry import FeatureRegistry
+from monoco.core.injection import PromptInjector
+from monoco.core.config import get_config
+from monoco.core.skills import SkillManager
+from monoco.core.integrations import get_active_integrations
+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)
+        return targets
+
+    # 2. Config Targets
+    if config.agent.targets:
+        for t in config.agent.targets:
+            targets.append(root / t)
+        return targets
+
+    # 3. Registry Defaults (Dynamic Detection)
+    integrations = get_active_integrations(
+        root,
+        config_overrides=config.agent.integrations,
+        auto_detect=True
+    )
+    
+    if integrations:
+        for integration in integrations.values():
+            targets.append(root / integration.system_prompt_file)
+    else:
+        # Fallback to standard Monoco header if nothing is detected
+        # 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
+
+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")
+):
+    """
+    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
+    
+    # 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:
+                active_features.append(f)
+    else:
+        active_features = all_features
+
+    with console.status("[bold green]Collecting feature integration data...") as status:
+        for feature in active_features:
+            status.update(f"Scanning Feature: {feature.name}")
+            try:
+                data = feature.integrate(root, config.model_dump())
+                if data:
+                    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]")
+
+    # 3. Distribute Skills
+    console.print(f"[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'
+    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
+    )
+    
+    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]")
+            
+            try:
+                # Distribute only the configured language version
+                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]")
+            except Exception as e:
+                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]")
+
+    # 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: 
+                # CLI target
+                console.print(f"[yellow]Creating {t.name}...[/yellow]")
+                try:
+                    t.touch()
+                    final_targets.append(t)
+                except Exception as e:
+                    console.print(f"[red]Failed to create {t}: {e}[/red]")
+            else:
+                # Default/Config target -> only create if it's one of the defaults we manage?
+                # For now, let's just create it to be safe, assuming user wants it.
+                console.print(f"[yellow]Creating {t.name}...[/yellow]")
+                try:
+                    t.touch()
+                    final_targets.append(t)
+                except Exception as e:
+                    console.print(f"[red]Failed to create {t}: {e}[/red]")
+        else:
+            final_targets.append(t)
+
+    # 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]")
+        else:
+            try:
+                changed = injector.inject(collected_prompts)
+                if changed:
+                    console.print(f"[green]✓ Updated {t.name}[/green]")
+                else:
+                    console.print(f"[dim]= {t.name} is up to date[/dim]")
+            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)")
+):
+    """
+    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]")
+            continue
+            
+        injector = PromptInjector(t)
+        try:
+            changed = injector.remove()
+            if changed:
+                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]")
+    
+    # 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
+    )
+    
+    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]")
+            
+            try:
+                skill_manager.cleanup(skill_target_dir)
+            except Exception as e:
+                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]")

monoco/core/workspace.py

@@ -5,16 +5,12 @@ def is_project_root(path: Path) -> bool:
     """
     Check if a directory serves as a Monoco project root.
     Criteria:
-    - has monoco.yaml
-    - OR has .monoco/config.yaml
-    - OR has Issues/ directory
+    - has .monoco/ directory
     """
     if not path.is_dir():
         return False
         
-    return (path / "monoco.yaml").exists() or \
-           (path / ".monoco" / "config.yaml").exists() or \
-           (path / "Issues").exists()
+    return (path / ".monoco").is_dir()
 
 def find_projects(workspace_root: Path) -> List[Path]:
     """

monoco/daemon/services.py

@@ -129,7 +129,7 @@ class ProjectManager:
     def scan(self):
         """
         Scans workspace for potential Monoco projects.
-        A directory is a project if it has monoco.yaml or .monoco/config.yaml or an Issues directory.
+        A directory is a project if it has a .monoco/ directory.
         """
         logger.info(f"Scanning workspace: {self.workspace_root}")
         from monoco.core.workspace import find_projects

monoco/features/config/commands.py

@@ -1,70 +1,130 @@
 import typer
 import yaml
+import json
 from pathlib import Path
-from typing import Optional
-from monoco.core.config import get_config, MonocoConfig
-from monoco.core.output import print_output
+from typing import Optional, Any
 from rich.console import Console
+from rich.syntax import Syntax
+from pydantic import ValidationError
+
+from monoco.core.config import (
+    get_config,
+    MonocoConfig,
+    ConfigScope,
+    load_raw_config,
+    save_raw_config,
+    get_config_path
+)
 
 app = typer.Typer(help="Manage Monoco configuration")
 console = Console()
 
+def _parse_value(value: str) -> Any:
+    """Parse string value into appropriate type (bool, int, float, str)."""
+    if value.lower() in ("true", "yes", "on"):
+        return True
+    if value.lower() in ("false", "no", "off"):
+        return False
+    if value.lower() == "null":
+        return None
+    try:
+        return int(value)
+    except ValueError:
+        try:
+            return float(value)
+        except ValueError:
+            return value
+
+@app.command()
+def show(
+    output: str = typer.Option("yaml", "--output", "-o", help="Output format: yaml or json"),
+):
+    """Show the currently active (merged) configuration."""
+    config = get_config()
+    # Pydantic v1/v2 compat: use dict() or model_dump()
+    data = config.dict()
+    
+    if output == "json":
+        print(json.dumps(data, indent=2))
+    else:
+        yaml_str = yaml.dump(data, default_flow_style=False)
+        syntax = Syntax(yaml_str, "yaml")
+        console.print(syntax)
+
 @app.command()
-def show():
-    """Show current configuration."""
-    settings = get_config()
-    print_output(settings, title="Current Configuration")
+def get(key: str = typer.Argument(..., help="Configuration key (e.g. project.name)")):
+    """Get a specific configuration value."""
+    config = get_config()
+    data = config.dict()
+    
+    parts = key.split(".")
+    current = data
+    
+    for part in parts:
+        if isinstance(current, dict) and part in current:
+            current = current[part]
+        else:
+            console.print(f"[red]Key '{key}' not found.[/red]")
+            raise typer.Exit(code=1)
+            
+    if isinstance(current, (dict, list)):
+        if isinstance(current, dict):
+            print(yaml.dump(current, default_flow_style=False))
+        else:
+            print(json.dumps(current))
+    else:
+        print(current)
 
 @app.command(name="set")
 def set_val(
     key: str = typer.Argument(..., help="Config key (e.g. telemetry.enabled)"),
     value: str = typer.Argument(..., help="Value to set"),
-    scope: str = typer.Option("global", "--scope", "-s", help="Configuration scope: global or project")
+    global_scope: bool = typer.Option(False, "--global", "-g", help="Update global configuration"),
 ):
-    """Set a configuration value."""
-    # This is a simplified implementation of config setting
-    # In a real system, we'd want to validate the key against the schema
+    """Set a configuration value in specific scope (project by default)."""
+    scope = ConfigScope.GLOBAL if global_scope else ConfigScope.PROJECT
     
-    if scope == "global":
-        config_path = Path.home() / ".monoco" / "config.yaml"
-    else:
-        # Check project root
-        cwd = Path.cwd()
-        config_path = cwd / ".monoco" / "config.yaml"
-        if not (cwd / ".monoco").exists():
-             config_path = cwd / "monoco.yaml"
-
-    config_data = {}
-    if config_path.exists():
-        with open(config_path, "r") as f:
-            config_data = yaml.safe_load(f) or {}
-
-    # Simple nested key support (e.g. telemetry.enabled)
+    # 1. Load Raw Config for the target scope
+    raw_data = load_raw_config(scope)
+    
+    # 2. Parse Key & Update Data
     parts = key.split(".")
-    target = config_data
-    for part in parts[:-1]:
+    target = raw_data
+    
+    # Context management for nested updates
+    for i, part in enumerate(parts[:-1]):
         if part not in target:
             target[part] = {}
         target = target[part]
+        if not isinstance(target, dict):
+            parent_key = ".".join(parts[:i+1])
+            console.print(f"[red]Cannot set '{key}': '{parent_key}' is not a dictionary ({type(target)}).[/red]")
+            raise typer.Exit(code=1)
+            
+    parsed_val = _parse_value(value)
+    target[parts[-1]] = parsed_val
     
-    # Type conversion
-    if value.lower() in ("true", "yes", "on"):
-        val = True
-    elif value.lower() in ("false", "no", "off"):
-        val = False
-    else:
-        try:
-            val = int(value)
-        except ValueError:
-            val = value
-
-    target[parts[-1]] = val
+    # 3. Validate against Schema
+    # We simulate a full load by creating a temporary MonocoConfig with these overrides.
+    # Note: This validation is "active" - we want to ensure the resulting config WOULD be valid.
+    # However, raw_data is partial. Pydantic models with defaults will accept partials.
+    try:
+        # We can try to validate just the relevant model part if we knew which one it was.
+        # But simpler is to check if MonocoConfig accepts this structure.
+        MonocoConfig(**raw_data)
+    except ValidationError as e:
+        console.print(f"[red]Validation failed for key '{key}':[/red]")
+        console.print(e)
+        raise typer.Exit(code=1)
+    except Exception as e:
+        console.print(f"[red]Unexpected validation error: {e}[/red]")
+        raise typer.Exit(code=1)
 
-    config_path.parent.mkdir(parents=True, exist_ok=True)
-    with open(config_path, "w") as f:
-        yaml.dump(config_data, f, default_flow_style=False)
+    # 4. Save
+    save_raw_config(scope, raw_data)
     
-    console.print(f"[green]✓ Set {key} = {val} in {scope} config.[/green]")
+    scope_display = "Global" if global_scope else "Project"
+    console.print(f"[green]✓ Set {key} = {parsed_val} in {scope_display} config.[/green]")
 
 if __name__ == "__main__":
     app()

monoco/features/i18n/adapter.py

@@ -0,0 +1,29 @@
+from pathlib import Path
+from typing import Dict
+from monoco.core.feature import MonocoFeature, IntegrationData
+from monoco.features.i18n import core
+
+class I18nFeature(MonocoFeature):
+    @property
+    def name(self) -> str:
+        return "i18n"
+
+    def initialize(self, root: Path, config: Dict) -> None:
+        core.init(root)
+
+    def integrate(self, root: Path, config: Dict) -> IntegrationData:
+        # Determine language from config, default to 'en'
+        lang = config.get("i18n", {}).get("source_lang", "en")
+        base_dir = Path(__file__).parent / "resources"
+        
+        prompt_file = base_dir / lang / "AGENTS.md"
+        if not prompt_file.exists():
+            prompt_file = base_dir / "en" / "AGENTS.md"
+            
+        content = ""
+        if prompt_file.exists():
+            content = prompt_file.read_text(encoding="utf-8").strip()
+
+        return IntegrationData(
+            system_prompts={"Documentation I18n": content}
+        )

monoco/features/i18n/core.py

@@ -154,25 +154,15 @@ i18n is a "first-class citizen" in Monoco.
 - Run `monoco i18n scan` to verify coverage.
 """
 
-PROMPT_CONTENT = """### Documentation I18n
-Manage internationalization.
-- **Scan**: `monoco i18n scan` (Check for missing translations)
-- **Structure**:
-  - Root files: `FILE_ZH.md`
-  - Subdirs: `folder/zh/file.md`"""
 
 def init(root: Path):
     """Initialize I18n environment (No-op currently as it relies on config)."""
     # In future, could generate i18n config section if missing.
     pass
 
-def get_resources() -> Dict[str, Any]:
     return {
         "skills": {
             "i18n": SKILL_CONTENT
         },
-        "prompts": {
-            "i18n": PROMPT_CONTENT
-        }
+        "prompts": {} # Handled by adapter via resource files
     }
-

monoco/features/i18n/resources/en/AGENTS.md

@@ -0,0 +1,8 @@
+### Documentation I18n
+
+Manage internationalization.
+
+- **Scan**: `monoco i18n scan` (Check for missing translations)
+- **Structure**:
+  - Root files: `FILE_ZH.md`
+  - Subdirs: `folder/zh/file.md`

monoco/features/i18n/resources/en/SKILL.md

@@ -0,0 +1,94 @@
+---
+name: monoco-i18n
+description: Internationalization quality control for documentation. Ensures multi-language documentation stays synchronized.
+---
+
+# Documentation I18n
+
+Manage internationalization for Monoco project documentation.
+
+## Overview
+
+The I18n feature provides:
+
+- **Automatic scanning** for missing translations
+- **Standardized structure** for multi-language documentation
+- **Quality control** to maintain documentation parity
+
+## Key Commands
+
+### Scan for Missing Translations
+
+```bash
+monoco i18n scan
+```
+
+Scans the project for markdown files and reports missing translations.
+
+**Output**:
+
+- Lists source files without corresponding translations
+- Shows which target languages are missing
+- Respects `.gitignore` and default exclusions
+
+## Configuration
+
+I18n settings are configured in `.monoco/config.yaml`:
+
+```yaml
+i18n:
+  source_lang: en # Source language code
+  target_langs: # Target language codes
+    - zh
+    - ja
+```
+
+## Documentation Structure
+
+### Root Files (Suffix Pattern)
+
+For files in the project root:
+
+- Source: `README.md`
+- Chinese: `README_ZH.md`
+- Japanese: `README_JA.md`
+
+### Subdirectory Files (Directory Pattern)
+
+For files in `docs/` or other directories:
+
+```
+docs/
+├── en/
+│   ├── guide.md
+│   └── api.md
+├── zh/
+│   ├── guide.md
+│   └── api.md
+└── ja/
+    ├── guide.md
+    └── api.md
+```
+
+## Exclusion Rules
+
+The following are automatically excluded from i18n scanning:
+
+- `.gitignore` patterns (respected automatically)
+- `.references/` directory
+- Build artifacts (`dist/`, `build/`, `node_modules/`)
+- `Issues/` directory
+
+## Best Practices
+
+1. **Create English First**: Write documentation in the source language first
+2. **Follow Naming Convention**: Use the appropriate pattern (suffix or directory)
+3. **Run Scan Regularly**: Use `monoco i18n scan` to verify coverage
+4. **Commit All Languages**: Keep translations in version control
+
+## Workflow
+
+1. Write documentation in source language (e.g., English)
+2. Create translation files following the naming convention
+3. Run `monoco i18n scan` to verify all translations exist
+4. Fix any missing translations reported by the scan

monoco/features/i18n/resources/zh/AGENTS.md

@@ -0,0 +1,8 @@
+### 文档国际化
+
+管理国际化。
+
+- **扫描**: `monoco i18n scan` (检查缺失的翻译)
+- **结构**:
+  - 根文件: `FILE_ZH.md`
+  - 子目录: `folder/zh/file.md`