monoco-toolkit 0.3.11__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

@@ -0,0 +1,63 @@
+"""
+Watcher Module - Layer 1 of the Event Automation Framework.
+
+This module provides file system watching capabilities with event emission.
+It is part of the three-layer architecture:
+- Layer 1: File Watcher (this module)
+- Layer 2: Action Router
+- Layer 3: Action Executor
+
+Example Usage:
+    >>> from monoco.core.watcher import IssueWatcher, WatchConfig
+    >>> from pathlib import Path
+    >>> 
+    >>> config = WatchConfig(
+    ...     path=Path("./Issues"),
+    ...     patterns=["*.md"],
+    ...     recursive=True,
+    ... )
+    >>> watcher = IssueWatcher(config)
+    >>> await watcher.start()
+    >>> # Events are automatically emitted to EventBus
+    >>> await watcher.stop()
+"""
+
+from .base import (
+    ChangeType,
+    FieldChange,
+    FileEvent,
+    FilesystemWatcher,
+    PollingWatcher,
+    WatchdogWatcher,
+    WatchConfig,
+)
+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
+    "ChangeType",
+    "FieldChange",
+    "FileEvent",
+    "FilesystemWatcher",
+    "PollingWatcher",
+    "WatchdogWatcher",
+    "WatchConfig",
+    # Concrete watchers
+    "IssueWatcher",
+    "IssueFileEvent",
+    "MemoWatcher",
+    "MemoFileEvent",
+    "TaskWatcher",
+    "TaskFileEvent",
+    "DropzoneWatcher",
+    "DropzoneFileEvent",
+    # IM watchers (FEAT-0167)
+    "IMWatcher",
+    "IMFileEvent",
+    "IMInboundWatcher",
+    "IMWebhookWatcher",
+]

monoco/core/watcher/base.py

