superlocalmemory 4.1.13 → 4.1.14

package/src/superlocalmemory/core/platform_utils.py

@@ -1,138 +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
-
-"""Cross-platform utilities for subprocess management and resource monitoring.
-
-V3.4.24: Consolidates Windows/POSIX branching from 10+ files into one module.
-Replaces the Unix-only ``resource`` module with ``psutil`` on Windows.
-Inspired by community PR #14 (GuillaumeG / Tyrin451).
-"""
-
-from __future__ import annotations
-
-import os
-import subprocess
-import sys
-import threading
-
-
-def popen_platform_kwargs() -> dict:
-    """Platform-appropriate kwargs for subprocess.Popen.
-
-    POSIX: ``start_new_session=True`` — prevents terminal signals bleeding.
-    Windows: ``CREATE_NO_WINDOW`` — prevents console window popup.
-    """
-    if sys.platform == "win32":
-        # CREATE_NO_WINDOW = 0x08000000 — only defined on Windows.
-        flag = getattr(subprocess, "CREATE_NO_WINDOW", 0x08000000)
-        return {"creationflags": flag}
-    return {"start_new_session": True}
-
-
-def get_rss_mb() -> float:
-    """Current process RSS in megabytes.
-
-    POSIX: ``resource.getrusage`` (stdlib). Windows: ``psutil``.
-    Returns 0.0 if measurement is unavailable.
-    """
-    if sys.platform != "win32":
-        try:
-            import resource
-            ru_maxrss = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
-            if sys.platform == "darwin":
-                return ru_maxrss / 1024 / 1024  # macOS: bytes
-            return ru_maxrss / 1024  # Linux: kilobytes
-        except Exception:
-            return 0.0
-    try:
-        import psutil
-        return psutil.Process().memory_info().rss / 1024 / 1024
-    except Exception:
-        return 0.0
-
-
-def is_pid_alive(pid: int) -> bool:
-    """Check whether a process with *pid* is alive.
-
-    POSIX: ``os.kill(pid, 0)`` — signal 0 checks existence.
-    Windows: ``psutil.pid_exists()`` with ``os.kill`` fallback.
-    """
-    if pid <= 0:
-        return False
-    if sys.platform != "win32":
-        try:
-            os.kill(pid, 0)
-            return True
-        except ProcessLookupError:
-            return False  # ESRCH — no such process
-        except PermissionError:
-            return True   # EPERM — process EXISTS, we just can't signal it
-        except OSError:
-            return False
-    try:
-        import psutil
-        return psutil.pid_exists(pid)
-    except ImportError:
-        try:
-            os.kill(pid, 0)
-            return True
-        except ProcessLookupError:
-            return False  # ESRCH — no such process
-        except PermissionError:
-            return True   # EPERM — process EXISTS, we just can't signal it
-        except OSError:
-            return False
-
-
-def kill_process(pid: int) -> bool:
-    """Send SIGTERM (POSIX) or taskkill /F /T (Windows).
-
-    Returns True if the signal was sent successfully.
-    """
-    if pid <= 0:
-        return False
-    if sys.platform == "win32":
-        try:
-            subprocess.call(
-                ["taskkill", "/F", "/T", "/PID", str(pid)],
-                stdout=subprocess.DEVNULL,
-                stderr=subprocess.DEVNULL,
-            )
-            return True
-        except Exception:
-            return False
-    try:
-        import signal
-        os.kill(pid, signal.SIGTERM)
-        return True
-    except OSError:
-        return False
-
-
-def start_parent_watchdog(
-    *, stop_event: threading.Event | None = None,
-) -> threading.Thread | None:
-    """Self-terminate when the parent process dies.
-
-    Prevents orphaned workers (500+ MB each) after parent crash/kill.
-    V3.3.7 origin: 33 GB consumed by orphaned workers.
-    V3.4.24: Consolidated from 3 separate worker files.
-    """
-    try:
-        parent_pid = os.getppid()
-    except AttributeError:
-        return
-    if parent_pid <= 1:
-        return
-
-    stop = stop_event or threading.Event()
-
-    def _watch() -> None:
-        while not stop.wait(5):
-            if not is_pid_alive(parent_pid):
-                os._exit(0)
-
-    t = threading.Thread(target=_watch, daemon=True, name="parent-watchdog")
-    t.start()
-    return t

