superlocalmemory 3.0.37 → 3.1.1

package/src/superlocalmemory/server/routes/memories.py

@@ -46,53 +46,37 @@ def _fetch_graph_data(
 ) -> tuple[list, list, list]:
     """Fetch graph nodes, links, clusters from V3 or V2 schema."""
     if use_v3:
-        # Graph-first: fetch edges, then get connected nodes, then fill slots
+        # Recency-first: get the most recent nodes, then find their edges
         cursor.execute("""
-            SELECT source_id as source, target_id as target,
-                   weight, edge_type as relationship_type
-            FROM graph_edges WHERE profile_id = ?
-            ORDER BY weight DESC
-        """, (profile,))
-        all_links = cursor.fetchall()
+            SELECT fact_id as id, content, fact_type as category,
+                   confidence as importance, session_id as project_name,
+                   created_at
+            FROM atomic_facts
+            WHERE profile_id = ? AND confidence >= ?
+            ORDER BY created_at DESC
+            LIMIT ?
+        """, (profile, min_importance / 10.0, max_nodes))
+        nodes = cursor.fetchall()
 
-        connected_ids = set()
-        for lk in all_links:
-            connected_ids.add(lk['source'])
-            connected_ids.add(lk['target'])
+        node_ids = {n['id'] for n in nodes}
 
-        # Fetch connected nodes first (these have edges to display)
-        connected_nodes: list = []
-        if connected_ids:
-            ph = ','.join('?' * len(connected_ids))
+        # Fetch edges between these nodes
+        if node_ids:
+            ph = ','.join('?' * len(node_ids))
+            id_list = list(node_ids)
             cursor.execute(f"""
-                SELECT fact_id as id, content, fact_type as category,
-                       confidence as importance, session_id as project_name,
-                       created_at
-                FROM atomic_facts
-                WHERE profile_id = ? AND fact_id IN ({ph})
-            """, [profile] + list(connected_ids))
-            connected_nodes = cursor.fetchall()
-
-        # Fill remaining slots with top-confidence unconnected nodes
-        remaining = max_nodes - len(connected_nodes)
-        if remaining > 0:
-            existing = {n['id'] for n in connected_nodes}
-            cursor.execute("""
-                SELECT fact_id as id, content, fact_type as category,
-                       confidence as importance, session_id as project_name,
-                       created_at
-                FROM atomic_facts
-                WHERE profile_id = ? AND confidence >= ?
-                ORDER BY confidence DESC, created_at DESC
-                LIMIT ?
-            """, (profile, min_importance / 10.0, remaining + len(existing)))
-            for n in cursor.fetchall():
-                if n['id'] not in existing:
-                    connected_nodes.append(n)
-                    if len(connected_nodes) >= max_nodes:
-                        break
-
-        nodes = connected_nodes[:max_nodes]
+                SELECT source_id as source, target_id as target,
+                       weight, edge_type as relationship_type
+                FROM graph_edges
+                WHERE profile_id = ?
+                  AND source_id IN ({ph}) AND target_id IN ({ph})
+                ORDER BY weight DESC
+            """, [profile] + id_list + id_list)
+            all_links = cursor.fetchall()
+        else:
+            all_links = []
+
+        links = all_links
         for n in nodes:
             n['entities'] = []
             n['content_preview'] = _preview(n.get('content'))