@@ -0,0 +1,382 @@
+"""
+Base abstractions for FilesystemWatcher - Layer 1 of the event automation framework.
+
+This module defines the core abstractions for file system event watching:
+- FilesystemWatcher: Abstract base class for all file watchers
+- FileEvent: Dataclass representing a file system event
+- WatchConfig: Configuration for file watching
+- ChangeType: Enum for types of file changes
+"""
+
+from __future__ import annotations
+
+import asyncio
+import inspect
+import logging
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum, auto
+from pathlib import Path
+from typing import Any, Callable, Dict, List, Optional, Set, Union
+
+from monoco.core.scheduler import AgentEventType, EventBus, event_bus
+
+logger = logging.getLogger(__name__)
+
+
+class ChangeType(Enum):
+    """Types of file system changes."""
+    CREATED = "created"
+    MODIFIED = "modified"
+    DELETED = "deleted"
+    MOVED = "moved"
+    RENAMED = "renamed"
+
+
+@dataclass
+class FileEvent:
+    """
+    Represents a file system event.
+    
+    Attributes:
+        path: Path to the file or directory
+        change_type: Type of change (created, modified, deleted, etc.)
+        watcher_name: Name of the watcher that emitted this event
+        old_path: Original path for move/rename events
+        old_content: Previous content hash or snapshot (for content tracking)
+        new_content: Current content hash or snapshot
+        metadata: Additional event metadata
+        timestamp: Event timestamp
+    """
+    path: Path
+    change_type: ChangeType
+    watcher_name: str
+    old_path: Optional[Path] = None
+    old_content: Optional[str] = None
+    new_content: Optional[str] = None
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    timestamp: datetime = field(default_factory=datetime.now)
+    
+    def to_agent_event_type(self) -> Optional[AgentEventType]:
+        """Convert FileEvent to AgentEventType if applicable."""
+        # This will be overridden by specific watchers
+        return None
+    
+    def to_payload(self) -> Dict[str, Any]:
+        """Convert to payload dict for EventBus."""
+        return {
+            "path": str(self.path),
+            "change_type": self.change_type.value,
+            "watcher_name": self.watcher_name,
+            "old_path": str(self.old_path) if self.old_path else None,
+            "old_content": self.old_content,
+            "new_content": self.new_content,
+            "metadata": self.metadata,
+            "timestamp": self.timestamp.isoformat(),
+        }
+
+
+@dataclass
+class WatchConfig:
+    """
+    Configuration for file watching.
+    
+    Attributes:
+        path: Path to watch (file or directory)
+        patterns: Glob patterns to match (e.g., "*.md", "*.yaml")
+        exclude_patterns: Patterns to exclude
+        recursive: Whether to watch recursively
+        field_extractors: Optional field extractors for content parsing
+        poll_interval: Polling interval in seconds (for polling-based watchers)
+    """
+    path: Path
+    patterns: List[str] = field(default_factory=lambda: ["*"])
+    exclude_patterns: List[str] = field(default_factory=list)
+    recursive: bool = True
+    field_extractors: Dict[str, Callable[[str], Any]] = field(default_factory=dict)
+    poll_interval: float = 5.0
+    
+    def should_watch(self, file_path: Path) -> bool:
+        """Check if a file should be watched based on patterns."""
+        # Check exclude patterns first
+        for pattern in self.exclude_patterns:
+            if file_path.match(pattern):
+                return False
+        
+        # Check include patterns
+        for pattern in self.patterns:
+            if file_path.match(pattern):
+                return True
+        
+        return False
+
+
+@dataclass
+class FieldChange:
+    """Represents a change in a specific field."""
+    field_name: str
+    old_value: Any
+    new_value: Any
+    change_type: ChangeType = ChangeType.MODIFIED
+
+
+class FilesystemWatcher(ABC):
+    """
+    Abstract base class for file system watchers (Layer 1).
+    
+    Responsibilities:
+    - Monitor file system changes
+    - Emit FileEvent objects
+    - Integrate with EventBus for event publishing
+    
+    Lifecycle:
+        1. Create watcher with config
+        2. Call start() to begin watching
+        3. File events are emitted via emit() or callbacks
+        4. Call stop() to cleanup
+    
+    Example:
+        >>> config = WatchConfig(path=Path("./Issues"), patterns=["*.md"])
+        >>> watcher = IssueWatcher(config)
+        >>> await watcher.start()
+        >>> # Events are automatically emitted to EventBus
+        >>> await watcher.stop()
+    """
+    
+    def __init__(
+        self,
+        config: WatchConfig,
+        event_bus: Optional[EventBus] = None,
+        name: Optional[str] = None,
+    ):
+        self.config = config
+        self.event_bus = event_bus or event_bus
+        self.name = name or self.__class__.__name__
+        self._running = False
+        self._callbacks: List[Callable[[FileEvent], None]] = []
+        self._state_cache: Dict[str, Any] = {}  # For tracking state changes
+    
+    @abstractmethod
+    async def start(self) -> None:
+        """Start watching the file system."""
+        pass
+    
+    @abstractmethod
+    async def stop(self) -> None:
+        """Stop watching and cleanup resources."""
+        pass
+    
+    def is_running(self) -> bool:
+        """Check if the watcher is currently running."""
+        return self._running
+    
+    def register_callback(self, callback: Callable[[FileEvent], None]) -> None:
+        """Register a callback for file events."""
+        self._callbacks.append(callback)
+    
+    def unregister_callback(self, callback: Callable[[FileEvent], None]) -> None:
+        """Unregister a callback."""
+        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.
+        
+        Args:
+            event: The FileEvent to emit
+        """
+        # Call local callbacks
+        for callback in self._callbacks:
+            try:
+                if self._is_async_callable(callback):
+                    await callback(event)
+                else:
+                    callback(event)
+            except Exception as e:
+                logger.error(f"Error in callback for {event}: {e}")
+        
+        # Publish to EventBus if available
+        if self.event_bus:
+            try:
+                agent_event_type = event.to_agent_event_type()
+                if agent_event_type:
+                    await self.event_bus.publish(
+                        agent_event_type,
+                        event.to_payload(),
+                        source=f"watcher.{self.name}",
+                    )
+            except Exception as e:
+                logger.error(f"Error publishing to EventBus: {e}")
+    
+    def _get_file_hash(self, file_path: Path) -> Optional[str]:
+        """Get a hash of file content for change detection."""
+        try:
+            import hashlib
+            content = file_path.read_text(encoding="utf-8")
+            return hashlib.md5(content.encode()).hexdigest()
+        except Exception:
+            return None
+    
+    def _read_file_content(self, file_path: Path) -> Optional[str]:
+        """Read file content safely."""
+        try:
+            return file_path.read_text(encoding="utf-8")
+        except Exception as e:
+            logger.debug(f"Could not read {file_path}: {e}")
+            return None
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """Get watcher statistics."""
+        return {
+            "name": self.name,
+            "running": self._running,
+            "config": {
+                "path": str(self.config.path),
+                "patterns": self.config.patterns,
+                "recursive": self.config.recursive,
+            },
+            "callbacks": len(self._callbacks),
+        }
+
+
+class PollingWatcher(FilesystemWatcher):
+    """
+    Base class for polling-based file watchers.
+    
+    Useful for watching specific files or when native file system
+    events are not available/reliable.
+    """
+    
+    def __init__(
+        self,
+        config: WatchConfig,
+        event_bus: Optional[EventBus] = None,
+        name: Optional[str] = None,
+    ):
+        super().__init__(config, event_bus, name)
+        self._poll_task: Optional[asyncio.Task] = None
+        self._file_states: Dict[Path, Dict[str, Any]] = {}
+    
+    async def start(self) -> None:
+        """Start polling loop."""
+        if self._running:
+            return
+        
+        self._running = True
+        self._poll_task = asyncio.create_task(self._poll_loop())
+        logger.info(f"Started polling watcher: {self.name}")
+    
+    async def stop(self) -> None:
+        """Stop polling loop."""
+        if not self._running:
+            return
+        
+        self._running = False
+        
+        if self._poll_task:
+            self._poll_task.cancel()
+            try:
+                await self._poll_task
+            except asyncio.CancelledError:
+                pass
+            self._poll_task = None
+        
+        logger.info(f"Stopped polling watcher: {self.name}")
+    
+    async def _poll_loop(self) -> None:
+        """Main polling loop."""
+        while self._running:
+            try:
+                await self._check_changes()
+                await asyncio.sleep(self.config.poll_interval)
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                logger.error(f"Error in poll loop: {e}")
+                await asyncio.sleep(self.config.poll_interval)
+    
+    @abstractmethod
+    async def _check_changes(self) -> None:
+        """Check for changes - implement in subclass."""
+        pass
+    
+    def _scan_files(self) -> Dict[Path, Dict[str, Any]]:
+        """Scan watched path and return file states."""
+        states = {}
+        
+        if self.config.path.is_file():
+            files = [self.config.path]
+        else:
+            if self.config.recursive:
+                files = list(self.config.path.rglob("*"))
+            else:
+                files = list(self.config.path.glob("*"))
+        
+        for file_path in files:
+            if not file_path.is_file():
+                continue
+            
+            if not self.config.should_watch(file_path):
+                continue
+            
+            try:
+                stat = file_path.stat()
+                content = self._read_file_content(file_path)
+                states[file_path] = {
+                    "mtime": stat.st_mtime,
+                    "size": stat.st_size,
+                    "content": content,
+                    "hash": self._get_file_hash(file_path) if content else None,
+                }
+            except Exception as e:
+                logger.debug(f"Could not stat {file_path}: {e}")
+        
+        return states
+
+
+class WatchdogWatcher(FilesystemWatcher):
+    """
+    Base class for watchdog-based file watchers.
+    
+    Uses the watchdog library for efficient native file system events.
+    """
+    
+    def __init__(
+        self,
+        config: WatchConfig,
+        event_bus: Optional[EventBus] = None,
+        name: Optional[str] = None,
+    ):
+        super().__init__(config, event_bus, name)
+        self._observer: Optional[Any] = None
+    
+    def _should_process(self, file_path: Path) -> bool:
+        """Check if a file should be processed."""
+        # Skip hidden files
+        if file_path.name.startswith("."):
+            return False
+        
+        # Skip temporary files
+        if file_path.suffix in (".tmp", ".temp", ".part", ".swp", "~"):
+            return False
+        
+        return self.config.should_watch(file_path)