package/src/superlocalmemory/core/profiles.py

@@ -1,234 +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
-
-"""SuperLocalMemory V3 — Profile Management.
-
-First-class profile isolation. Every memory, fact, entity, and learning
-record is scoped by profile_id. Profiles are persisted in profiles.json
-with atomic writes and instant switching (config-only, zero data movement).
-
-Ported from V2.8 columnar profile isolation pattern.
-
-Part of Qualixar | Author: Varun Pratap Bhardwaj
-"""
-
-from __future__ import annotations
-
-import json
-import logging
-import os
-import re
-import tempfile
-import uuid
-from dataclasses import asdict
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Any, Callable
-
-from superlocalmemory.core.config import DEFAULT_PROFILES_FILE
-from superlocalmemory.storage.models import Mode, Profile
-
-logger = logging.getLogger(__name__)
-
-_VALID_NAME_RE = re.compile(r"^[a-zA-Z0-9][a-zA-Z0-9_-]{0,49}$")
-_MAX_NAME_LEN = 50
-_RESERVED = "default"
-
-
-def _validate_name(name: str) -> None:
-    """Alphanumeric + dash + underscore, 1-50 chars, starts alphanumeric."""
-    if not name or len(name) > _MAX_NAME_LEN:
-        raise ValueError(f"Profile name must be 1-{_MAX_NAME_LEN} chars, got {len(name)}.")
-    if not _VALID_NAME_RE.match(name):
-        raise ValueError(
-            f"Invalid profile name '{name}'. "
-            "Must start with alphanumeric, then alphanumeric / dash / underscore."
-        )
-
-
-def _now() -> str:
-    return datetime.now(timezone.utc).isoformat()
-
-
-def _pid() -> str:
-    return uuid.uuid4().hex[:16]
-
-
-def _evolve(prof: Profile, **overrides: Any) -> Profile:
-    """Return a new Profile with selected fields replaced (frozen dataclass)."""
-    base = asdict(prof)
-    base.update(overrides)
-    base["mode"] = Mode(base["mode"]) if isinstance(base["mode"], str) else base["mode"]
-    return Profile(**base)
-
-
-class ProfileManager:
-    """Thread-safe profile manager with atomic JSON persistence.
-
-    Stores profile metadata in ``profiles.json`` inside *base_dir*.
-    Profiles are isolated at the DB column level (WHERE profile_id = ?).
-    Switching is instant — only the active pointer changes.
-    """
-
-    def __init__(self, base_dir: Path) -> None:
-        self._base_dir = base_dir
-        self._base_dir.mkdir(parents=True, exist_ok=True)
-        self._path = self._base_dir / DEFAULT_PROFILES_FILE
-        self._profiles: dict[str, Profile] = {}
-        self._active_name: str = _RESERVED
-        self._on_switch: Callable[[Profile], None] | None = None
-        self._load()
-
-    # -- Persistence (atomic write via tempfile + rename) ------------------
-
-    def _load(self) -> None:
-        """Load profiles.json or bootstrap with the default profile."""
-        if self._path.exists():
-            raw = json.loads(self._path.read_text(encoding="utf-8"))
-            self._active_name = raw.get("active", _RESERVED)
-            for entry in raw.get("profiles", []):
-                mode = Mode(entry["mode"]) if "mode" in entry else Mode.A
-                prof = Profile(
-                    profile_id=entry["profile_id"],
-                    name=entry["name"],
-                    description=entry.get("description", ""),
-                    personality=entry.get("personality", ""),
-                    mode=mode,
-                    created_at=entry.get("created_at", _now()),
-                    last_used=entry.get("last_used"),
-                    config=entry.get("config", {}),
-                )
-                self._profiles[prof.name] = prof
-        if _RESERVED not in self._profiles:
-            self._profiles[_RESERVED] = Profile(
-                profile_id=_pid(), name=_RESERVED,
-                description="Default memory profile", mode=Mode.A,
-                created_at=_now(),
-            )
-            self._save()
-
-    def _save(self) -> None:
-        """Atomic write: temp file in same dir, then rename."""
-        data = json.dumps(
-            {"active": self._active_name,
-             "profiles": [asdict(p) for p in self._profiles.values()]},
-            indent=2, ensure_ascii=False,
-        )
-        fd, tmp = tempfile.mkstemp(dir=str(self._base_dir), suffix=".tmp")
-        try:
-            Path(tmp).write_text(data, encoding="utf-8")
-            Path(tmp).replace(self._path)
-        finally:
-            try:
-                os.close(fd)
-            except OSError:
-                pass
-
-    # -- Event hook --------------------------------------------------------
-
-    @property
-    def on_profile_switch(self) -> Callable[[Profile], None] | None:
-        return self._on_switch
-
-    @on_profile_switch.setter
-    def on_profile_switch(self, cb: Callable[[Profile], None] | None) -> None:
-        self._on_switch = cb
-
-    # -- CRUD --------------------------------------------------------------
-
-    def create_profile(
-        self,
-        name: str,
-        description: str = "",
-        personality: str = "",
-        mode: Mode = Mode.A,
-        config: dict[str, Any] | None = None,
-    ) -> Profile:
-        """Create a new profile. Raises ValueError on duplicate or bad name."""
-        _validate_name(name)
-        if name in self._profiles:
-            raise ValueError(f"Profile '{name}' already exists.")
-        profile = Profile(
-            profile_id=_pid(), name=name, description=description,
-            personality=personality, mode=mode,
-            created_at=_now(), config=config or {},
-        )
-        self._profiles[name] = profile
-        self._save()
-        logger.info("Created profile '%s' (id=%s, mode=%s)", name, profile.profile_id, mode.value)
-        return profile
-
-    def get_profile(self, name: str) -> Profile | None:
-        """Return profile by name, or None if not found."""
-        return self._profiles.get(name)
-
-    def get_active_profile(self) -> Profile:
-        """Return the currently active profile."""
-        return self._profiles.get(self._active_name) or self._profiles[_RESERVED]
-
-    def switch_profile(self, name: str) -> Profile:
-        """Instant switch — config-only, zero data movement."""
-        if name not in self._profiles:
-            raise KeyError(f"Profile '{name}' does not exist.")
-        self._active_name = name
-        updated = _evolve(self._profiles[name], last_used=_now())
-        self._profiles[name] = updated
-        self._save()
-        logger.info("Switched to profile '%s'", name)
-        if self._on_switch is not None:
-            self._on_switch(updated)
-        return updated
-
-    def list_profiles(self) -> list[Profile]:
-        """All profiles sorted by name (default first)."""
-        profs = list(self._profiles.values())
-        profs.sort(key=lambda p: (p.name != _RESERVED, p.name))
-        return profs
-
-    def delete_profile(self, name: str) -> None:
-        """Delete a profile. Cannot delete 'default'. Data stays in DB."""
-        if name == _RESERVED:
-            raise ValueError("Cannot delete the default profile.")
-        if name not in self._profiles:
-            raise KeyError(f"Profile '{name}' does not exist.")
-        del self._profiles[name]
-        if self._active_name == name:
-            self._active_name = _RESERVED
-            logger.info("Active profile deleted — fell back to 'default'.")
-        self._save()
-        logger.info("Deleted profile '%s'. Associated data remains in DB.", name)
-
-    def rename_profile(self, old_name: str, new_name: str) -> None:
-        """Rename a profile. Cannot rename 'default'."""
-        if old_name == _RESERVED:
-            raise ValueError("Cannot rename the default profile.")
-        _validate_name(new_name)
-        if old_name not in self._profiles:
-            raise KeyError(f"Profile '{old_name}' does not exist.")
-        if new_name in self._profiles:
-            raise ValueError(f"Profile '{new_name}' already exists.")
-        old = self._profiles.pop(old_name)
-        self._profiles[new_name] = _evolve(old, name=new_name)
-        if self._active_name == old_name:
-            self._active_name = new_name
-        self._save()
-        logger.info("Renamed profile '%s' -> '%s'", old_name, new_name)
-
-    def update_profile(self, name: str, **kwargs: Any) -> Profile:
-        """Update mutable fields: description, personality, mode, config."""
-        if name not in self._profiles:
-            raise KeyError(f"Profile '{name}' does not exist.")
-        allowed = {"description", "personality", "mode", "config"}
-        overrides = {k: v for k, v in kwargs.items() if k in allowed}
-        updated = _evolve(self._profiles[name], **overrides)
-        self._profiles[name] = updated
-        self._save()
-        logger.info("Updated profile '%s'", name)
-        return updated
-
-    def export_profile(self, name: str) -> dict[str, Any]:
-        """Export profile metadata as a plain dict (for backup / migration)."""
-        if name not in self._profiles:
-            raise KeyError(f"Profile '{name}' does not exist.")
-        return asdict(self._profiles[name])

