superlocalmemory 4.1.13 → 4.1.14

package/src/superlocalmemory/code_graph/watcher.py

@@ -1,207 +0,0 @@
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later - see LICENSE file
-# Part of SuperLocalMemory v3.4 — CodeGraph Module
-
-"""CodeGraphWatcher — file system watcher with debounce.
-
-Wraps watchdog Observer in a daemon thread. 300ms debounce coalesces
-rapid file changes. Only reacts to supported source extensions.
-Ignored directories (node_modules, .git, __pycache__, etc.) are skipped.
-"""
-
-from __future__ import annotations
-
-import logging
-import os
-import threading
-import time
-from pathlib import Path
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from superlocalmemory.code_graph.service import CodeGraphService
-
-logger = logging.getLogger(__name__)
-
-# ---------------------------------------------------------------------------
-# Constants
-# ---------------------------------------------------------------------------
-
-SUPPORTED_EXTENSIONS: frozenset[str] = frozenset({
-    ".py", ".ts", ".tsx", ".js", ".jsx",
-})
-
-IGNORED_DIRS: frozenset[str] = frozenset({
-    "node_modules", ".git", "__pycache__", ".venv", "venv",
-    "dist", "build", ".tox", ".mypy_cache", ".pytest_cache",
-    "coverage", ".next", ".nuxt", ".eggs", "egg-info",
-})
-
-DEBOUNCE_SECONDS: float = 0.3
-
-
-# ---------------------------------------------------------------------------
-# Event handler
-# ---------------------------------------------------------------------------
-
-class _DebouncedHandler:
-    """File system event handler with debounce logic.
-
-    Accumulates changed file paths and flushes them after DEBOUNCE_SECONDS
-    of inactivity. Uses a threading.Timer for the debounce.
-    """
-
-    def __init__(self, repo_root: str, callback) -> None:
-        self._repo_root = repo_root
-        self._callback = callback
-        self._pending: dict[str, float] = {}
-        self._timer: threading.Timer | None = None
-        self._lock = threading.Lock()
-
-    def on_event(self, src_path: str, is_delete: bool = False) -> None:
-        """Handle a file system event."""
-        # Filter by extension
-        ext = os.path.splitext(src_path)[1]
-        if ext not in SUPPORTED_EXTENSIONS:
-            return
-
-        # Filter by ignored directories
-        parts = Path(src_path).parts
-        for part in parts:
-            if part in IGNORED_DIRS:
-                return
-
-        with self._lock:
-            if is_delete:
-                # Deletions are immediate
-                self._flush_immediate([src_path])
-                return
-
-            self._pending[src_path] = time.time()
-            if self._timer is not None:
-                self._timer.cancel()
-            self._timer = threading.Timer(DEBOUNCE_SECONDS, self._flush)
-            self._timer.daemon = True
-            self._timer.start()
-
-    def _flush(self) -> None:
-        """Flush pending changes to the callback."""
-        with self._lock:
-            paths = list(self._pending.keys())
-            self._pending.clear()
-            self._timer = None
-
-        if paths:
-            try:
-                self._callback(paths)
-            except Exception as exc:
-                logger.warning("Watcher callback failed: %s", exc)
-
-    def _flush_immediate(self, paths: list[str]) -> None:
-        """Flush specific paths immediately (for deletions)."""
-        try:
-            self._callback(paths)
-        except Exception as exc:
-            logger.warning("Watcher callback failed: %s", exc)
-
-    def cancel(self) -> None:
-        """Cancel any pending timer."""
-        with self._lock:
-            if self._timer is not None:
-                self._timer.cancel()
-                self._timer = None
-            self._pending.clear()
-
-
-# ---------------------------------------------------------------------------
-# CodeGraphWatcher
-# ---------------------------------------------------------------------------
-
-class CodeGraphWatcher:
-    """Watches a repository for file changes and triggers incremental updates.
-
-    Runs in a daemon thread — never blocks the main thread (HR-6).
-    """
-
-    def __init__(self, repo_root: str, service: CodeGraphService) -> None:
-        self._repo_root = str(repo_root)
-        self._service = service
-        self._observer = None
-        self._handler = None
-        self._running = False
-
-    def start(self) -> None:
-        """Start watching. Non-blocking — spawns a daemon thread."""
-        try:
-            from watchdog.observers import Observer
-            from watchdog.events import FileSystemEventHandler
-        except ImportError:
-            raise ImportError(
-                "watchdog not installed. Install with: pip install superlocalmemory[code-graph]"
-            )
-
-        def _on_changes(paths: list[str]) -> None:
-            """Called by debounced handler with accumulated changes."""
-            try:
-                rel_paths = []
-                root = Path(self._repo_root)
-                for p in paths:
-                    try:
-                        rel = str(Path(p).relative_to(root))
-                        rel_paths.append(rel)
-                    except ValueError:
-                        rel_paths.append(p)
-
-                logger.info(
-                    "Watcher detected %d changed files, updating graph",
-                    len(rel_paths),
-                )
-                # Placeholder: incremental update would go here
-                # The service doesn't have an incremental_update method yet
-                # but this is where it would be called
-            except Exception as exc:
-                logger.warning("Watcher update failed: %s", exc)
-
-        self._handler = _DebouncedHandler(self._repo_root, _on_changes)
-
-        class _WatchdogBridge(FileSystemEventHandler):
-            """Bridge between watchdog events and our debounced handler."""
-
-            def __init__(self, handler: _DebouncedHandler) -> None:
-                self._handler = handler
-
-            def on_modified(self, event):
-                if not event.is_directory:
-                    self._handler.on_event(event.src_path)
-
-            def on_created(self, event):
-                if not event.is_directory:
-                    self._handler.on_event(event.src_path)
-
-            def on_deleted(self, event):
-                if not event.is_directory:
-                    self._handler.on_event(event.src_path, is_delete=True)
-
-        self._observer = Observer()
-        bridge = _WatchdogBridge(self._handler)
-        self._observer.schedule(bridge, self._repo_root, recursive=True)
-        self._observer.daemon = True
-        self._observer.start()
-        self._running = True
-        logger.info("CodeGraphWatcher started for %s", self._repo_root)
-
-    def stop(self) -> None:
-        """Stop watching and clean up."""
-        if self._handler is not None:
-            self._handler.cancel()
-        if self._observer is not None:
-            self._observer.stop()
-            self._observer.join(timeout=5)
-            self._observer = None
-        self._running = False
-        logger.info("CodeGraphWatcher stopped")
-
-    @property
-    def is_running(self) -> bool:
-        """Whether the watcher is currently running."""
-        return self._running

