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

monoco/core/sync.py

@@ -1,4 +1,5 @@
 import typer
+import subprocess
 from pathlib import Path
 from typing import Optional, List
 from monoco.core.registry import FeatureRegistry
@@ -21,8 +22,10 @@ def _get_targets(root: Path, config, cli_target: Optional[Path]) -> List[Path]:
         return targets
 
     # 2. Registry Defaults (Dynamic Detection)
+    # We now default to ALL integrations instead of auto-detecting
+    # because we want to enable all agents by default.
     integrations = get_active_integrations(
-        root, config_overrides=None, auto_detect=True
+        root, config_overrides=None, auto_detect=False
     )
 
     if integrations:
@@ -133,8 +136,9 @@ def sync_command(
     skill_manager = SkillManager(root, active_features)
 
     # Get active integrations
+    # Disable auto-detect to distribute to all supported frameworks
     integrations = get_active_integrations(
-        root, config_overrides=None, auto_detect=True
+        root, config_overrides=None, auto_detect=False
     )
 
     if integrations:
@@ -165,7 +169,7 @@ def sync_command(
     # 5. Distribute Workflows (if --workflows flag is set)
     if workflows:
         console.print("[bold blue]Distributing Flow Skills as Workflows...[/bold blue]")
-        
+
         try:
             workflow_results = skill_manager.distribute_workflows(force=False, lang=skill_lang)
             success_count = sum(1 for v in workflow_results.values() if v)
@@ -182,6 +186,103 @@ def sync_command(
                 f"[red]  Failed to distribute workflows: {e}[/red]"
             )
 
+    # 6. Sync Universal Hooks (Git & Agent)
+    console.print("[bold blue]Synchronizing Universal Hooks...[/bold blue]")
+
+    try:
+        from monoco.features.hooks import UniversalHookManager, HookType
+        from monoco.features.hooks.dispatchers import (
+            GitHookDispatcher,
+            ClaudeCodeDispatcher,
+            GeminiDispatcher,
+        )
+
+        hooks_manager = UniversalHookManager()
+
+        # Register Dispatchers
+        git_dispatcher = GitHookDispatcher()
+        hooks_manager.register_dispatcher(HookType.GIT, git_dispatcher)
+
+        # Register Agent Dispatchers for active platforms
+        # NOTE: Only Claude Code and Gemini CLI are officially supported
+        agent_dispatchers = {
+            "claude-code": ClaudeCodeDispatcher(),
+            "gemini-cli": GeminiDispatcher(),
+        }
+        for dispatcher in agent_dispatchers.values():
+            hooks_manager.register_dispatcher(HookType.AGENT, dispatcher)
+
+        # 6.1 Scan for hooks
+        all_hooks = []
+
+        # 6.1.1 Scan builtin hooks from hooks feature
+        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 = hooks_manager.scan(builtin_hooks_dir)
+                for group in groups.values():
+                    all_hooks.extend(group.hooks)
+        except Exception as e:
+            console.print(f"[dim]  No builtin hooks found: {e}[/dim]")
+
+        # 6.1.2 Scan for hooks in all active features
+        for feature in active_features:
+            if feature.name == "hooks":
+                continue  # Already scanned
+
+            import importlib
+            try:
+                # Use the module where the feature class is defined (usually adapter.py)
+                module_name = feature.__class__.__module__
+                module = importlib.import_module(module_name)
+
+                if hasattr(module, "__file__") and module.__file__:
+                    # feature_dir is the directory containing adapter.py
+                    feature_dir = Path(module.__file__).parent
+                    hooks_resource_dir = feature_dir / "resources" / "hooks"
+
+                    if hooks_resource_dir.exists():
+                        groups = hooks_manager.scan(hooks_resource_dir)
+                        for group in groups.values():
+                            all_hooks.extend(group.hooks)
+            except Exception:
+                continue
+
+        # 6.2 Sync Git Hooks
+        git_hooks = [h for h in all_hooks if h.metadata.type == HookType.GIT]
+
+        if not (root / ".git").exists():
+            console.print("[dim]  Git repository not found. Initializing...[/dim]")
+            # Set global default branch to main
+            subprocess.run(["git", "config", "--global", "init.defaultBranch", "main"], check=False)
+            subprocess.run(["git", "init"], cwd=root, check=False)
+
+        git_results = git_dispatcher.sync(git_hooks, root)
+
+        git_installed = sum(1 for v in git_results.values() if v)
+        if git_installed > 0:
+            console.print(f"[green]  ✓ Synchronized {git_installed} Git hooks[/green]")
+        elif git_hooks:
+            console.print("[yellow]  No Git hooks were successfully synchronized[/yellow]")
+
+        # 6.3 Sync Agent Hooks using the new ACL-based dispatchers
+        agent_hooks = [h for h in all_hooks if h.metadata.type == HookType.AGENT]
+
+        for provider, dispatcher in agent_dispatchers.items():
+            provider_hooks = [h for h in agent_hooks if h.metadata.provider == provider]
+            if provider_hooks:
+                results = dispatcher.sync(provider_hooks, root)
+                success_count = sum(1 for v in results.values() if v)
+                if success_count > 0:
+                    console.print(f"[green]  ✓ Synchronized {success_count} agent hooks to {provider}[/green]")
+
+    except Exception as e:
+        console.print(f"[red]  Failed to synchronize Universal Hooks: {e}[/red]")
+        import traceback
+        console.print(f"[dim]{traceback.format_exc()}[/dim]")
+
     # 4. Determine Targets
     targets = _get_targets(root, config, target)
 
@@ -299,7 +400,7 @@ def uninstall_command(
 
     # 3. Clean up Workflows
     console.print("[bold blue]Cleaning up distributed workflows...[/bold blue]")
-    
+
     try:
         removed_count = skill_manager.cleanup_workflows()
         if removed_count > 0:
@@ -310,3 +411,97 @@ def uninstall_command(
         console.print(
             f"[red]  Failed to clean workflows: {e}[/red]"
         )
+
+    # 4. Clean up Git Hooks
+    console.print("[bold blue]Cleaning up Git Hooks...[/bold blue]")
+
+    try:
+        from monoco.features.hooks.dispatchers import GitHookDispatcher
+
+        git_dispatcher = GitHookDispatcher()
+        installed = git_dispatcher.list_installed(root)
+
+        uninstalled = 0
+        for hook_info in installed:
+            if git_dispatcher.uninstall(hook_info["event"], root):
+                uninstalled += 1
+
+        if uninstalled > 0:
+            console.print(
+                f"[green]  ✓ Removed {uninstalled} Git hooks[/green]"
+            )
+        else:
+            console.print("[dim]  No Monoco Git hooks to clean up[/dim]")
+    except Exception as e:
+        console.print(f"[red]  Failed to clean Git hooks: {e}[/red]")
+
+    # 5. Clean up Agent Hooks
+    console.print("[bold blue]Cleaning up Agent Hooks...[/bold blue]")
+
+    try:
+        from monoco.features.hooks.dispatchers import (
+            ClaudeCodeDispatcher,
+            GeminiDispatcher,
+        )
+
+        # Clean up Claude Code hooks
+        claude_dispatcher = ClaudeCodeDispatcher()
+        claude_settings = claude_dispatcher.get_settings_path(root)
+        if claude_settings and claude_settings.exists():
+            try:
+                import json
+                with open(claude_settings, "r", encoding="utf-8") as f:
+                    settings = json.load(f)
+
+                if "hooks" in settings:
+                    original_count = len(settings["hooks"])
+                    # Remove Monoco-managed hooks
+                    for event in list(settings["hooks"].keys()):
+                        configs = settings["hooks"][event]
+                        if isinstance(configs, list):
+                            settings["hooks"][event] = [
+                                c for c in configs if not c.get("_monoco_managed")
+                            ]
+                    # Clean up empty events
+                    settings["hooks"] = {
+                        k: v for k, v in settings["hooks"].items() if v
+                    }
+
+                    with open(claude_settings, "w", encoding="utf-8") as f:
+                        json.dump(settings, f, indent=2, ensure_ascii=False)
+
+                    console.print("[green]  ✓ Cleaned up Claude Code hooks[/green]")
+            except Exception as e:
+                console.print(f"[red]  Failed to clean Claude Code hooks: {e}[/red]")
+
+        # Clean up Gemini CLI hooks
+        gemini_dispatcher = GeminiDispatcher()
+        gemini_settings = gemini_dispatcher.get_settings_path(root)
+        if gemini_settings and gemini_settings.exists():
+            try:
+                import json
+                with open(gemini_settings, "r", encoding="utf-8") as f:
+                    settings = json.load(f)
+
+                if "hooks" in settings:
+                    # Remove Monoco-managed hooks
+                    for event in list(settings["hooks"].keys()):
+                        configs = settings["hooks"][event]
+                        if isinstance(configs, list):
+                            settings["hooks"][event] = [
+                                c for c in configs if not c.get("_monoco_managed")
+                            ]
+                    # Clean up empty events
+                    settings["hooks"] = {
+                        k: v for k, v in settings["hooks"].items() if v
+                    }
+
+                    with open(gemini_settings, "w", encoding="utf-8") as f:
+                        json.dump(settings, f, indent=2, ensure_ascii=False)
+
+                    console.print("[green]  ✓ Cleaned up Gemini CLI hooks[/green]")
+            except Exception as e:
+                console.print(f"[red]  Failed to clean Gemini CLI hooks: {e}[/red]")
+
+    except Exception as e:
+        console.print(f"[red]  Failed to clean Agent hooks: {e}[/red]")

monoco/core/watcher/__init__.py

@@ -35,6 +35,7 @@ from .issue import IssueWatcher, IssueFileEvent
 from .memo import MemoWatcher, MemoFileEvent
 from .task import TaskWatcher, TaskFileEvent
 from .dropzone import DropzoneWatcher, DropzoneFileEvent
+from .im import IMWatcher, IMFileEvent, IMInboundWatcher, IMWebhookWatcher
 
 __all__ = [
     # Base classes
@@ -54,4 +55,9 @@ __all__ = [
     "TaskFileEvent",
     "DropzoneWatcher",
     "DropzoneFileEvent",
+    # IM watchers (FEAT-0167)
+    "IMWatcher",
+    "IMFileEvent",
+    "IMInboundWatcher",
+    "IMWebhookWatcher",
 ]

monoco/core/watcher/base.py

@@ -180,6 +180,23 @@ class FilesystemWatcher(ABC):
         if callback in self._callbacks:
             self._callbacks.remove(callback)
     
+    def _is_async_callable(self, callback: Callable) -> bool:
+        """
+        Check if a callable is async (coroutine function or has async __call__).
+        
+        This handles both:
+        - Regular async functions: async def func(): ...
+        - Callable objects with async __call__: class Handler: async def __call__(self, ...): ...
+        """
+        # Direct check for coroutine function
+        if inspect.iscoroutinefunction(callback):
+            return True
+        # Check for callable object with async __call__ method
+        if hasattr(callback, "__call__") and not inspect.ismethod(callback):
+            if inspect.iscoroutinefunction(callback.__call__):
+                return True
+        return False
+
     async def emit(self, event: FileEvent) -> None:
         """
         Emit a file event to all registered callbacks and EventBus.
@@ -190,7 +207,7 @@ class FilesystemWatcher(ABC):
         # Call local callbacks
         for callback in self._callbacks:
             try:
-                if inspect.iscoroutinefunction(callback):
+                if self._is_async_callable(callback):
                     await callback(event)
                 else:
                     callback(event)