devloop 0.2.0__py3-none-any.whl

devloop/collectors/filesystem.py

@@ -0,0 +1,126 @@
+"""Filesystem event collector using watchdog."""
+
+import asyncio
+from pathlib import Path
+from typing import Any, Dict
+
+from watchdog.events import FileSystemEvent, FileSystemEventHandler
+from watchdog.observers import Observer
+
+from devloop.collectors.base import BaseCollector
+from devloop.core.event import EventBus
+
+
+class FileSystemCollector(BaseCollector, FileSystemEventHandler):
+    """Collects filesystem events and emits them to the event bus."""
+
+    def __init__(self, event_bus: EventBus, config: Dict[str, Any] | None = None):
+        super().__init__("filesystem", event_bus, config)
+
+        self.watch_paths = self.config.get("watch_paths", ["."])
+        self.ignore_patterns = self.config.get(
+            "ignore_patterns",
+            [
+                "*/.git/*",
+                "*/__pycache__/*",
+                "*/.devloop/*",
+                "*/node_modules/*",
+                "*/.venv/*",
+                "*/venv/*",
+            ],
+        )
+        self.observer = Observer()
+        self._loop = None  # Store reference to the event loop
+
+    def should_ignore(self, path: str) -> bool:
+        """Check if path should be ignored."""
+        path_obj = Path(path)
+
+        for pattern in self.ignore_patterns:
+            # Simple pattern matching (could be improved with fnmatch)
+            pattern_clean = pattern.replace("*/", "").replace("/*", "")
+            if pattern_clean in str(path_obj):
+                return True
+
+        return False
+
+    def on_created(self, event: FileSystemEvent) -> None:
+        """Handle file/directory created."""
+        if event.is_directory or self.should_ignore(event.src_path):
+            return
+
+        self._emit_event_sync("file:created", event.src_path)
+
+    def on_modified(self, event: FileSystemEvent) -> None:
+        """Handle file/directory modified."""
+        if event.is_directory or self.should_ignore(event.src_path):
+            return
+
+        self._emit_event_sync("file:modified", event.src_path)
+
+    def on_deleted(self, event: FileSystemEvent) -> None:
+        """Handle file/directory deleted."""
+        if event.is_directory or self.should_ignore(event.src_path):
+            return
+
+        self._emit_event_sync("file:deleted", event.src_path)
+
+    def on_moved(self, event: FileSystemEvent) -> None:
+        """Handle file/directory moved/renamed."""
+        if event.is_directory or self.should_ignore(event.src_path):
+            return
+
+        self._emit_event_sync(
+            "file:moved",
+            event.src_path,
+            {"dest_path": event.dest_path if hasattr(event, "dest_path") else None},
+        )
+
+    def _emit_event_sync(
+        self, event_type: str, path: str, extra_payload: Dict[str, Any] | None = None
+    ) -> None:
+        """Emit a filesystem event to the event bus (synchronous version for watchdog threads)."""
+        payload = {"path": path, "absolute_path": str(Path(path).absolute())}
+
+        if extra_payload:
+            payload.update(extra_payload)
+
+        # Schedule coroutine from watchdog thread to asyncio event loop
+        # This is thread-safe and handles the watchdog (threading) -> asyncio bridge
+        if self._loop and self._loop.is_running():
+            asyncio.run_coroutine_threadsafe(
+                self._emit_event(event_type, payload, "normal", "filesystem"),
+                self._loop,
+            )
+
+    async def start(self) -> None:
+        """Start watching filesystem."""
+        if self.is_running:
+            return
+
+        self._set_running(True)
+
+        # Capture the current event loop for thread-safe event emission
+        self._loop = asyncio.get_running_loop()
+
+        # Schedule watches for all paths
+        for path in self.watch_paths:
+            watch_path = Path(path).absolute()
+            if watch_path.exists():
+                self.observer.schedule(self, str(watch_path), recursive=True)
+                self.logger.info(f"Watching: {watch_path}")
+            else:
+                self.logger.warning(f"Path does not exist: {watch_path}")
+
+        self.observer.start()
+        self.logger.info("Filesystem collector started")
+
+    async def stop(self) -> None:
+        """Stop watching filesystem."""
+        if not self.is_running:
+            return
+
+        self._set_running(False)
+        self.observer.stop()
+        self.observer.join()
+        self.logger.info("Filesystem collector stopped")