@@ -101,7 +85,33 @@ def _fetch_graph_data(
         node_ids = {n['id'] for n in nodes}
         links = [lk for lk in all_links
                  if lk['source'] in node_ids and lk['target'] in node_ids]
-        return nodes, links, []
+
+        # Compute clusters from memory_scenes
+        clusters = []
+        try:
+            cursor.execute("""
+                SELECT scene_id, theme, fact_ids_json
+                FROM memory_scenes WHERE profile_id = ?
+            """, (profile,))
+            for row in cursor.fetchall():
+                fact_ids = []
+                try:
+                    fact_ids = json.loads(row.get('fact_ids_json', '[]') or '[]')
+                except (json.JSONDecodeError, TypeError):
+                    pass
+                # Only include clusters that overlap with displayed nodes
+                overlap = [fid for fid in fact_ids if fid in node_ids]
+                if overlap:
+                    clusters.append({
+                        'cluster_id': row['scene_id'],
+                        'size': len(fact_ids),
+                        'visible_size': len(overlap),
+                        'theme': row.get('theme', ''),
+                    })
+        except Exception:
+            pass
+
+        return nodes, links, clusters
 
     # V2 fallback
     try:
@@ -362,15 +372,54 @@ async def get_clusters(request: Request):
         profile = get_active_profile()
         unclustered = 0
 
-        if _has_table(cursor, 'scene_facts'):
+        # V3 schema: memory_scenes stores fact_ids_json (JSON array)
+        if _has_table(cursor, 'memory_scenes'):
             cursor.execute("""
-                SELECT s.scene_id as cluster_id, COUNT(sf.fact_id) as member_count,
-                       s.summary, s.created_at as first_memory
-                FROM scenes s JOIN scene_facts sf ON s.scene_id = sf.scene_id
-                WHERE s.profile_id = ? GROUP BY s.scene_id ORDER BY member_count DESC
+                SELECT scene_id as cluster_id, theme, fact_ids_json,
+                       entity_ids_json, created_at as first_memory
+                FROM memory_scenes WHERE profile_id = ?
+                ORDER BY created_at DESC
             """, (profile,))
-            clusters = [dict(r, top_entities=[]) for r in cursor.fetchall()]
+            raw_scenes = cursor.fetchall()
+            clusters = []
+            for scene in raw_scenes:
+                fact_ids = []
+                try:
+                    fact_ids = json.loads(scene.get('fact_ids_json', '[]') or '[]')
+                except (json.JSONDecodeError, TypeError):
+                    pass
+                entity_ids = []
+                try:
+                    entity_ids = json.loads(scene.get('entity_ids_json', '[]') or '[]')
+                except (json.JSONDecodeError, TypeError):
+                    pass
+                clusters.append({
+                    'cluster_id': scene['cluster_id'],
+                    'member_count': len(fact_ids),
+                    'categories': scene.get('theme', ''),
+                    'summary': scene.get('theme', ''),
+                    'first_memory': scene.get('first_memory', ''),
+                    'top_entities': entity_ids[:5],
+                })
+            # Filter out empty clusters
+            clusters = [c for c in clusters if c['member_count'] > 0]
+            clusters.sort(key=lambda c: c['member_count'], reverse=True)
+
+            # Count facts not in any scene
+            all_scene_fact_ids = set()
+            for scene in raw_scenes:
+                try:
+                    ids = json.loads(scene.get('fact_ids_json', '[]') or '[]')
+                    all_scene_fact_ids.update(ids)
+                except (json.JSONDecodeError, TypeError):
+                    pass
+            total_facts = cursor.execute(
+                "SELECT COUNT(*) as c FROM atomic_facts WHERE profile_id = ?",
+                (profile,),
+            ).fetchone()['c']
+            unclustered = total_facts - len(all_scene_fact_ids)
         else:
+            # V2 fallback
             try:
                 cursor.execute("""
                     SELECT cluster_id, COUNT(*) as member_count,
@@ -382,8 +431,14 @@ async def get_clusters(request: Request):
                 clusters = [dict(r, top_entities=[]) for r in cursor.fetchall()]
             except Exception:
                 clusters = []
-            cursor.execute("SELECT COUNT(*) as c FROM memories WHERE cluster_id IS NULL AND profile = ?", (profile,))
-            unclustered = cursor.fetchone()['c']
+            try:
+                cursor.execute(
+                    "SELECT COUNT(*) as c FROM memories WHERE cluster_id IS NULL AND profile = ?",
+                    (profile,),
+                )
+                unclustered = cursor.fetchone()['c']
+            except Exception:
+                unclustered = 0
 
         conn.close()
         return {"clusters": clusters, "total_clusters": len(clusters), "unclustered_count": unclustered}
@@ -392,21 +447,41 @@ async def get_clusters(request: Request):
 
 
 @router.get("/api/clusters/{cluster_id}")
-async def get_cluster_detail(request: Request, cluster_id: int, limit: int = Query(50, ge=1, le=200)):
-    """Get detailed view of a specific cluster."""
+async def get_cluster_detail(request: Request, cluster_id: str, limit: int = Query(50, ge=1, le=200)):
+    """Get detailed view of a specific cluster (scene)."""
     try:
         conn = get_db_connection()
         conn.row_factory = dict_factory
         cursor = conn.cursor()
         profile = get_active_profile()
 
-        if _has_table(cursor, 'scene_facts'):
-            cursor.execute("""
-                SELECT f.fact_id as id, f.content, f.fact_type as category,
-                       f.confidence as importance, f.created_at
-                FROM atomic_facts f JOIN scene_facts sf ON f.fact_id = sf.fact_id
-                WHERE sf.scene_id = ? AND f.profile_id = ? ORDER BY f.confidence DESC LIMIT ?
-            """, (str(cluster_id), profile, limit))
+        if _has_table(cursor, 'memory_scenes'):
+            # Get fact IDs from the scene's JSON array
+            cursor.execute(
+                "SELECT fact_ids_json, theme FROM memory_scenes "
+                "WHERE scene_id = ? AND profile_id = ?",
+                (cluster_id, profile),
+            )
+            scene_row = cursor.fetchone()
+            if scene_row:
+                fact_ids = []
+                try:
+                    fact_ids = json.loads(scene_row.get('fact_ids_json', '[]') or '[]')
+                except (json.JSONDecodeError, TypeError):
+                    pass
+                if fact_ids:
+                    ph = ','.join('?' * min(len(fact_ids), limit))
+                    cursor.execute(f"""
+                        SELECT fact_id as id, content, fact_type as category,
+                               confidence as importance, created_at
+                        FROM atomic_facts
+                        WHERE profile_id = ? AND fact_id IN ({ph})
+                        ORDER BY confidence DESC
+                    """, [profile] + fact_ids[:limit])
+                else:
+                    cursor.execute("SELECT 1 WHERE 0")  # empty result
+            else:
+                cursor.execute("SELECT 1 WHERE 0")  # empty result
         else:
             cursor.execute("""
                 SELECT id, content, summary, category, project_name, importance, created_at, tags

package/src/superlocalmemory/server/routes/stats.py

@@ -13,7 +13,7 @@ from typing import Optional
 
 from fastapi import APIRouter, HTTPException, Query
 
-from .helpers import get_db_connection, dict_factory, get_active_profile, DB_PATH
+from .helpers import get_db_connection, dict_factory, get_active_profile, DB_PATH, MEMORY_DIR
 
 logger = logging.getLogger("superlocalmemory.routes.stats")
 router = APIRouter()
@@ -306,10 +306,38 @@ async def get_patterns():
 
         if not table_name:
             conn.close()
-            return {
-                "patterns": {}, "total_patterns": 0, "pattern_types": [],
-                "message": "Pattern learning not initialized.",
-            }
+            # Fall through to V3.1 behavioral pattern store
+            try:
+                from superlocalmemory.learning.behavioral import BehavioralPatternStore
+                store = BehavioralPatternStore(str(MEMORY_DIR / "learning.db"))
+                raw = store.get_patterns(profile_id=active_profile)
+                grouped = defaultdict(list)
+                for p in raw:
+                    meta = p.get("metadata", {})
+                    grouped[p["pattern_type"]].append({
+                        "pattern_type": p["pattern_type"],
+                        "key": meta.get("key", p.get("pattern_key", "")),
+                        "value": meta.get("value", p.get("pattern_key", "")),
+                        "confidence": p.get("confidence", 0),
+                        "evidence_count": p.get("evidence_count", 0),
+                    })
+                all_patterns = [p for ps in grouped.values() for p in ps]
+                confs = [p["confidence"] for p in all_patterns if p.get("confidence")]
+                return {
+                    "patterns": dict(grouped),
+                    "total_patterns": len(all_patterns),
+                    "pattern_types": list(grouped.keys()),
+                    "confidence_stats": {
+                        "avg": sum(confs) / len(confs) if confs else 0,
+                        "min": min(confs) if confs else 0,
+                        "max": max(confs) if confs else 0,
+                    },
+                }
+            except Exception:
+                return {
+                    "patterns": {}, "total_patterns": 0, "pattern_types": [],
+                    "message": "Pattern learning not initialized.",
+                }
 
         if table_name == 'identity_patterns':
             cursor.execute("""

package/src/superlocalmemory/server/routes/v3_api.py

@@ -339,6 +339,13 @@ async def recall_trace(request: Request):
             except Exception:
                 pass
 
+        # Record learning signals (non-blocking, non-critical)
+        try:
+            _record_learning_signals(query, result.get("results", []))
+        except Exception as _sig_exc:
+            import logging as _log
+            _log.getLogger(__name__).warning("Learning signal error: %s", _sig_exc)
+
         return {
             "query": query,
             "query_type": result.get("query_type", "unknown"),
@@ -351,6 +358,44 @@ async def recall_trace(request: Request):
         return JSONResponse({"error": str(e)}, status_code=500)
 
 
+def _record_learning_signals(query: str, results: list) -> None:
+    """Record feedback + co-retrieval + confidence boost for any recall."""
+    from pathlib import Path
+    from superlocalmemory.core.config import SLMConfig
+
+    slm_dir = Path.home() / ".superlocalmemory"
+    config = SLMConfig.load()
+    pid = config.active_profile
+    fact_ids = [r.get("fact_id", "") for r in results[:10] if r.get("fact_id")]
+    if not fact_ids:
+        return
+
+    try:
+        from superlocalmemory.learning.feedback import FeedbackCollector
+        collector = FeedbackCollector(slm_dir / "learning.db")
+        collector.record_implicit(
+            profile_id=pid, query=query,
+            fact_ids_returned=fact_ids, fact_ids_available=fact_ids,
+        )
+    except Exception:
+        pass
+
+    try:
+        from superlocalmemory.learning.signals import LearningSignals
+        signals = LearningSignals(slm_dir / "learning.db")
+        signals.record_co_retrieval(pid, fact_ids)
+    except Exception:
+        pass
+
+    try:
+        from superlocalmemory.learning.signals import LearningSignals
+        mem_db = str(slm_dir / "memory.db")
+        for fid in fact_ids[:5]:
+            LearningSignals.boost_confidence(mem_db, fid)
+    except Exception:
+        pass
+
+
 # ── Trust Dashboard ──────────────────────────────────────────
 
 @router.get("/trust/dashboard")
@@ -521,3 +566,51 @@ async def ide_connect(request: Request):
             return {"results": results}
     except Exception as e:
         return JSONResponse({"error": str(e)}, status_code=500)
+
+
+# ── Active Memory (V3.1) ────────────────────────────────────
+
+@router.get("/learning/signals")
+async def learning_signals():
+    """Get zero-cost learning signal statistics."""
+    try:
+        from superlocalmemory.learning.signals import LearningSignals
+        from superlocalmemory.core.config import SLMConfig
+        from superlocalmemory.server.routes.helpers import DB_PATH
+        learning_db = DB_PATH.parent / "learning.db"
+        signals = LearningSignals(learning_db)
+        config = SLMConfig.load()
+        pid = config.active_profile
+        return {"success": True, **signals.get_signal_stats(pid)}
+    except Exception as exc:
+        return {"success": False, "error": str(exc)}
+
+
+@router.post("/learning/consolidate")
+async def run_consolidation(request: Request):
+    """Run sleep-time consolidation. Body: {dry_run: true/false}."""
+    try:
+        body = await request.json()
+        dry_run = body.get("dry_run", False)
+        from superlocalmemory.learning.consolidation_worker import ConsolidationWorker
+        from superlocalmemory.core.config import SLMConfig
+        from superlocalmemory.server.routes.helpers import DB_PATH
+        worker = ConsolidationWorker(
+            memory_db=str(DB_PATH),
+            learning_db=str(DB_PATH.parent / "learning.db"),
+        )
+        config = SLMConfig.load()
+        stats = worker.run(config.active_profile, dry_run=dry_run)
+        return {"success": True, **stats}
+    except Exception as exc:
+        return {"success": False, "error": str(exc)}
+
+
+@router.get("/hooks/status")
+async def hooks_status():
+    """Check if Claude Code hooks are installed."""
+    try:
+        from superlocalmemory.hooks.claude_code_hooks import check_status
+        return {"success": True, **check_status()}
+    except Exception as exc:
+        return {"success": False, "error": str(exc)}