package/src/superlocalmemory/core/progressive_abstraction.py

@@ -1,208 +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
-
-"""Progressive abstraction (Wave Q3) — the top persona tier + drill-down.
-
-Completes the abstraction hierarchy on the ONE principled backbone (rather
-than a fourth divergent clustering):
-
-    atoms (atomic_facts)
-      -> entity communities        (Wave Q backbone)
-        -> community summaries      (Wave Q2)
-          -> persona roll-up        (this module)
-
-The persona is one bounded roll-up per profile that consumes the top community
-summaries. It is recall-GATED (never auto-injected into the hot recall path —
-avoids the V3.4.40 summary-pollution regression) and SIZE-bounded. Drill-down
-(``get_sources``) walks the hierarchy back down to the source atoms, matching
-the design goal for summary->source provenance (Zep-style attribution).
-
-Runs in the background consolidation lane after community summaries.
-Fail-open throughout; recompute replaces a profile's row.
-
-Part of Qualixar | Author: Varun Pratap Bhardwaj
-License: AGPL-3.0-or-later
-"""
-
-from __future__ import annotations
-
-import json
-import logging
-from typing import Any
-
-from superlocalmemory.core.community_summary import CommunitySummaryBuilder
-
-logger = logging.getLogger(__name__)
-
-_PERSONA_MAX_CHARS = 2048
-
-
-class ProgressiveAbstraction:
-    """Build + persist the persona tier; provide hierarchy drill-down."""
-
-    def __init__(
-        self,
-        db: Any,
-        summarizer: Any = None,
-        max_communities_in_persona: int = 8,
-        persona_max_chars: int = _PERSONA_MAX_CHARS,
-        max_keywords: int = 12,
-    ) -> None:
-        self._db = db
-        self._summarizer = summarizer
-        self._max_communities = max(1, int(max_communities_in_persona))
-        self._persona_max_chars = max(256, int(persona_max_chars))
-        self._max_keywords = max(1, int(max_keywords))
-
-    # ------------------------------------------------------------------
-    # Build
-    # ------------------------------------------------------------------
-
-    def compute_and_store(self, profile_id: str) -> dict[str, Any]:
-        summaries = CommunitySummaryBuilder(self._db).get_summaries(profile_id)
-        try:
-            self._db.execute(
-                "DELETE FROM persona_summary WHERE profile_id = ?",
-                (profile_id,),
-            )
-        except Exception as exc:
-            logger.debug("persona_summary clear failed: %s", exc)
-        if not summaries:
-            return {"built": False, "communities_in_persona": 0}
-
-        top = summaries[: self._max_communities]
-        summary = self._persona_summary(top)
-        keywords = self._merge_keywords(top)
-        community_ids = [int(s["community_id"]) for s in top]
-
-        try:
-            self._db.execute(
-                "INSERT OR REPLACE INTO persona_summary "
-                "(profile_id, summary, keywords, community_ids_json, computed_at) "
-                "VALUES (?, ?, ?, ?, datetime('now'))",
-                (profile_id, summary, keywords, json.dumps(community_ids)),
-            )
-        except Exception as exc:
-            logger.debug("persona_summary write failed: %s", exc)
-            return {"built": False, "communities_in_persona": 0}
-
-        return {"built": True, "communities_in_persona": len(top)}
-
-    # ------------------------------------------------------------------
-    # Read API
-    # ------------------------------------------------------------------
-
-    def get_persona(self, profile_id: str) -> dict | None:
-        try:
-            rows = self._db.execute(
-                "SELECT * FROM persona_summary WHERE profile_id = ?",
-                (profile_id,),
-            )
-        except Exception as exc:
-            logger.debug("get_persona failed: %s", exc)
-            return None
-        if not rows:
-            return None
-        d = dict(rows[0])
-        try:
-            community_ids = json.loads(d.get("community_ids_json") or "[]")
-        except (ValueError, TypeError):
-            community_ids = []
-        return {
-            "profile_id": d.get("profile_id", profile_id),
-            "summary": d.get("summary", ""),
-            "keywords": d.get("keywords", ""),
-            "community_ids": community_ids,
-            "computed_at": d.get("computed_at", ""),
-        }
-
-    def get_sources(self, profile_id: str, node_id: Any) -> dict:
-        """Drill-down: a tier node -> its child communities + source atoms.
-
-        node_id == "persona"  -> the persona's member communities + their facts.
-        node_id == <community> -> that community's member facts.
-        Unknown node -> empty (never raises).
-        """
-        result: dict[str, Any] = {
-            "node_id": node_id, "node_type": "unknown",
-            "communities": [], "fact_ids": [],
-        }
-        try:
-            if isinstance(node_id, str) and node_id.lower() == "persona":
-                persona = self.get_persona(profile_id)
-                cids = persona["community_ids"] if persona else []
-                fact_ids: list[str] = []
-                seen: set[str] = set()
-                for cid in cids:
-                    for fid in self._community_fact_ids(profile_id, cid):
-                        if fid not in seen:
-                            seen.add(fid)
-                            fact_ids.append(fid)
-                result.update(
-                    node_type="persona", communities=list(cids), fact_ids=fact_ids,
-                )
-                return result
-
-            # Otherwise treat node_id as a community id.
-            cid = int(node_id)
-            fids = self._community_fact_ids(profile_id, cid)
-            result.update(
-                node_type="community", communities=[cid], fact_ids=fids,
-            )
-            return result
-        except (ValueError, TypeError):
-            return result
-        except Exception as exc:
-            logger.debug("get_sources failed: %s", exc)
-            return result
-
-    # ------------------------------------------------------------------
-    # Internal
-    # ------------------------------------------------------------------
-
-    def _community_fact_ids(self, profile_id: str, community_id: Any) -> list[str]:
-        try:
-            rows = self._db.execute(
-                "SELECT fact_ids_json FROM community_summaries "
-                "WHERE profile_id = ? AND community_id = ?",
-                (profile_id, int(community_id)),
-            )
-        except Exception as exc:
-            logger.debug("_community_fact_ids failed: %s", exc)
-            return []
-        if not rows:
-            return []
-        try:
-            return [str(f) for f in json.loads(dict(rows[0]).get("fact_ids_json") or "[]")]
-        except (ValueError, TypeError):
-            return []
-
-    def _persona_summary(self, top: list[dict]) -> str:
-        if self._summarizer is not None:
-            try:
-                text = self._summarizer.summarize_cluster(
-                    [{"content": s.get("summary", "")} for s in top],
-                )
-                if text and text.strip():
-                    return text.strip()[: self._persona_max_chars]
-            except Exception as exc:
-                logger.debug("persona summarizer failed (fail-open): %s", exc)
-        # Mode A keyword-dense fallback: stitch the top community summaries.
-        heads = [s.get("summary", "").strip() for s in top if s.get("summary")]
-        base = " ".join(heads) if heads else "No persona yet."
-        return base[: self._persona_max_chars]
-
-    def _merge_keywords(self, top: list[dict]) -> str:
-        seen: set[str] = set()
-        merged: list[str] = []
-        for s in top:
-            for kw in (s.get("keywords", "") or "").split(","):
-                k = kw.strip()
-                low = k.lower()
-                if k and low not in seen:
-                    seen.add(low)
-                    merged.append(k)
-                    if len(merged) >= self._max_keywords:
-                        return ", ".join(merged)
-        return ", ".join(merged)