monoco-toolkit 0.3.11__py3-none-any.whl → 0.4.0__py3-none-any.whl

monoco/features/hooks/__init__.py

@@ -1,11 +1,66 @@
 """
-Git Hooks management feature for Monoco.
+Universal Hooks management feature for Monoco.
 
-Provides distributed hooks architecture where each Feature can contribute
-its own hooks in resources/hooks/, aggregated by this feature.
+Provides a unified hooks system for Git, IDE, and Agent integration
+with Front Matter metadata support.
 """
 
-from .core import GitHooksManager, HookDeclaration, HookType
-from .adapter import HooksFeature
+from .models import (
+    HookType,
+    HookMetadata,
+    GitEvent,
+    AgentEvent,
+    IDEEvent,
+    ParsedHook,
+    HookGroup,
+)
+from .parser import HookParser, ParseError
+from .manager import UniversalHookManager, ValidationResult, HookDispatcher
+from .dispatchers import (
+    GitHookDispatcher,
+    AgentHookDispatcher,
+    ClaudeCodeDispatcher,
+    GeminiDispatcher,
+    create_agent_dispatchers,
+    get_dispatcher_for_provider,
+)
+from .universal_interceptor import (
+    UniversalInterceptor,
+    AgentAdapter,
+    ClaudeAdapter,
+    GeminiAdapter,
+    UnifiedDecision,
+    UnifiedHookInput,
+)
 
-__all__ = ["GitHooksManager", "HookDeclaration", "HookType", "HooksFeature"]
+__all__ = [
+    # Models
+    "HookType",
+    "HookMetadata",
+    "GitEvent",
+    "AgentEvent",
+    "IDEEvent",
+    "ParsedHook",
+    "HookGroup",
+    # Parser
+    "HookParser",
+    "ParseError",
+    # Manager
+    "UniversalHookManager",
+    "ValidationResult",
+    "HookDispatcher",
+    # Dispatchers
+    "GitHookDispatcher",
+    "AgentHookDispatcher",
+    "ClaudeCodeDispatcher",
+    "GeminiDispatcher",
+    "create_agent_dispatchers",
+    "get_dispatcher_for_provider",
+    # Universal Interceptor (ACL)
+    "UniversalInterceptor",
+    "AgentAdapter",
+    "ClaudeAdapter",
+    "GeminiAdapter",
+    "UnifiedDecision",
+    "UnifiedHookInput",
+]

monoco/features/hooks/commands.py

@@ -1,309 +1,319 @@
 """
-CLI commands for Git Hooks management.
+CLI commands for Universal Hooks management.
 
-Provides:
-- monoco hooks install
-- monoco hooks uninstall
-- monoco hooks status
+This module provides commands for managing Universal Hooks (Git/IDE/Agent).
 """
 
-import typer
 from pathlib import Path
 from typing import Optional
+
+import typer
 from rich.console import Console
-from rich.table import Table
-from rich.panel import Panel
-from rich.tree import Tree
 
-from monoco.core.config import get_config
-from monoco.core.output import OutputManager
-from .core import GitHooksManager, HookConfig
+from .manager import UniversalHookManager
+from .models import HookType
+from .dispatchers import GitHookDispatcher
 
-app = typer.Typer(help="Manage Git hooks for development workflow.")
+app = typer.Typer(help="Universal Hooks management (Git/IDE/Agent).")
 console = Console()
 
 
-def _get_manager() -> GitHooksManager:
-    """Get configured GitHooksManager instance."""
-    config = get_config()
-    project_root = Path(config.paths.root).resolve()
+@app.command("scan")
+def scan(
+    directory: Path = typer.Option(
+        ".monoco/hooks",
+        "--dir",
+        "-d",
+        help="Directory to scan for hook scripts",
+    ),
+) -> None:
+    """Scan for hook scripts with Front Matter metadata."""
+    manager = UniversalHookManager()
+    dir_path = Path(directory)
 
-    hooks_config = HookConfig(
-        enabled=config.hooks.enabled,
-        enabled_features=config.hooks.features,
-        enabled_hooks=config.hooks.hooks,
-    )
+    if not dir_path.exists():
+        console.print(f"[yellow]Directory not found: {dir_path}[/yellow]")
+        raise typer.Exit(1)
 
-    return GitHooksManager(project_root, hooks_config)
+    groups = manager.scan(dir_path)
 
+    if not groups:
+        console.print("[dim]No hooks found.[/dim]")
+        return
 
