superlocalmemory 4.1.13 → 4.1.14

package/src/superlocalmemory/mcp/profiles.py

@@ -1,154 +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
-
-"""MCP profile definitions — pure data, no side effects.
-
-Extracted from mcp/server.py (v3.8.0) so the daemon can import profile
-metadata without triggering FastMCP tool registration or engine warmup.
-
-server.py re-exports all names from this module for backward compatibility.
-Do NOT import FastMCP, MemoryEngine, or any heavy dependency here.
-"""
-
-from __future__ import annotations
-
-# ---------------------------------------------------------------------------
-# Named profile definitions (introduced in v3.6.14)
-# ---------------------------------------------------------------------------
-
-_PROFILE_CORE: frozenset[str] = frozenset({  # 18
-    "remember", "recall", "search", "fetch", "list_recent", "update_memory", "forget",
-    "session_init", "close_session",
-    "slm_compress", "slm_retrieve", "slm_cache_set", "slm_cache_get", "slm_optimize_stats",
-    # A client that can propose a correction must be able to inspect and
-    # authenticate its review; otherwise the core lifecycle is incomplete.
-    "review_correction", "list_corrections",
-    # v4.0.8: the readable summary layer (issue #113). In CORE because the
-    # natural caller is the agent holding the conversation — an assistant
-    # asked "what did I work on yesterday" should not need a power profile.
-    "get_memory_summary",
-    # v4.1.0: every memory operation is scoped to a profile, so a surface that
-    # can read or write memory must also be able to say which profile it means.
-    # Without this, the smallest profile can store and recall but can never
-    # leave the profile it happened to start in, and a second workspace is
-    # unreachable from the surface most hosts ship. The route stays RBAC
-    # member-gated, so company-mode isolation is unaffected.
-    "switch_profile",
-})
-
-# Portable Brain evidence must reach the coding-host profile shipped by the
-# Claude/Codex plugins, not only an unrestricted server.
-_PROFILE_BRAIN: frozenset[str] = frozenset({
-    "get_brain_evidence_status", "record_agent_experience",
-    "record_cognitive_turn", "finalize_cognitive_turn",
-    "observe_bounded_loop_evidence",
-})
-
-_PROFILE_CODE: frozenset[str] = _PROFILE_CORE | _PROFILE_BRAIN | frozenset({  # 32
-    "build_code_graph", "get_blast_radius", "query_graph",
-    "semantic_search_code", "get_review_context", "detect_changes",
-    # switch_profile lets a plugin/IDE session change the active workspace over
-    # MCP (the plugin ships SLM_MCP_PROFILE=code, so it must be here). The
-    # underlying route is RBAC member-gated, so company-mode isolation holds.
-    "switch_profile",
-    # v3.8.0: bounded loops on the MCP surface. Coding agents (the /slm-loop
-    # command's audience) run gated, bounded loops and inspect the ledger.
-    "slm_loop_run", "slm_loop_history", "slm_loop_show",
-    # Retrieval ranks a memory partly on whether it has actually helped, and
-    # the only evidence of that comes from the assistant that used it. The
-    # plugin ships SLM_MCP_PROFILE=code, so without these two the ranker has
-    # no input at all for the audience it exists to serve.
-    "report_outcome", "report_feedback",
-})
-
-_PROFILE_FULL_MESH: frozenset[str] = frozenset({  # 8
-    "mesh_summary", "mesh_peers", "mesh_send", "mesh_inbox",
-    "mesh_state", "mesh_lock", "mesh_events", "mesh_status",
-})
-
-# 41 base — explicit literal, not runtime _ESSENTIAL_TOOLS (OQ-2).
-_PROFILE_FULL: frozenset[str] = frozenset({
-    "remember", "recall", "search", "fetch", "list_recent", "delete_memory", "update_memory",
-    "get_status", "session_init", "observe", "close_session", "report_feedback", "forget",
-    "run_maintenance", "consolidate_cognitive", "get_soft_prompts", "set_mode", "report_outcome",
-    "log_tool_event", "get_assertions", "reinforce_assertion", "contradict_assertion",
-    "get_brain_evidence_status", "record_agent_experience",
-    "record_cognitive_turn", "finalize_cognitive_turn",
-    "observe_bounded_loop_evidence", "review_correction", "list_corrections",
-    "evolve_skill", "skill_health", "skill_lineage", "switch_profile",
-    "slm_compress", "slm_retrieve", "slm_cache_set", "slm_cache_get", "slm_optimize_stats",
-    # v3.8.0: bounded-loop tools (CLI + /slm-loop command + MCP).
-    "slm_loop_run", "slm_loop_history", "slm_loop_show",
-    # v4.0.8: readable summaries (#113). In core, so it must be in full too —
-    # full is asserted to be a superset of core.
-    "get_memory_summary",
-    # prestage_context remains registered but deliberately raw-server-only.
-}) | _PROFILE_FULL_MESH  # 50
-
-_PROFILE_POWER: frozenset[str] = _PROFILE_FULL | frozenset({  # 62
-    "get_version", "get_mode", "health", "consistency_check", "recall_trace",
-    "get_lifecycle_status", "set_retention_policy", "compact_memories",
-    "get_behavioral_patterns", "audit_trail", "quantize", "get_retention_stats",
-})
-
-_PROFILE_MESH: frozenset[str] = _PROFILE_FULL_MESH  # 8
-
-# Canonical name → frozenset mapping.  "whole" is intentionally absent —
-# it maps to the raw server (all tools, D-2 LOCKED).
-_PROFILE_DEFINITIONS: dict[str, frozenset[str]] = {
-    "core": _PROFILE_CORE,
-    "code": _PROFILE_CODE,
-    "full": _PROFILE_FULL,
-    "power": _PROFILE_POWER,
-    "mesh": _PROFILE_MESH,
-}
-
-# Compatibility aliases published by the v3.6 README.  Stale client
-# configurations have one deterministic meaning; migration warnings fire
-# at server startup.  Any other value is a configuration error (fail closed).
-_PROFILE_ALIASES: dict[str, str] = {
-    "core14": "core",
-    "core16": "core",
-    # 3.8.0 and later additions grew code/full/power; every historical count
-    # power. Every historical count-suffixed name is kept so a v3.6/3.7/early-
-    # 3.8 config still resolves (back-compat); new 3.8.0 counts added alongside.
-    "code20": "code",
-    "code21": "code",
-    "code24": "code",
-    "code28": "code",
-    "code29": "code",
-    "code31": "code",
-    "full38": "full",
-    "full39": "full",
-    "full42": "full",
-    "full46": "full",
-    "full47": "full",
-    "full49": "full",
-    "power50": "power",
-    "power51": "power",
-    "power54": "power",
-    "power58": "power",
-    "power59": "power",
-    "power61": "power",
-    "mesh8": "mesh",
-    "whole81": "whole",
-    "whole84": "whole",
-    "whole91": "whole",
-    "whole92": "whole",
-    "whole94": "whole",
-}
-
-# Plain-English descriptions for UI display.
-# Rules: no internal jargon (no POMDP, Fisher-Rao, TurboQuant, etc.),
-# one sentence, user-facing language only.
-PROFILE_DESCRIPTIONS: dict[str, str] = {
-    "core": "Essential memory: store, recall, search, sessions",
-    "code": (
-        "Core + code graph, portable Brain evidence, and profile switching "
-        "(default for IDE coding agents)"
-    ),
-    "full": "All everyday memory, portable Brain evidence, optimization, and mesh tools",
-    "power": "Everything in full plus advanced governance and behavioral tools",
-    "mesh": "Cross-device mesh coordination only",
-}

