devtorch-core 3.0.1__py3-none-any.whl

devtorch_core/daemon/watcher.py

@@ -0,0 +1,244 @@
+"""
+Filesystem watcher for the DevTorch background daemon (S26).
+
+Monitors project files for create/modify/delete events and emits them as
+`fs_change` events to `.GCC/events.log.jsonl`.
+
+Uses `watchdog` when available; otherwise falls back to a simple polling
+implementation.
+"""
+from __future__ import annotations
+
+import os
+import threading
+import time
+from pathlib import Path
+from typing import Any, Optional
+
+
+def _emit_fs_change(project_root: Path, file_path: Path, event_kind: str) -> None:
+    """Append a fs_change event to the project's event log.
+
+    Uses the GCCRepository._append_event helper so the hash chain and
+    optional signing remain intact.
+    """
+    from devtorch_core import GCCRepository
+
+    repo = GCCRepository.at(project_root)
+    if not repo.is_initialized():
+        return
+
+    mtime: Optional[float] = None
+    try:
+        if file_path.exists():
+            mtime = file_path.stat().st_mtime
+    except Exception:
+        pass
+
+    payload = {
+        "path": str(file_path),
+        "event_kind": event_kind,
+        "mtime": mtime,
+    }
+
+    try:
+        repo._append_event("fs_change", payload)
+    except Exception:
+        # Last-resort fallback: write directly without hash chain.
+        # This should only happen if the repo backend is unavailable.
+        try:
+            import json
+
+            log_path = repo.gcc_dir / "events.log.jsonl"
+            entry = {
+                "timestamp": _now_iso(),
+                "actor": "devtorch-daemon",
+                "event_type": "fs_change",
+                "payload": payload,
+            }
+            with log_path.open("a", encoding="utf-8") as f:
+                f.write(json.dumps(entry) + "\n")
+        except Exception:
+            pass
+
+
+def _now_iso() -> str:
+    import datetime as dt
+    return dt.datetime.now(tz=dt.timezone.utc).isoformat()
+
+
+def _is_inside_gcc(path: Path, gcc_dir: Path) -> bool:
+    """Return True if path is inside or equal to the .GCC directory."""
+    try:
+        return str(path.resolve()).startswith(str(gcc_dir.resolve()))
+    except Exception:
+        return False
+
+
+# ---------------------------------------------------------------------------
+# watchdog-based implementation
+# ---------------------------------------------------------------------------
+
+try:
+    from watchdog.events import FileSystemEventHandler  # type: ignore
+    from watchdog.observers import Observer  # type: ignore
+
+    _HAS_WATCHDOG = True
+
+    class _WatchdogHandler(FileSystemEventHandler):  # type: ignore[misc]
+        def __init__(self, watcher: "ProjectWatcher") -> None:
+            self._watcher = watcher
+
+        def on_created(self, event: Any) -> None:
+            self._watcher._emit(Path(event.src_path), "created")  # noqa: SLF001
+
+        def on_modified(self, event: Any) -> None:
+            self._watcher._emit(Path(event.src_path), "modified")  # noqa: SLF001
+
+        def on_deleted(self, event: Any) -> None:
+            self._watcher._emit(Path(event.src_path), "deleted")  # noqa: SLF001
+
+except Exception:  # pragma: no cover
+    _HAS_WATCHDOG = False
+    Observer: Any = None  # type: ignore[no-redef]
+    FileSystemEventHandler: Any = None  # type: ignore[no-redef]
+
+
+# ---------------------------------------------------------------------------
+# polling-based implementation
+# ---------------------------------------------------------------------------
+
+
+class _PollingWatcher:
+    def __init__(self, project_root: Path, gcc_dir: Path, emit: Any, interval: float) -> None:
+        self.project_root = project_root
+        self.gcc_dir = gcc_dir
+        self.emit = emit
+        self.interval = interval
+        self._stop_event = threading.Event()
+        self._thread: Optional[threading.Thread] = None
+
+    def _build_snapshot(self) -> dict[str, float]:
+        snap: dict[str, float] = {}
+        for root, dirs, files in os.walk(self.project_root):
+            root_path = Path(root)
+            if _is_inside_gcc(root_path, self.gcc_dir):
+                dirs[:] = []
+                continue
+            for name in files:
+                p = root_path / name
+                if _is_inside_gcc(p, self.gcc_dir):
+                    continue
+                try:
+                    snap[str(p.resolve())] = p.stat().st_mtime
+                except Exception:
+                    pass
+        return snap
+
+    def _detect_changes(self, old: dict[str, float], new: dict[str, float]) -> None:
+        for p, mtime in new.items():
+            if p not in old:
+                self.emit(Path(p), "created")
+            elif old[p] != mtime:
+                self.emit(Path(p), "modified")
+        for p in old:
+            if p not in new:
+                self.emit(Path(p), "deleted")
+
+    def _run(self) -> None:
+        snapshot = self._build_snapshot()
+        while not self._stop_event.is_set():
+            self._stop_event.wait(self.interval)
+            if self._stop_event.is_set():
+                break
+            new_snapshot = self._build_snapshot()
+            self._detect_changes(snapshot, new_snapshot)
+            snapshot = new_snapshot
+
+    def start(self) -> None:
+        self._stop_event.clear()
+        self._thread = threading.Thread(target=self._run, daemon=True)
+        self._thread.start()
+
+    def stop(self) -> None:
+        self._stop_event.set()
+        if self._thread is not None:
+            self._thread.join(timeout=2.0)
+            self._thread = None
+
+
+# ---------------------------------------------------------------------------
+# public watcher
+# ---------------------------------------------------------------------------
+
+
+class ProjectWatcher:
+    """Watch a project root for file changes and emit `fs_change` events."""
+
+    def __init__(self, project_root: Path, poll_interval: float = 1.0, use_watchdog: bool = True) -> None:
+        self.project_root = Path(project_root).resolve()
+        self.gcc_dir = self.project_root / ".GCC"
+        self.poll_interval = poll_interval
+        self.use_watchdog = use_watchdog
+        self._observer: Optional[Any] = None
+        self._polling: Optional[_PollingWatcher] = None
+
+    def _is_gcc_path(self, path: Path) -> bool:
+        return _is_inside_gcc(path, self.gcc_dir)
+
+    def _emit(self, path: Path, event_kind: str) -> None:
+        if self._is_gcc_path(path):
+            return
+        _emit_fs_change(self.project_root, path, event_kind)
+
+    def _start_watchdog(self) -> bool:
+        if not self.use_watchdog or not _HAS_WATCHDOG:
+            return False
+        observer = Observer()
+        handler = _WatchdogHandler(self)
+        observer.schedule(handler, str(self.project_root), recursive=True)
+        observer.start()
+        self._observer = observer
+        return True
+
+    def _start_polling(self) -> None:
+        polling = _PollingWatcher(
+            self.project_root,
+            self.gcc_dir,
+            self._emit,
+            self.poll_interval,
+        )
+        polling.start()
+        self._polling = polling
+
+    def start(self) -> None:
+        """Start watching the project root.
+
+        Tries to use watchdog if installed; otherwise falls back to polling.
+        """
+        if not self._start_watchdog():
+            self._start_polling()
+
+    def stop(self) -> None:
+        """Stop watching the project root."""
+        if self._observer is not None:
+            try:
+                self._observer.stop()
+                self._observer.join(timeout=2.0)
+            except Exception:
+                pass
+            self._observer = None
+        if self._polling is not None:
+            self._polling.stop()
+            self._polling = None
+
+    def is_alive(self) -> bool:
+        """Return True if the watcher is still running."""
+        if self._observer is not None:
+            try:
+                return self._observer.is_alive()
+            except Exception:
+                return False
+        if self._polling is not None:
+            return self._polling._thread is not None and self._polling._thread.is_alive()
+        return False