package/src/superlocalmemory/compliance/abac.py

@@ -1,204 +0,0 @@
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later - see LICENSE file
-# Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
-
-"""Attribute-Based Access Control for memory operations.
-
-Evaluates policies: (agent_id, profile_id, action) -> allow/deny.
-Default: allow all (open access). Policies restrict specific agents.
-
-Actions: "read", "write", "delete", "admin".
-Policies are stored in-memory (loaded from DB on init).
-Simple deny-list approach: if a deny policy matches, access is blocked.
-"""
-
-from __future__ import annotations
-
-import logging
-import sqlite3
-from typing import Any, Optional
-
-logger = logging.getLogger(__name__)
-
-# Valid ABAC actions
-VALID_ACTIONS = frozenset({"read", "write", "delete", "admin"})
-
-_POLICY_TABLE_SQL = """
-CREATE TABLE IF NOT EXISTS abac_policies (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    profile_id TEXT NOT NULL,
-    agent_id TEXT NOT NULL,
-    action TEXT NOT NULL,
-    deny INTEGER NOT NULL DEFAULT 1,
-    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-)
-"""
-
-
-class AccessDenied(PermissionError):
-    """Raised when ABAC denies an operation."""
-
-
-class ABACEngine:
-    """Attribute-Based Access Control for memory operations.
-
-    Evaluates policies: (agent_id, profile_id, action) -> allow/deny.
-    Default: allow all (open access). Deny policies restrict specific
-    agent+profile+action combinations.
-    """
-
-    def __init__(self, db: Optional[sqlite3.Connection] = None) -> None:
-        self._policies: list[dict[str, Any]] = []
-        self._db = db
-        if db is not None:
-            self._load_policies_from_db(db)
-
-    # ------------------------------------------------------------------
-    # Policy loading
-    # ------------------------------------------------------------------
-
-    def _load_policies_from_db(self, db: sqlite3.Connection) -> None:
-        """Load policies from the abac_policies table."""
-        try:
-            db.execute(_POLICY_TABLE_SQL)
-            db.commit()
-            rows = db.execute(
-                "SELECT profile_id, agent_id, action, deny "
-                "FROM abac_policies"
-            ).fetchall()
-            for row in rows:
-                self._policies.append({
-                    "profile_id": row[0],
-                    "agent_id": row[1],
-                    "action": row[2],
-                    "deny": bool(row[3]),
-                })
-            logger.info("Loaded %d ABAC policies from DB", len(self._policies))
-        except sqlite3.OperationalError as exc:
-            logger.warning("Failed to load ABAC policies: %s", exc)
-
-    # ------------------------------------------------------------------
-    # Policy management
-    # ------------------------------------------------------------------
-
-    def add_policy(
-        self,
-        profile_id: str,
-        agent_id: str,
-        action: str,
-        deny: bool = True,
-    ) -> None:
-        """Add an access control policy.
-
-        Args:
-            profile_id: Profile this policy applies to.
-            agent_id: Agent this policy applies to.
-            action: The action to control (read/write/delete/admin).
-            deny: If True, this is a deny policy. Default True.
-        """
-        if action not in VALID_ACTIONS:
-            raise ValueError(f"Invalid action '{action}'. Must be one of {VALID_ACTIONS}")
-        policy = {
-            "profile_id": profile_id,
-            "agent_id": agent_id,
-            "action": action,
-            "deny": deny,
-        }
-        self._policies.append(policy)
-        self._persist_policy(policy)
-
-    def remove_policy(
-        self,
-        profile_id: str,
-        agent_id: str,
-        action: str,
-    ) -> None:
-        """Remove a policy matching profile_id + agent_id + action."""
-        self._policies = [
-            p for p in self._policies
-            if not (
-                p["profile_id"] == profile_id
-                and p["agent_id"] == agent_id
-                and p["action"] == action
-            )
-        ]
-        if self._db is not None:
-            try:
-                self._db.execute(
-                    "DELETE FROM abac_policies WHERE profile_id = ? AND agent_id = ? AND action = ?",
-                    (profile_id, agent_id, action),
-                )
-                self._db.commit()
-            except sqlite3.OperationalError:
-                pass
-
-    def _persist_policy(self, policy: dict[str, Any]) -> None:
-        """Write a policy to DB so it survives restart."""
-        if self._db is None:
-            return
-        try:
-            self._db.execute(
-                "INSERT INTO abac_policies (profile_id, agent_id, action, deny) "
-                "VALUES (?, ?, ?, ?)",
-                (policy["profile_id"], policy["agent_id"], policy["action"], int(policy["deny"])),
-            )
-            self._db.commit()
-        except sqlite3.OperationalError as exc:
-            logger.warning("Failed to persist ABAC policy: %s", exc)
-
-    # ------------------------------------------------------------------
-    # Access evaluation
-    # ------------------------------------------------------------------
-
-    def check(self, agent_id: str, profile_id: str, action: str) -> bool:
-        """Evaluate access. Returns True if allowed, False if denied.
-
-        Default: allow if no deny policy matches the request.
-        Deny-first semantics: any matching deny policy blocks access.
-        """
-        for policy in self._policies:
-            if not policy.get("deny", True):
-                continue
-            if (
-                policy["agent_id"] == agent_id
-                and policy["profile_id"] == profile_id
-                and policy["action"] == action
-            ):
-                return False
-        return True
-
-    def check_or_raise(
-        self,
-        agent_id: str,
-        profile_id: str,
-        action: str,
-    ) -> None:
-        """Like check() but raises AccessDenied if denied."""
-        if not self.check(agent_id, profile_id, action):
-            raise AccessDenied(
-                f"Agent '{agent_id}' denied '{action}' "
-                f"on profile '{profile_id}'"
-            )
-
-    # ------------------------------------------------------------------
-    # Policy listing
-    # ------------------------------------------------------------------
-
-    def list_policies(
-        self,
-        profile_id: Optional[str] = None,
-    ) -> list[dict[str, Any]]:
-        """List all policies, optionally filtered by profile.
-
-        Args:
-            profile_id: If provided, only return policies for this profile.
-
-        Returns:
-            List of policy dicts with keys: profile_id, agent_id, action, deny.
-        """
-        if profile_id is None:
-            return [dict(p) for p in self._policies]
-        return [
-            dict(p) for p in self._policies
-            if p["profile_id"] == profile_id
-        ]