package/src/superlocalmemory/mcp/resources.py

@@ -1,281 +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 — MCP Resources (6 resources).
-
-slm://recent, slm://stats, slm://clusters, slm://identity,
-slm://learning, slm://engagement.
-
-Part of Qualixar | Author: Varun Pratap Bhardwaj
-"""
-
-from __future__ import annotations
-
-import json
-import logging
-from typing import Callable
-
-logger = logging.getLogger(__name__)
-
-
-def register_resources(server, get_engine: Callable) -> None:
-    """Register 7 MCP resources on *server*."""
-
-    # ------------------------------------------------------------------
-    # 0. slm://context — Active Memory auto-injection
-    # ------------------------------------------------------------------
-    @server.resource("slm://context")
-    async def session_context() -> str:
-        """Active session context — auto-injected on MCP connect.
-
-        Returns the most relevant memories for the current session:
-        recent decisions, active patterns, and project context.
-        AI tools read this automatically on connection to get instant context.
-        """
-        try:
-            from superlocalmemory.hooks.auto_recall import AutoRecall
-            from superlocalmemory.mcp._pool_adapter import pool_recall
-            # Pass engine so the soft-prompt bridge (engine->AutoInvoker) fires on
-            # this real MCP session-context surface; recall_fn still drives recall.
-            # Fail-soft: if the engine is unavailable, recall via pool_recall alone.
-            try:
-                _eng = get_engine()
-            except Exception:
-                _eng = None
-            auto = AutoRecall(
-                recall_fn=pool_recall,
-                engine=_eng,
-                config={"enabled": True, "max_memories_injected": 10, "relevance_threshold": 0.3},
-            )
-            context = auto.get_session_context(query="recent decisions and important context")
-            if not context:
-                return "No session context available yet. Use 'remember' to store memories."
-            return context
-        except Exception as exc:
-            return f"Context unavailable: {exc}"
-
-    # ------------------------------------------------------------------
-    # 1. slm://recent
-    # ------------------------------------------------------------------
-    @server.resource("slm://recent")
-    async def recent_memories() -> str:
-        """Recent memories summary.
-
-        Returns a plain-text summary of the 20 most recent facts
-        stored in the active profile.
-        """
-        try:
-            engine = get_engine()
-            pid = engine.profile_id
-            facts = engine._db.get_all_facts(pid)[:20]
-            if not facts:
-                return "No memories stored yet."
-            lines = [f"Recent memories for profile '{pid}' ({len(facts)} shown):"]
-            for f in facts:
-                preview = f.content[:100].replace("\n", " ")
-                lines.append(
-                    f"  [{f.fact_type.value}] {preview} "
-                    f"(id={f.fact_id}, {f.created_at[:10]})"
-                )
-            return "\n".join(lines)
-        except Exception as exc:
-            return f"Error loading recent memories: {exc}"
-
-    # ------------------------------------------------------------------
-    # 2. slm://stats
-    # ------------------------------------------------------------------
-    @server.resource("slm://stats")
-    async def stats() -> str:
-        """Memory system statistics.
-
-        Returns a text summary of fact counts, entity counts,
-        edge counts, and storage breakdown by type.
-        """
-        try:
-            engine = get_engine()
-            pid = engine.profile_id
-            fact_count = engine._db.get_fact_count(pid)
-
-            entity_rows = engine._db.execute(
-                "SELECT COUNT(*) AS c FROM canonical_entities WHERE profile_id = ?",
-                (pid,),
-            )
-            entity_count = int(dict(entity_rows[0])["c"]) if entity_rows else 0
-
-            edge_rows = engine._db.execute(
-                "SELECT COUNT(*) AS c FROM graph_edges WHERE profile_id = ?",
-                (pid,),
-            )
-            edge_count = int(dict(edge_rows[0])["c"]) if edge_rows else 0
-
-            scene_rows = engine._db.execute(
-                "SELECT COUNT(*) AS c FROM memory_scenes WHERE profile_id = ?",
-                (pid,),
-            )
-            scene_count = int(dict(scene_rows[0])["c"]) if scene_rows else 0
-
-            lines = [
-                f"SuperLocalMemory V3 Statistics (profile: {pid})",
-                f"  Mode: {engine._config.mode.value.upper()}",
-                f"  Facts: {fact_count}",
-                f"  Entities: {entity_count}",
-                f"  Edges: {edge_count}",
-                f"  Scenes: {scene_count}",
-            ]
-            return "\n".join(lines)
-        except Exception as exc:
-            return f"Error loading stats: {exc}"
-
-    # ------------------------------------------------------------------
-    # 3. slm://clusters
-    # ------------------------------------------------------------------
-    @server.resource("slm://clusters")
-    async def clusters() -> str:
-        """Memory scene clusters.
-
-        Returns a summary of memory scenes (topic clusters)
-        with their themes and fact counts.
-        """
-        try:
-            engine = get_engine()
-            pid = engine.profile_id
-            scenes = engine._db.get_all_scenes(pid)
-            if not scenes:
-                return "No memory scenes/clusters formed yet."
-            lines = [f"Memory Scenes ({len(scenes)} clusters):"]
-            for s in scenes[:30]:
-                theme = s.theme[:80] if s.theme else "(no theme)"
-                lines.append(
-                    f"  [{s.scene_id[:8]}] {theme} "
-                    f"({len(s.fact_ids)} facts, {len(s.entity_ids)} entities)"
-                )
-            return "\n".join(lines)
-        except Exception as exc:
-            return f"Error loading clusters: {exc}"
-
-    # ------------------------------------------------------------------
-    # 4. slm://identity
-    # ------------------------------------------------------------------
-    @server.resource("slm://identity")
-    async def coding_identity() -> str:
-        """Active profile identity and coding context.
-
-        Returns profile name, personality description, mode, and
-        top entities with fact counts for context-aware assistance.
-        """
-        try:
-            engine = get_engine()
-            pid = engine.profile_id
-            mode = engine._config.mode.value.upper()
-
-            # Top entities by fact count
-            entity_rows = engine._db.execute(
-                "SELECT canonical_name, fact_count FROM canonical_entities "
-                "WHERE profile_id = ? ORDER BY fact_count DESC LIMIT 10",
-                (pid,),
-            )
-            entities = [
-                f"{dict(r)['canonical_name']} ({dict(r)['fact_count']} facts)"
-                for r in entity_rows
-            ]
-
-            lines = [
-                f"Profile: {pid}",
-                f"Mode: {mode}",
-                f"Top entities: {', '.join(entities) if entities else 'none yet'}",
-            ]
-            return "\n".join(lines)
-        except Exception as exc:
-            return f"Error loading identity: {exc}"
-
-    # ------------------------------------------------------------------
-    # 5. slm://learning
-    # ------------------------------------------------------------------
-    @server.resource("slm://learning")
-    async def learning_status() -> str:
-        """Learning system status.
-
-        Returns adaptive learning health, pattern summary, and
-        outcome tracking statistics.
-        """
-        try:
-            engine = get_engine()
-            pid = engine.profile_id
-
-            # Behavioral patterns summary
-            try:
-                from superlocalmemory.learning.behavioral import BehavioralPatternStore
-                store = BehavioralPatternStore(engine._db.db_path)
-                summary = store.get_summary(pid)
-            except Exception as exc:
-                logger.warning("learning_status behavioral summary failed: %s", exc)
-                summary = {}
-
-            # Outcome stats
-            try:
-                outcome_rows = engine._db.execute(
-                    "SELECT outcome, COUNT(*) AS c FROM action_outcomes "
-                    "WHERE profile_id = ? GROUP BY outcome",
-                    (pid,),
-                )
-                outcomes = {dict(r)["outcome"]: dict(r)["c"] for r in outcome_rows}
-            except Exception as exc:
-                logger.warning("learning_status outcome query failed: %s", exc)
-                outcomes = {}
-
-            lines = [
-                f"Learning Status (profile: {pid})",
-                f"  Behavioral patterns: {json.dumps(summary) if summary else 'none detected'}",
-                f"  Outcome tracking: {json.dumps(outcomes) if outcomes else 'no outcomes recorded'}",
-            ]
-            return "\n".join(lines)
-        except Exception as exc:
-            return f"Error loading learning status: {exc}"
-
-    # ------------------------------------------------------------------
-    # 6. slm://engagement
-    # ------------------------------------------------------------------
-    @server.resource("slm://engagement")
-    async def engagement() -> str:
-        """Engagement metrics.
-
-        Returns memory usage activity: recent stores, recalls,
-        and top-accessed facts.
-        """
-        try:
-            engine = get_engine()
-            pid = engine.profile_id
-
-            # Recent activity via audit trail
-            try:
-                audit_rows = engine._db.execute(
-                    "SELECT action, COUNT(*) AS c FROM compliance_audit "
-                    "WHERE profile_id = ? GROUP BY action",
-                    (pid,),
-                )
-                activity = {dict(r)["action"]: dict(r)["c"] for r in audit_rows}
-            except Exception as exc:
-                logger.warning("engagement audit-trail query failed: %s", exc)
-                activity = {}
-
-            # Top-accessed facts
-            top_rows = engine._db.execute(
-                "SELECT fact_id, content, access_count FROM atomic_facts "
-                "WHERE profile_id = ? AND access_count > 0 "
-                "ORDER BY access_count DESC LIMIT 5",
-                (pid,),
-            )
-            top_facts = [
-                f"{dict(r)['content'][:60]}... (accessed {dict(r)['access_count']}x)"
-                for r in top_rows
-            ]
-
-            lines = [
-                f"Engagement (profile: {pid})",
-                f"  Activity: {json.dumps(activity) if activity else 'no activity'}",
-                f"  Top facts: {'; '.join(top_facts) if top_facts else 'none accessed'}",
-            ]
-            return "\n".join(lines)
-        except Exception as exc:
-            return f"Error loading engagement: {exc}"