devloop/collectors/git.py

@@ -0,0 +1,171 @@
+"""Git event collector using git hooks and monitoring."""
+
+from __future__ import annotations
+
+import subprocess  # nosec B404 - Required for git operations
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from devloop.collectors.base import BaseCollector
+from devloop.core.event import EventBus
+
+
+class GitCollector(BaseCollector):
+    """Collects git-related events through hooks and monitoring."""
+
+    def __init__(self, event_bus: EventBus, config: Optional[Dict[str, Any]] = None):
+        super().__init__("git", event_bus, config)
+        self.git_hooks = [
+            "pre-commit",
+            "prepare-commit-msg",
+            "commit-msg",
+            "post-commit",
+            "pre-rebase",
+            "post-checkout",
+            "post-merge",
+            "pre-push",
+            "post-rewrite",
+        ]
+        self.repo_path = Path(self.config.get("repo_path", ".")).absolute()
+        self.installed_hooks: Dict[str, Path] = {}
+
+    def _is_git_repo(self) -> bool:
+        """Check if current directory is a git repository."""
+        try:
+            result = subprocess.run(
+                ["git", "rev-parse", "--git-dir"],  # nosec
+                cwd=self.repo_path,
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+            return result.returncode == 0
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            return False
+
+    def _get_hooks_dir(self) -> Path:
+        """Get the git hooks directory."""
+        return self.repo_path / ".git" / "hooks"
+
+    def _install_hook(self, hook_name: str) -> bool:
+        """Install a git hook script."""
+        hooks_dir = self._get_hooks_dir()
+        hook_path = hooks_dir / hook_name
+
+        # Create hook script content
+        hook_script = f"""#!/bin/bash
+# Claude Agents Git Hook - {hook_name}
+
+# Export environment for Python
+export PYTHONPATH="$(dirname $(dirname $(dirname $(dirname $(dirname "$0")))))/src"
+
+# Call the collector
+python3 -c "
+import asyncio
+import sys
+import os
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))))
+from devloop.collectors.git import GitCollector
+
+async def emit_hook_event():
+    # Import here to avoid circular imports
+    from devloop.core.event import EventBus, Event, Priority
+    import os
+
+    event_bus = EventBus()
+    collector = GitCollector(event_bus)
+
+    payload = {{
+        'hook': '{hook_name}',
+        'repo_path': '{str(self.repo_path)}',
+        'args': list(sys.argv[1:]),
+        'env': dict(os.environ)
+    }}
+
+    await collector._emit_event(f'git:{hook_name}', payload, 'high')
+
+asyncio.run(emit_hook_event())
+"
+
+# Continue with original hook if it exists
+if [ -f "$0.original" ]; then
+    exec "$0.original" "$@"
+fi
+"""
+
+        try:
+            # Backup original hook if it exists
+            if hook_path.exists():
+                backup_path = hook_path.with_suffix(".original")
+                if not backup_path.exists():
+                    hook_path.rename(backup_path)
+                    self.logger.info(f"Backed up original {hook_name} hook")
+
+            # Write new hook
+            hook_path.write_text(hook_script)
+            hook_path.chmod(0o755)
+
+            self.installed_hooks[hook_name] = hook_path
+            self.logger.info(f"Installed {hook_name} hook")
+            return True
+
+        except Exception as e:
+            self.logger.error(f"Failed to install {hook_name} hook: {e}")
+            return False
+
+    def _uninstall_hooks(self) -> None:
+        """Uninstall all git hooks."""
+        for hook_name, hook_path in self.installed_hooks.items():
+            try:
+                # Restore original hook if it exists
+                original_path = hook_path.with_suffix(".original")
+                if original_path.exists():
+                    original_path.rename(hook_path)
+                    self.logger.info(f"Restored original {hook_name} hook")
+                elif hook_path.exists():
+                    hook_path.unlink()
+                    self.logger.info(f"Removed {hook_name} hook")
+
+            except Exception as e:
+                self.logger.error(f"Failed to uninstall {hook_name} hook: {e}")
+
+        self.installed_hooks.clear()
+
+    async def start(self) -> None:
+        """Start the git collector."""
+        if self.is_running:
+            return
+
+        if not self._is_git_repo():
+            self.logger.warning(f"Not a git repository: {self.repo_path}")
+            return
+
+        self._set_running(True)
+
+        # Install git hooks
+        hooks_dir = self._get_hooks_dir()
+        hooks_dir.mkdir(parents=True, exist_ok=True)
+
+        installed_count = 0
+        for hook_name in self.git_hooks:
+            if self.config.get("auto_install_hooks", True):
+                if self._install_hook(hook_name):
+                    installed_count += 1
+
+        self.logger.info(f"Git collector started - installed {installed_count} hooks")
+
+    async def stop(self) -> None:
+        """Stop the git collector."""
+        if not self.is_running:
+            return
+
+        # Uninstall hooks if we installed them
+        if self.config.get("auto_install_hooks", True):
+            self._uninstall_hooks()
+
+        self._set_running(False)
+        self.logger.info("Git collector stopped")
+
+    async def emit_git_event(self, event_type: str, payload: Dict[str, Any]) -> None:
+        """Manually emit a git event (for testing or external triggers)."""
+        await self._emit_event(f"git:{event_type}", payload, "normal", "git")

devloop/collectors/manager.py

@@ -0,0 +1,159 @@
+"""Collector manager for coordinating all event collectors."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from typing import Any, Dict, List, Optional, Type
+
+from devloop.collectors.base import BaseCollector
+from devloop.collectors.filesystem import FileSystemCollector
+from devloop.collectors.git import GitCollector
+from devloop.collectors.process import ProcessCollector
+from devloop.collectors.system import SystemCollector
+from devloop.core.event import EventBus
+
+
+class CollectorManager:
+    """Manages all event collectors and their lifecycle."""
+
+    def __init__(self, event_bus: EventBus):
+        self.event_bus = event_bus
+        self.collectors: Dict[str, BaseCollector] = {}
+        self.logger = logging.getLogger("collector_manager")
+        self._running = False
+
+        # Register built-in collectors
+        self._collector_classes: Dict[str, Type[BaseCollector]] = {
+            "filesystem": FileSystemCollector,
+            "git": GitCollector,
+            "process": ProcessCollector,
+            "system": SystemCollector,
+        }
+
+    def register_collector_class(
+        self, name: str, collector_class: Type[BaseCollector]
+    ) -> None:
+        """Register a new collector class."""
+        self._collector_classes[name] = collector_class
+        self.logger.info(f"Registered collector class: {name}")
+
+    def create_collector(
+        self, name: str, config: Optional[Dict[str, Any]] = None
+    ) -> Optional[BaseCollector]:
+        """Create a collector instance."""
+        if name not in self._collector_classes:
+            self.logger.error(f"Unknown collector type: {name}")
+            return None
+
+        try:
+            collector_class = self._collector_classes[name]
+            collector = collector_class(self.event_bus, config)
+            self.collectors[name] = collector
+            self.logger.info(f"Created collector: {name}")
+            return collector
+        except Exception as e:
+            self.logger.error(f"Failed to create collector {name}: {e}")
+            return None
+
+    async def start_collector(self, name: str) -> bool:
+        """Start a specific collector."""
+        if name not in self.collectors:
+            self.logger.error(f"Collector not found: {name}")
+            return False
+
+        try:
+            await self.collectors[name].start()
+            self.logger.info(f"Started collector: {name}")
+            return True
+        except Exception as e:
+            self.logger.error(f"Failed to start collector {name}: {e}")
+            return False
+
+    async def stop_collector(self, name: str) -> bool:
+        """Stop a specific collector."""
+        if name not in self.collectors:
+            self.logger.warning(f"Collector not found: {name}")
+            return False
+
+        try:
+            await self.collectors[name].stop()
+            self.logger.info(f"Stopped collector: {name}")
+            return True
+        except Exception as e:
+            self.logger.error(f"Failed to stop collector {name}: {e}")
+            return False
+
+    async def start_all(self) -> None:
+        """Start all registered collectors."""
+        if self._running:
+            return
+
+        self._running = True
+        self.logger.info("Starting all collectors...")
+
+        # Start collectors in dependency order
+        start_order = ["filesystem", "git", "process"]  # filesystem first, then others
+
+        started_count = 0
+        for name in start_order:
+            if name in self.collectors:
+                if await self.start_collector(name):
+                    started_count += 1
+
+        # Start any remaining collectors not in the ordered list
+        for name, collector in self.collectors.items():
+            if name not in start_order and not collector.is_running:
+                if await self.start_collector(name):
+                    started_count += 1
+
+        self.logger.info(f"Started {started_count}/{len(self.collectors)} collectors")
+
+    async def stop_all(self) -> None:
+        """Stop all collectors."""
+        if not self._running:
+            return
+
+        self._running = False
+        self.logger.info("Stopping all collectors...")
+
+        # Stop in reverse order
+        stop_tasks = []
+        for collector in self.collectors.values():
+            if collector.is_running:
+                stop_tasks.append(self._safe_stop_collector(collector))
+
+        if stop_tasks:
+            await asyncio.gather(*stop_tasks, return_exceptions=True)
+
+        self.logger.info("All collectors stopped")
+
+    async def _safe_stop_collector(self, collector: BaseCollector) -> None:
+        """Safely stop a collector with error handling."""
+        try:
+            await collector.stop()
+        except Exception as e:
+            self.logger.error(f"Error stopping collector {collector.name}: {e}")
+
+    def get_status(self) -> Dict[str, Dict[str, Any]]:
+        """Get status of all collectors."""
+        return {
+            name: {
+                "running": collector.is_running,
+                "type": type(collector).__name__,
+                "config": collector.config,
+            }
+            for name, collector in self.collectors.items()
+        }
+
+    def get_collector(self, name: str) -> Optional[BaseCollector]:
+        """Get a collector by name."""
+        return self.collectors.get(name)
+
+    def list_available_collectors(self) -> List[str]:
+        """List all available collector types."""
+        return list(self._collector_classes.keys())
+
+    def list_active_collectors(self) -> List[str]:
+        """List names of active collectors."""
+        return list(self.collectors.keys())

devloop/collectors/process.py

@@ -0,0 +1,221 @@
+"""Process event collector using psutil monitoring."""
+
+from __future__ import annotations
+
+import asyncio
+import time
+from typing import Any, Dict, Optional
+
+try:
+    import psutil
+
+    HAS_PSUTIL = True
+except ImportError:
+    HAS_PSUTIL = False
+    psutil = None
+
+from devloop.collectors.base import BaseCollector
+
+
+class ProcessCollector(BaseCollector):
+    """Collects process-related events like script completion and build events."""
+
+    def __init__(
+        self,
+        event_bus: Any,  # EventBus type (avoiding circular import)
+        config: Optional[Dict[str, Any]] = None,
+    ):
+        super().__init__("process", event_bus, config)
+
+        if not HAS_PSUTIL:
+            self.logger.warning("psutil not available - process monitoring disabled")
+            self._psutil_available = False
+        else:
+            self._psutil_available = True
+
+        self.monitored_processes: Dict[int, Dict[str, Any]] = {}
+        self.monitoring_patterns = self.config.get(
+            "patterns",
+            [
+                "pytest",
+                "python",
+                "node",
+                "npm",
+                "yarn",
+                "make",
+                "gradle",
+                "maven",
+                "cargo",
+                "go",
+                "rustc",
+            ],
+        )
+        self._monitoring_task: Optional[asyncio.Task] = None
+
+    def _should_monitor_process(self, process: Any) -> bool:
+        """Check if a process should be monitored."""
+        if not self._psutil_available:
+            return False
+
+        try:
+            cmdline = process.cmdline()
+            process_name = process.name().lower()
+
+            # Check if process name matches any pattern
+            for pattern in self.monitoring_patterns:
+                if pattern.lower() in process_name:
+                    return True
+
+            # Check command line for build/dev scripts
+            cmdline_str = " ".join(cmdline).lower()
+            if any(
+                script in cmdline_str
+                for script in ["test", "build", "lint", "format", "check", "run"]
+            ):
+                return True
+
+        except (psutil.AccessDenied, psutil.NoSuchProcess):
+            pass
+
+        return False
+
+    async def _monitor_processes(self) -> None:
+        """Monitor running processes and track their completion."""
+        if not self._psutil_available:
+            return
+
+        while self.is_running:
+            try:
+                # Get current processes
+                current_pids = set()
+
+                for process in psutil.process_iter(
+                    ["pid", "name", "cmdline", "create_time"]
+                ):
+                    try:
+                        pid = process.info["pid"]
+                        current_pids.add(pid)
+
+                        # Check if we should monitor this process
+                        if self._should_monitor_process(process):
+                            if pid not in self.monitored_processes:
+                                # New process to monitor
+                                self.monitored_processes[pid] = {
+                                    "info": process.info,
+                                    "start_time": process.info.get(
+                                        "create_time", time.time()
+                                    ),
+                                }
+                                self.logger.debug(
+                                    f"Started monitoring process {pid}: {process.info['name']}"
+                                )
+
+                    except (psutil.AccessDenied, psutil.NoSuchProcess):
+                        continue
+
+                # Check for completed processes
+                completed_pids = []
+                for pid, process_data in self.monitored_processes.items():
+                    if pid not in current_pids:
+                        # Process completed
+                        completed_pids.append(pid)
+                        await self._handle_process_completion(pid, process_data)
+
+                # Remove completed processes
+                for pid in completed_pids:
+                    del self.monitored_processes[pid]
+
+            except Exception as e:
+                self.logger.error(f"Error monitoring processes: {e}")
+
+            await asyncio.sleep(1.0)  # Check every second
+
+    async def _handle_process_completion(
+        self, pid: int, process_data: Dict[str, Any]
+    ) -> None:
+        """Handle process completion event."""
+        try:
+            info = process_data["info"]
+            start_time = process_data["start_time"]
+            duration = time.time() - start_time
+
+            # Determine event type based on process
+            event_type = "process:completed"
+            process_name = info.get("name", "unknown")
+
+            # Categorize the process
+            if any(term in process_name.lower() for term in ["pytest", "test"]):
+                event_type = "test:completed"
+            elif any(
+                term in process_name.lower()
+                for term in ["lint", "flake8", "ruff", "eslint"]
+            ):
+                event_type = "lint:completed"
+            elif any(
+                term in process_name.lower() for term in ["format", "black", "prettier"]
+            ):
+                event_type = "format:completed"
+            elif any(
+                term in process_name.lower()
+                for term in ["build", "make", "gradle", "maven", "cargo"]
+            ):
+                event_type = "build:completed"
+
+            payload = {
+                "pid": pid,
+                "name": process_name,
+                "cmdline": info.get("cmdline", []),
+                "duration": duration,
+                "start_time": start_time,
+                "end_time": time.time(),
+            }
+
+            await self._emit_event(event_type, payload, "normal", "process")
+            self.logger.info(
+                f"Process completed: {process_name} (PID: {pid}, duration: {duration:.2f}s)"
+            )
+
+        except Exception as e:
+            self.logger.error(f"Error handling process completion for PID {pid}: {e}")
+
+    async def start(self) -> None:
+        """Start the process collector."""
+        if self.is_running:
+            return
+
+        if not self._psutil_available:
+            self.logger.error("Cannot start process collector - psutil not available")
+            return
+
+        self._set_running(True)
+
+        # Start monitoring task
+        self._monitoring_task = asyncio.create_task(self._monitor_processes())
+
+        self.logger.info("Process collector started")
+
+    async def stop(self) -> None:
+        """Stop the process collector."""
+        if not self.is_running:
+            return
+
+        self._set_running(False)
+
+        # Cancel monitoring task
+        if self._monitoring_task:
+            self._monitoring_task.cancel()
+            try:
+                await self._monitoring_task
+            except asyncio.CancelledError:
+                pass
+
+        # Clear monitored processes
+        self.monitored_processes.clear()
+
+        self.logger.info("Process collector stopped")
+
+    async def emit_process_event(
+        self, event_type: str, payload: Dict[str, Any]
+    ) -> None:
+        """Manually emit a process event (for testing or external triggers)."""
+        await self._emit_event(f"process:{event_type}", payload, "normal", "process")