-@app.command("install")
-def install(
-    hook_type: Optional[str] = typer.Argument(
-        None,
-        help="Specific hook type to install (pre-commit, pre-push, post-checkout). If not specified, installs all enabled hooks."
-    ),
-    force: bool = typer.Option(
-        False,
-        "--force",
-        "-f",
-        help="Force installation even if hook already exists",
+    for key, group in groups.items():
+        console.print(f"\n[bold]{key}[/bold] ({len(group.hooks)} hooks)")
+        for hook in group.get_prioritized_hooks():
+            console.print(f"  • {hook.script_path.name}")
+            console.print(f"    Event: {hook.metadata.event}")
+            if hook.metadata.matcher:
+                console.print(f"    Matchers: {', '.join(hook.metadata.matcher)}")
+
+
+@app.command("validate")
+def validate(
+    directory: Path = typer.Option(
+        ".monoco/hooks",
+        "--dir",
+        "-d",
+        help="Directory to validate hook scripts",
     ),
-    json: bool = typer.Option(
-        False,
-        "--json",
-        help="Output in JSON format (for agent mode)",
+) -> None:
+    """Validate hook metadata."""
+    manager = UniversalHookManager()
+    dir_path = Path(directory)
+
+    if not dir_path.exists():
+        console.print(f"[yellow]Directory not found: {dir_path}[/yellow]")
+        raise typer.Exit(1)
+
+    groups = manager.scan(dir_path)
+    errors_found = False
+
+    for key, group in groups.items():
+        for hook in group.hooks:
+            result = manager.validate(hook)
+            if not result.is_valid:
+                errors_found = True
+                console.print(f"\n[red]✗ {hook.script_path}[/red]")
+                for error in result.errors:
+                    console.print(f"  Error: {error}")
+                for warning in result.warnings:
+                    console.print(f"  Warning: {warning}")
+            elif result.warnings:
+                console.print(f"\n[yellow]⚠ {hook.script_path}[/yellow]")
+                for warning in result.warnings:
+                    console.print(f"  Warning: {warning}")
+
+    if not errors_found:
+        console.print("[green]✓ All hooks are valid[/green]")
+    else:
+        raise typer.Exit(1)
+
+
+@app.command("run")
+def run(
+    hook_type: str = typer.Argument(..., help="Hook type (git, ide, agent)"),
+    event: str = typer.Argument(..., help="Hook event (e.g., pre-commit, before-tool)"),
+    project_root: Path = typer.Option(
+        ".",
+        "--project",
+        "-p",
+        help="Project root directory",
     ),
-):
-    """
-    Install git hooks to .git/hooks/.
+    extra_args: Optional[list[str]] = typer.Argument(None),
+) -> None:
+    """Run hooks for a specific type and event."""
+    try:
+        hook_type_enum = HookType(hook_type.lower())
+    except ValueError:
+        console.print(f"[red]Invalid hook type: {hook_type}[/red]")
+        console.print(f"Valid types: git, ide, agent")
+        raise typer.Exit(1)
+
+    manager = UniversalHookManager()
 
-    Discovers hooks from all Features and generates combined hook scripts.
-    """
-    manager = _get_manager()
+    # Discover hooks from all active features
+    from monoco.core.registry import FeatureRegistry
+    active_features = FeatureRegistry.get_features()
 
-    if not manager.is_git_repo():
-        OutputManager.error("Not a git repository. Cannot install hooks.")
-        raise typer.Exit(code=1)
+    all_hooks_list = []
 
-    if hook_type:
-        # Install specific hook type
-        from .core import HookType
+    # 1. Builtin hooks
+    try:
+        from monoco.features import hooks as hooks_module
+        hooks_feature_dir = Path(hooks_module.__file__).parent
+        builtin_hooks_dir = hooks_feature_dir / "resources" / "hooks"
+        if builtin_hooks_dir.exists():
+            groups = manager.scan(builtin_hooks_dir)
+            for group in groups.values():
+                all_hooks_list.extend(group.hooks)
+    except Exception:
+        pass
+
+    # 2. Feature hooks
+    for feature in active_features:
+        if feature.name == "hooks":
+            continue
         try:
-            htype = HookType(hook_type)
-        except ValueError:
-            valid_types = [t.value for t in HookType]
-            OutputManager.error(f"Invalid hook type: {hook_type}. Valid types: {', '.join(valid_types)}")
-            raise typer.Exit(code=1)
-
-        # Temporarily enable this hook type
-        manager.config.enabled_hooks[hook_type] = True
-
-    results = manager.install()
-
-    if OutputManager.is_agent_mode() or json:
-        OutputManager.print({
-            "status": "installed",
-            "hooks": {k.value: v for k, v in results.items()}
-        })
+            import importlib
+            module_name = feature.__class__.__module__
+            module = importlib.import_module(module_name)
+            if hasattr(module, "__file__") and module.__file__:
+                feature_dir = Path(module.__file__).parent
+                hooks_resource_dir = feature_dir / "resources" / "hooks"
+                if hooks_resource_dir.exists():
+                    groups = manager.scan(hooks_resource_dir)
+                    for group in groups.values():
+                        all_hooks_list.extend(group.hooks)
+        except Exception:
+            continue
+
+    # Find matching hooks
+    matching_hooks = [
+        h for h in all_hooks_list
+        if h.metadata.type == hook_type_enum and h.metadata.event == event
+    ]
+
+    if not matching_hooks:
+        raise typer.Exit(0)
+
+    # Execute matching hooks
+    if hook_type_enum == HookType.AGENT:
+        # Use Universal Interceptor for agent hooks
+        from .universal_interceptor import UniversalInterceptor
+
+        interceptor = UniversalInterceptor()
+        exit_code = 0
+
+        for hook in matching_hooks:
+            result = interceptor.run(str(hook.script_path))
+            if result != 0:
+                exit_code = result
+                console.print(f"[red]Hook failed: {hook.script_path.name}[/red]")
+
+        raise typer.Exit(exit_code)
     else:
-        installed = [k.value for k, v in results.items() if v]
-        skipped = [k.value for k, v in results.items() if not v]
-
-        if installed:
-            console.print(f"[green]✓ Installed hooks:[/green] {', '.join(installed)}")
-        if skipped:
-            console.print(f"[yellow]⚠ Skipped hooks:[/yellow] {', '.join(skipped)}")
+        # Use dispatcher for Git/IDE hooks
+        dispatcher = manager.get_dispatcher(hook_type_enum)
+        if not dispatcher:
+            # Register appropriate dispatcher
+            if hook_type_enum == HookType.GIT:
+                dispatcher = GitHookDispatcher()
+                manager.register_dispatcher(hook_type_enum, dispatcher)
+            else:
+                console.print(f"[red]No dispatcher available for type: {hook_type}[/red]")
+                raise typer.Exit(1)
+
+        exit_code = 0
+        for hook in matching_hooks:
+            context = {
+                "event": event,
+                "git_root": str(project_root),
+                "args": extra_args or [],
+            }
+            if not dispatcher.execute(hook, context):
+                exit_code = 1
+                console.print(f"[red]Hook failed: {hook.script_path.name}[/red]")
+
+        raise typer.Exit(exit_code)
 
 
-@app.command("uninstall")
-def uninstall(
-    hook_type: Optional[str] = typer.Argument(
-        None,
-        help="Specific hook type to uninstall. If not specified, uninstalls all Monoco-managed hooks."
-    ),
-    json: bool = typer.Option(
-        False,
-        "--json",
-        help="Output in JSON format (for agent mode)",
+@app.command("install")
+def install(
+    directory: Path = typer.Option(
+        ".monoco/hooks",
+        "--dir",
+        "-d",
+        help="Directory containing hook scripts",
     ),
-):
-    """
-    Uninstall Monoco-managed git hooks from .git/hooks/.
-
-    Only removes hooks that were installed by Monoco (identified by marker).
-    """
-    manager = _get_manager()
-
-    if not manager.is_git_repo():
-        OutputManager.error("Not a git repository.")
-        raise typer.Exit(code=1)
-
-    if hook_type:
-        # Uninstall specific hook type
-        hook_path = manager.hooks_dir / hook_type
-        if hook_path.exists():
-            try:
-                content = hook_path.read_text(encoding="utf-8")
-                if manager.MONOCO_MARKER in content:
-                    hook_path.unlink()
-                    results = {hook_type: True}
-                else:
-                    results = {hook_type: False}
-            except Exception as e:
-                OutputManager.error(f"Failed to uninstall {hook_type}: {e}")
-                raise typer.Exit(code=1)
-        else:
-            results = {hook_type: False}
-    else:
-        results = manager.uninstall()
-
-    if OutputManager.is_agent_mode() or json:
-        OutputManager.print({
-            "status": "uninstalled",
-            "hooks": {k.value if hasattr(k, 'value') else k: v for k, v in results.items()}
-        })
-    else:
-        removed = [k.value if hasattr(k, 'value') else k for k, v in results.items() if v]
-        skipped = [k.value if hasattr(k, 'value') else k for k, v in results.items() if not v]
-
-        if removed:
-            console.print(f"[green]✓ Removed hooks:[/green] {', '.join(removed)}")
-        if skipped:
-            console.print(f"[dim]- Skipped (not managed by Monoco):[/dim] {', '.join(skipped)}")
-
-
-@app.command("status")
-def status(
-    json: bool = typer.Option(
-        False,
-        "--json",
-        help="Output in JSON format (for agent mode)",
+    project_root: Path = typer.Option(
+        ".",
+        "--project",
+        "-p",
+        help="Project root directory",
     ),
-):
-    """
-    Show current hooks installation status.
-
-    Displays which hooks are installed, discovered, and their configuration.
-    """
-    manager = _get_manager()
-    status_info = manager.get_status()
-
-    if OutputManager.is_agent_mode() or json:
-        OutputManager.print(status_info)
+) -> None:
+    """Install Git hooks to .git/hooks/."""
+    manager = UniversalHookManager()
+    dispatcher = GitHookDispatcher()
+    manager.register_dispatcher(HookType.GIT, dispatcher)
+
+    dir_path = Path(directory)
+    if not dir_path.exists():
+        console.print(f"[yellow]Hooks directory not found: {dir_path}[/yellow]")
+        raise typer.Exit(1)
+
+    # Scan for git hooks
+    groups = manager.scan(dir_path)
+
+    if "git" not in groups:
+        console.print("[dim]No Git hooks found.[/dim]")
         return
 
-    # Human-readable output
-    if not status_info["is_git_repo"]:
-        console.print("[red]Not a git repository.[/red]")
-        raise typer.Exit(code=1)
-
-    console.print(Panel("[bold blue]Git Hooks Status[/bold blue]", expand=False))
-
-    # Installed hooks table
-    table = Table(title="Installed Hooks")
-    table.add_column("Hook Type", style="cyan")
-    table.add_column("Status", style="green")
-    table.add_column("Managed By", style="dim")
+    # Install hooks
+    group = groups["git"]
+    installed = 0
+    failed = 0
 
-    for hook_type, info in status_info["installed"].items():
-        if info["exists"]:
-            status_str = "[green]Installed[/green]"
-            managed = "Monoco" if info.get("managed_by_monoco") else "External"
+    for hook in group.hooks:
+        if dispatcher.install(hook, project_root):
+            installed += 1
+            console.print(f"[green]✓ Installed {hook.metadata.event}[/green]")
         else:
-            status_str = "[dim]Not installed[/dim]"
-            managed = "-"
-        table.add_row(hook_type, status_str, managed)
-
-    console.print(table)
-
-    # Discovered hooks
-    if status_info["discovered"]:
-        console.print("\n[bold]Discovered Hook Scripts:[/bold]")
-        for hook_type, scripts in status_info["discovered"].items():
-            tree = Tree(f"[cyan]{hook_type}[/cyan]")
-            for script in scripts:
-                tree.add(f"[dim]{script['feature']}[/dim] (priority: {script['priority']})")
-            console.print(tree)
-    else:
-        console.print("\n[yellow]No hook scripts discovered from Features.[/yellow]")
-
-    # Configuration
-    config_tree = Tree("[bold]Configuration:[/bold]")
-    config_tree.add(f"Hooks enabled: {status_info['config']['enabled']}")
-
-    if status_info['config']['enabled_features']:
-        features_branch = config_tree.add("Feature-specific settings:")
-        for feature, enabled in status_info['config']['enabled_features'].items():
-            status = "enabled" if enabled else "disabled"
-            features_branch.add(f"{feature}: {status}")
+            failed += 1
+            console.print(f"[red]✗ Failed to install {hook.metadata.event}[/red]")
 
-    if status_info['config']['enabled_hooks']:
-        hooks_branch = config_tree.add("Hook-type settings:")
-        for hook, enabled in status_info['config']['enabled_hooks'].items():
-            status = "enabled" if enabled else "disabled"
-            hooks_branch.add(f"{hook}: {status}")
+    if failed > 0:
+        raise typer.Exit(1)
 
-    console.print(config_tree)
+    console.print(f"\n[green]Installed {installed} hook(s)[/green]")
 
 
-@app.command("enable")
-def enable(
-    hook_type: str = typer.Argument(..., help="Hook type to enable (pre-commit, pre-push, post-checkout)"),
-):
-    """
-    Enable a specific hook type in configuration.
+@app.command("uninstall")
+def uninstall(
+    event: Optional[str] = typer.Option(
+        None,
+        "--event",
+        "-e",
+        help="Specific event to uninstall (uninstalls all if not specified)",
+    ),
+    project_root: Path = typer.Option(
+        ".",
+        "--project",
+        "-p",
+        help="Project root directory",
+    ),
+) -> None:
+    """Uninstall Git hooks from .git/hooks/."""
+    dispatcher = GitHookDispatcher()
 
-    This updates workspace.yaml to enable the hook for future installs.
-    """
-    from .core import HookType
-    try:
-        HookType(hook_type)
-    except ValueError:
-        valid_types = [t.value for t in HookType]
-        OutputManager.error(f"Invalid hook type: {hook_type}. Valid types: {', '.join(valid_types)}")
-        raise typer.Exit(code=1)
+    if event:
+        if dispatcher.uninstall(event, project_root):
+            console.print(f"[green]✓ Uninstalled {event}[/green]")
+        else:
+            console.print(f"[red]✗ Failed to uninstall {event}[/red]")
+            raise typer.Exit(1)
+    else:
+        # Uninstall all Monoco hooks
+        installed = dispatcher.list_installed(project_root)
+        uninstalled = 0
+        failed = 0
+
+        for hook_info in installed:
+            if dispatcher.uninstall(hook_info["event"], project_root):
+                uninstalled += 1
+                console.print(f"[green]✓ Uninstalled {hook_info['event']}[/green]")
+            else:
+                failed += 1
+                console.print(f"[red]✗ Failed to uninstall {hook_info['event']}[/red]")
+
+        if failed > 0:
+            raise typer.Exit(1)
+
+        console.print(f"\n[green]Uninstalled {uninstalled} hook(s)[/green]")
+
+
+@app.command("list")
+def list_hooks(
+    project_root: Path = typer.Option(
+        ".",
+        "--project",
+        "-p",
+        help="Project root directory",
+    ),
+) -> None:
+    """List installed Git hooks."""
+    dispatcher = GitHookDispatcher()
+    installed = dispatcher.list_installed(project_root)
 
-    # Update workspace.yaml
-    config = get_config()
-    config_path = Path(config.paths.root) / ".monoco" / "workspace.yaml"
-    try:
-        import yaml
-        with open(config_path, 'r') as f:
-            data = yaml.safe_load(f) or {}
-
-        if 'hooks' not in data:
-            data['hooks'] = {}
-        if 'hooks' not in data['hooks']:
-            data['hooks']['hooks'] = {}
-        data['hooks']['hooks'][hook_type] = True
-
-        with open(config_path, 'w') as f:
-            yaml.dump(data, f, default_flow_style=False, allow_unicode=True)
-
-        console.print(f"[green]✓ Enabled {hook_type} hook in configuration[/green]")
-        console.print(f"[dim]Run 'monoco hooks install' to apply changes.[/dim]")
-    except Exception as e:
-        OutputManager.error(f"Failed to update configuration: {e}")
-        raise typer.Exit(code=1)
-
-
-@app.command("disable")
-def disable(
-    hook_type: str = typer.Argument(..., help="Hook type to disable (pre-commit, pre-push, post-checkout)"),
-):
-    """
-    Disable a specific hook type in configuration.
-
-    This updates workspace.yaml to disable the hook for future installs.
-    """
-    from .core import HookType
-    try:
-        HookType(hook_type)
-    except ValueError:
-        valid_types = [t.value for t in HookType]
-        OutputManager.error(f"Invalid hook type: {hook_type}. Valid types: {', '.join(valid_types)}")
-        raise typer.Exit(code=1)
+    if not installed:
+        console.print("[dim]No Monoco Git hooks installed.[/dim]")
+        return
 
-    # Update workspace.yaml
-    config = get_config()
-    config_path = Path(config.paths.root) / ".monoco" / "workspace.yaml"
-    try:
-        import yaml
-        with open(config_path, 'r') as f:
-            data = yaml.safe_load(f) or {}
-
-        if 'hooks' not in data:
-            data['hooks'] = {}
-        if 'hooks' not in data['hooks']:
-            data['hooks']['hooks'] = {}
-        data['hooks']['hooks'][hook_type] = False
-
-        with open(config_path, 'w') as f:
-            yaml.dump(data, f, default_flow_style=False, allow_unicode=True)
-
-        console.print(f"[green]✓ Disabled {hook_type} hook in configuration[/green]")
-        console.print(f"[dim]Run 'monoco hooks uninstall {hook_type}' to remove existing hook.[/dim]")
-    except Exception as e:
-        OutputManager.error(f"Failed to update configuration: {e}")
-        raise typer.Exit(code=1)
+    console.print("[bold]Installed Git Hooks:[/bold]\n")
+    for hook in installed:
+        merged_status = " (merged)" if hook.get("is_merged") else ""
+        console.print(f"  • {hook['event']}{merged_status}")
+        if hook.get("hook_id"):
+            console.print(f"    ID: {hook['hook_id']}")