superlocalmemory 3.2.1 → 3.2.2

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

@@ -614,3 +614,579 @@ async def hooks_status():
         return {"success": True, **check_status()}
     except Exception as exc:
         return {"success": False, "error": str(exc)}
+
+
+# ── Phase 6: V3.2 API Endpoints ──────────────────────────────
+# 9 new endpoints for the V3.2 dashboard tabs:
+#   Auto-Invoke (2), Associations (2), Consolidation (2),
+#   Core Memory (2), VectorStore (1)
+#
+# Rules enforced:
+#   01 - Profile scoping on ALL endpoints
+#   06 - No engine import from routes (direct sqlite3)
+#   11 - Parameterized SQL everywhere
+#   18 - WorkerPool for POST consolidation/trigger
+#   19 - Silent errors with JSONResponse
+# ──────────────────────────────────────────────────────────────
+
+
+def _load_auto_invoke_json() -> dict:
+    """Load auto-invoke config from config.json's auto_invoke section."""
+    from superlocalmemory.server.routes.helpers import MEMORY_DIR
+    config_path = MEMORY_DIR / "config.json"
+    if config_path.exists():
+        try:
+            data = json.loads(config_path.read_text())
+            return data.get("auto_invoke", {})
+        except (json.JSONDecodeError, IOError):
+            pass
+    return {}
+
+
+def _save_auto_invoke_json(auto_invoke_data: dict) -> None:
+    """Persist auto-invoke config into config.json's auto_invoke section."""
+    from superlocalmemory.server.routes.helpers import MEMORY_DIR
+    config_path = MEMORY_DIR / "config.json"
+    cfg: dict = {}
+    if config_path.exists():
+        try:
+            cfg = json.loads(config_path.read_text())
+        except (json.JSONDecodeError, IOError):
+            pass
+    cfg["auto_invoke"] = auto_invoke_data
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+    config_path.write_text(json.dumps(cfg, indent=2))
+
+
+# ── 1. GET /api/v3/auto-invoke/config ─────────────────────────
+
+@router.get("/auto-invoke/config")
+async def get_auto_invoke_config(request: Request):
+    """Get current auto-invoke configuration."""
+    try:
+        from superlocalmemory.core.config import AutoInvokeConfig
+        defaults = AutoInvokeConfig()
+
+        persisted = _load_auto_invoke_json()
+
+        return {
+            "enabled": persisted.get("enabled", defaults.enabled),
+            "min_score": persisted.get("min_score", defaults.fok_threshold),
+            "weights": persisted.get("weights", dict(defaults.weights)),
+            "act_r_mode": persisted.get("act_r_mode", defaults.use_act_r),
+            "invocation_count": persisted.get("invocation_count", 0),
+            "last_invocation": persisted.get("last_invocation", None),
+        }
+    except Exception as e:
+        return JSONResponse({"error": str(e)}, status_code=500)
+
+
+# ── 2. PUT /api/v3/auto-invoke/config ─────────────────────────
+
+@router.put("/auto-invoke/config")
+async def set_auto_invoke_config(request: Request):
+    """Update auto-invoke configuration.
+
+    Body: {"enabled": true, "min_score": 0.15, "weights": {...}}
+    """
+    try:
+        body = await request.json()
+
+        # Validate min_score range
+        min_score = body.get("min_score")
+        if min_score is not None and (min_score < 0 or min_score > 1):
+            return JSONResponse(
+                {"error": "min_score must be between 0 and 1"},
+                status_code=400,
+            )
+
+        # Load existing, merge updates
+        from superlocalmemory.core.config import AutoInvokeConfig
+        defaults = AutoInvokeConfig()
+        persisted = _load_auto_invoke_json()
+
+        updated = {
+            "enabled": body.get("enabled", persisted.get("enabled", defaults.enabled)),
+            "min_score": body.get("min_score", persisted.get("min_score", defaults.fok_threshold)),
+            "weights": body.get("weights", persisted.get("weights", dict(defaults.weights))),
+            "act_r_mode": body.get("act_r_mode", persisted.get("act_r_mode", defaults.use_act_r)),
+            "invocation_count": persisted.get("invocation_count", 0),
+            "last_invocation": persisted.get("last_invocation", None),
+        }
+        _save_auto_invoke_json(updated)
+
+        return updated
+    except Exception as e:
+        return JSONResponse({"error": str(e)}, status_code=500)
+
+
+# ── 3. GET /api/v3/associations ───────────────────────────────
+
+@router.get("/associations")
+async def get_associations(
+    request: Request,
+    limit: int = 50,
+    type: str = "",
+    profile: str = "",
+):
+    """Get association edges for a profile with content previews."""
+    try:
+        from superlocalmemory.server.routes.helpers import get_active_profile, DB_PATH
+        import sqlite3
+        pid = profile or get_active_profile()
+
+        if not DB_PATH.exists():
+            return {"edges": [], "total": 0}
+
+        conn = sqlite3.connect(str(DB_PATH))
+        conn.row_factory = sqlite3.Row
+
+        # Build query with optional type filter (parameterized)
+        params: list = [pid]
+        sql = (
+            "SELECT ae.edge_id, ae.source_fact_id, ae.target_fact_id, "
+            "ae.association_type, ae.weight, ae.co_access_count, ae.created_at, "
+            "sf.content AS source_content, tf.content AS target_content "
+            "FROM association_edges ae "
+            "LEFT JOIN atomic_facts sf ON sf.fact_id = ae.source_fact_id "
+            "LEFT JOIN atomic_facts tf ON tf.fact_id = ae.target_fact_id "
+            "WHERE ae.profile_id = ? "
+        )
+        if type:
+            sql += "AND ae.association_type = ? "
+            params.append(type)
+        sql += "ORDER BY ae.created_at DESC LIMIT ?"
+        params.append(limit)
+
+        rows = conn.execute(sql, params).fetchall()
+
+        # Total count (separate query for pagination info)
+        count_sql = "SELECT COUNT(*) FROM association_edges WHERE profile_id = ?"
+        count_params: list = [pid]
+        if type:
+            count_sql += " AND association_type = ?"
+            count_params.append(type)
+        total = conn.execute(count_sql, count_params).fetchone()[0]
+
+        conn.close()
+
+        edges = []
+        for r in rows:
+            row = dict(r)
+            source_content = row.get("source_content") or ""
+            target_content = row.get("target_content") or ""
+            edges.append({
+                "edge_id": row["edge_id"],
+                "source_fact_id": row["source_fact_id"],
+                "target_fact_id": row["target_fact_id"],
+                "association_type": row["association_type"],
+                "weight": round(float(row["weight"]), 3),
+                "co_access_count": row["co_access_count"],
+                "created_at": row["created_at"],
+                "source_preview": source_content[:100],
+                "target_preview": target_content[:100],
+            })
+
+        return {"edges": edges, "total": total}
+    except Exception as e:
+        return JSONResponse({"error": str(e)}, status_code=500)
+
+
+# ── 4. GET /api/v3/associations/stats ─────────────────────────
+
+@router.get("/associations/stats")
+async def get_association_stats(request: Request, profile: str = ""):
+    """Get association graph statistics."""
+    try:
+        from superlocalmemory.server.routes.helpers import get_active_profile, DB_PATH
+        import sqlite3
+        pid = profile or get_active_profile()
+
+        if not DB_PATH.exists():
+            return {
+                "total_edges": 0,
+                "by_type": {},
+                "community_count": 0,
+                "avg_weight": 0.0,
+                "top_connected_facts": [],
+            }
+
+        conn = sqlite3.connect(str(DB_PATH))
+        conn.row_factory = sqlite3.Row
+
+        # Total edges
+        total = conn.execute(
+            "SELECT COUNT(*) FROM association_edges WHERE profile_id = ?",
+            (pid,),
+        ).fetchone()[0]
+
+        # Edges by type
+        by_type_rows = conn.execute(
+            "SELECT association_type, COUNT(*) AS cnt "
+            "FROM association_edges WHERE profile_id = ? "
+            "GROUP BY association_type",
+            (pid,),
+        ).fetchall()
+        by_type = {row["association_type"]: row["cnt"] for row in by_type_rows}
+
+        # Average weight
+        avg_row = conn.execute(
+            "SELECT AVG(weight) AS avg_w FROM association_edges "
+            "WHERE profile_id = ?",
+            (pid,),
+        ).fetchone()
+        avg_weight = round(float(avg_row["avg_w"] or 0), 3)
+
+        # Community count from fact_importance table
+        community_count = 0
+        try:
+            cc_row = conn.execute(
+                "SELECT COUNT(DISTINCT community_id) AS cnt "
+                "FROM fact_importance "
+                "WHERE profile_id = ? AND community_id IS NOT NULL",
+                (pid,),
+            ).fetchone()
+            community_count = cc_row["cnt"] if cc_row else 0
+        except Exception:
+            pass
+
+        # Top connected facts (by degree = count of edges as source or target)
+        top_facts = []
+        try:
+            degree_rows = conn.execute(
+                "SELECT fact_id, degree FROM ("
+                "  SELECT source_fact_id AS fact_id, COUNT(*) AS degree "
+                "  FROM association_edges WHERE profile_id = ? "
+                "  GROUP BY source_fact_id "
+                "  UNION ALL "
+                "  SELECT target_fact_id AS fact_id, COUNT(*) AS degree "
+                "  FROM association_edges WHERE profile_id = ? "
+                "  GROUP BY target_fact_id "
+                ") GROUP BY fact_id ORDER BY SUM(degree) DESC LIMIT 5",
+                (pid, pid),
+            ).fetchall()
+            for dr in degree_rows:
+                fact_id = dr["fact_id"]
+                preview_row = conn.execute(
+                    "SELECT content FROM atomic_facts WHERE fact_id = ?",
+                    (fact_id,),
+                ).fetchone()
+                preview = (dict(preview_row).get("content", "")[:80]) if preview_row else ""
+                top_facts.append({
+                    "fact_id": fact_id,
+                    "degree": dr["degree"],
+                    "preview": preview,
+                })
+        except Exception:
+            pass
+
+        conn.close()
+
+        return {
+            "total_edges": total,
+            "by_type": by_type,
+            "community_count": community_count,
+            "avg_weight": avg_weight,
+            "top_connected_facts": top_facts,
+        }
+    except Exception as e:
+        return JSONResponse({"error": str(e)}, status_code=500)
+
+
+# ── 5. GET /api/v3/consolidation/status ───────────────────────
+
+@router.get("/consolidation/status")
+async def get_consolidation_status(request: Request, profile: str = ""):
+    """Get consolidation status and last run results."""
+    try:
+        from superlocalmemory.server.routes.helpers import get_active_profile, DB_PATH
+        from superlocalmemory.core.config import SLMConfig
+        import sqlite3
+
+        pid = profile or get_active_profile()
+        config = SLMConfig.load()
+        cons_cfg = config.consolidation
+
+        result: dict = {
+            "enabled": cons_cfg.enabled,
+            "last_run": None,
+            "last_result": None,
+            "triggers": {
+                "session_end": cons_cfg.session_trigger,
+                "idle_timeout": cons_cfg.idle_timeout_seconds,
+                "step_count": cons_cfg.step_count_trigger,
+                "scheduled_sessions": cons_cfg.scheduled_sessions,
+            },
+            "store_count_since_last": 0,
+        }
+
+        if not DB_PATH.exists():
+            return result
+
+        conn = sqlite3.connect(str(DB_PATH))
+        conn.row_factory = sqlite3.Row
+
+        # Last consolidation log entry
+        try:
+            last_row = conn.execute(
+                "SELECT timestamp, action_type, reason "
+                "FROM consolidation_log "
+                "WHERE profile_id = ? ORDER BY timestamp DESC LIMIT 1",
+                (pid,),
+            ).fetchone()
+            if last_row:
+                result["last_run"] = dict(last_row).get("timestamp")
+        except Exception:
+            pass
+
+        # Count blocks compiled (proxy for last consolidation result)
+        try:
+            block_count = conn.execute(
+                "SELECT COUNT(*) FROM core_memory_blocks WHERE profile_id = ?",
+                (pid,),
+            ).fetchone()[0]
+            edge_count = conn.execute(
+                "SELECT COUNT(*) FROM association_edges WHERE profile_id = ?",
+                (pid,),
+            ).fetchone()[0]
+            result["last_result"] = {
+                "blocks_compiled": block_count,
+                "total_edges": edge_count,
+            }
+        except Exception:
+            pass
+
+        # Store count since last consolidation
+        try:
+            if result["last_run"]:
+                sc = conn.execute(
+                    "SELECT COUNT(*) FROM atomic_facts "
+                    "WHERE profile_id = ? AND created_at > ?",
+                    (pid, result["last_run"]),
+                ).fetchone()[0]
+                result["store_count_since_last"] = sc
+            else:
+                sc = conn.execute(
+                    "SELECT COUNT(*) FROM atomic_facts WHERE profile_id = ?",
+                    (pid,),
+                ).fetchone()[0]
+                result["store_count_since_last"] = sc
+        except Exception:
+            pass
+
+        conn.close()
+        return result
+    except Exception as e:
+        return JSONResponse({"error": str(e)}, status_code=500)
+
+
+# ── 6. POST /api/v3/consolidation/trigger ─────────────────────
+
+@router.post("/consolidation/trigger")
+async def trigger_consolidation(request: Request):
+    """Trigger consolidation manually.
+
+    Body: {"lightweight": false, "profile": ""}
+    Uses WorkerPool for thread safety (Rule 18).
+    """
+    try:
+        body = await request.json()
+        lightweight = body.get("lightweight", False)
+        profile = body.get("profile", "")
+
+        from superlocalmemory.server.routes.helpers import get_active_profile
+        pid = profile or get_active_profile()
+
+        # Use WorkerPool to run consolidation in the worker subprocess (Rule 18)
+        try:
+            from superlocalmemory.core.worker_pool import WorkerPool
+            pool = WorkerPool.shared()
+            result = pool.send_command({
+                "action": "consolidate",
+                "profile_id": pid,
+                "lightweight": lightweight,
+            })
+            if result and result.get("ok"):
+                return {"success": True, **result}
+        except Exception:
+            pass
+
+        # Fallback: direct consolidation if WorkerPool unavailable
+        from superlocalmemory.core.config import SLMConfig
+        from superlocalmemory.storage.database import DatabaseManager
+        from superlocalmemory.storage import schema as _schema
+        from superlocalmemory.core.consolidation_engine import ConsolidationEngine
+
+        config = SLMConfig.load()
+        db = DatabaseManager(config.db_path)
+        db.initialize(_schema)
+
+        engine = ConsolidationEngine(db=db, config=config.consolidation, slm_config=config)
+        result = engine.consolidate(profile_id=pid, lightweight=lightweight)
+
+        return {"success": True, **result}
+    except Exception as e:
+        return JSONResponse({"error": str(e)}, status_code=500)
+
+
+# ── 7. GET /api/v3/core-memory ────────────────────────────────
+
+@router.get("/core-memory")
+async def get_core_memory(request: Request, profile: str = ""):
+    """Get all Core Memory blocks for a profile."""
+    try:
+        from superlocalmemory.server.routes.helpers import get_active_profile, DB_PATH
+        import sqlite3
+        pid = profile or get_active_profile()
+
+        if not DB_PATH.exists():
+            return {"blocks": [], "total_chars": 0, "char_limit": 2000}
+
+        conn = sqlite3.connect(str(DB_PATH))
+        conn.row_factory = sqlite3.Row
+
+        rows = conn.execute(
+            "SELECT block_id, block_type, content, char_count, version, "
+            "compiled_by, updated_at FROM core_memory_blocks "
+            "WHERE profile_id = ? ORDER BY block_type",
+            (pid,),
+        ).fetchall()
+
+        conn.close()
+
+        blocks = []
+        total_chars = 0
+        for r in rows:
+            row = dict(r)
+            char_count = row.get("char_count", 0) or len(row.get("content", ""))
+            total_chars += char_count
+            blocks.append({
+                "block_id": row["block_id"],
+                "block_type": row["block_type"],
+                "content": row["content"],
+                "char_count": char_count,
+                "version": row["version"],
+                "compiled_by": row["compiled_by"],
+                "updated_at": row["updated_at"],
+            })
+
+        return {"blocks": blocks, "total_chars": total_chars, "char_limit": 2000}
+    except Exception as e:
+        return JSONResponse({"error": str(e)}, status_code=500)
+
+
+# ── 8. PUT /api/v3/core-memory/{block_id} ─────────────────────
+
+@router.put("/core-memory/{block_id}")
+async def update_core_memory_block(block_id: str, request: Request):
+    """Update a Core Memory block's content manually.
+
+    Body: {"content": "Updated content..."}
+    """
+    try:
+        body = await request.json()
+        content = body.get("content")
+        if content is None:
+            return JSONResponse(
+                {"error": "content field is required"},
+                status_code=400,
+            )
+
+        from superlocalmemory.server.routes.helpers import DB_PATH
+        import sqlite3
+        from datetime import datetime, timezone
+
+        if not DB_PATH.exists():
+            return JSONResponse(
+                {"error": "Database not found"},
+                status_code=404,
+            )
+
+        conn = sqlite3.connect(str(DB_PATH))
+        conn.row_factory = sqlite3.Row
+
+        # Verify block exists
+        existing = conn.execute(
+            "SELECT block_id, profile_id, block_type, version "
+            "FROM core_memory_blocks WHERE block_id = ?",
+            (block_id,),
+        ).fetchone()
+
+        if not existing:
+            conn.close()
+            return JSONResponse(
+                {"error": f"Block {block_id} not found"},
+                status_code=404,
+            )
+
+        existing_dict = dict(existing)
+        new_version = existing_dict["version"] + 1
+        now = datetime.now(timezone.utc).isoformat()
+
+        conn.execute(
+            "UPDATE core_memory_blocks SET content = ?, char_count = ?, "
+            "version = ?, compiled_by = 'manual', updated_at = ? "
+            "WHERE block_id = ?",
+            (content, len(content), new_version, now, block_id),
+        )
+        conn.commit()
+
+        # Read back updated block
+        updated = conn.execute(
+            "SELECT block_id, block_type, content, char_count, version, "
+            "compiled_by, updated_at FROM core_memory_blocks "
+            "WHERE block_id = ?",
+            (block_id,),
+        ).fetchone()
+        conn.close()
+
+        return dict(updated) if updated else {"block_id": block_id, "updated": True}
+    except Exception as e:
+        return JSONResponse({"error": str(e)}, status_code=500)
+
+
+# ── 9. GET /api/v3/vector-store/status ────────────────────────
+
+@router.get("/vector-store/status")
+async def get_vector_store_status(request: Request, profile: str = ""):
+    """Get VectorStore health and statistics."""
+    try:
+        from superlocalmemory.core.config import SLMConfig
+        from superlocalmemory.server.routes.helpers import DB_PATH
+        import sqlite3
+
+        config = SLMConfig.load()
+
+        result: dict = {
+            "available": False,
+            "provider": "sqlite-vec",
+            "dimension": config.embedding.dimension,
+            "embedding_model": config.embedding.model_name,
+            "total_vectors": 0,
+            "binary_quantization": False,
+            "binary_quantization_threshold": 100000,
+            "fallback_to_ann": False,
+        }
+
+        # Check if sqlite-vec extension is available
+        try:
+            import sqlite_vec  # noqa: F401
+            result["available"] = True
+        except ImportError:
+            result["fallback_to_ann"] = True
+
+        # Count vectors in embedding_metadata
+        if DB_PATH.exists():
+            try:
+                conn = sqlite3.connect(str(DB_PATH))
+                count = conn.execute(
+                    "SELECT COUNT(*) FROM embedding_metadata"
+                ).fetchone()[0]
+                result["total_vectors"] = count
+                conn.close()
+            except Exception:
+                pass
+
+        return result
+    except Exception as e:
+        return JSONResponse({"error": str(e)}, status_code=500)