superlocalmemory 3.4.1 → 3.4.4

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

@@ -0,0 +1,63 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under the Elastic License 2.0 - see LICENSE file
+# Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
+
+"""Ingestion adapter management API — enable/disable/start/stop from dashboard.
+
+v3.4.4: Users can manage Gmail, Calendar, Transcript adapters entirely from
+the dashboard UI — no CLI needed. The best product experience.
+
+Endpoints:
+  GET  /api/adapters         — list all adapters with status
+  POST /api/adapters/enable  — enable an adapter
+  POST /api/adapters/disable — disable an adapter
+  POST /api/adapters/start   — start a running adapter
+  POST /api/adapters/stop    — stop a running adapter
+"""
+
+from __future__ import annotations
+
+from fastapi import APIRouter, Request
+from pydantic import BaseModel
+
+router = APIRouter(tags=["adapters"])
+
+
+class AdapterAction(BaseModel):
+    name: str
+
+
+@router.get("/api/adapters")
+async def list_adapters_api():
+    """List all adapters with their enabled/running status."""
+    from superlocalmemory.ingestion.adapter_manager import list_adapters
+    adapters = list_adapters()
+    return {"adapters": adapters}
+
+
+@router.post("/api/adapters/enable")
+async def enable_adapter_api(body: AdapterAction):
+    """Enable an adapter (doesn't start it yet)."""
+    from superlocalmemory.ingestion.adapter_manager import enable_adapter
+    return enable_adapter(body.name)
+
+
+@router.post("/api/adapters/disable")
+async def disable_adapter_api(body: AdapterAction):
+    """Disable and stop an adapter."""
+    from superlocalmemory.ingestion.adapter_manager import disable_adapter
+    return disable_adapter(body.name)
+
+
+@router.post("/api/adapters/start")
+async def start_adapter_api(body: AdapterAction):
+    """Start a running adapter subprocess."""
+    from superlocalmemory.ingestion.adapter_manager import start_adapter
+    return start_adapter(body.name)
+
+
+@router.post("/api/adapters/stop")
+async def stop_adapter_api(body: AdapterAction):
+    """Stop a running adapter."""
+    from superlocalmemory.ingestion.adapter_manager import stop_adapter
+    return stop_adapter(body.name)

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

@@ -0,0 +1,151 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under the Elastic License 2.0 - see LICENSE file
+# Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
+
+"""Entity compilation API routes — view and recompile entity summaries."""
+
+from __future__ import annotations
+
+from fastapi import APIRouter, HTTPException, Request, Query
+
+router = APIRouter(prefix="/api/entity", tags=["entity"])
+
+
+@router.get("/list")
+async def list_entities(
+    request: Request,
+    profile: str = Query(default="default"),
+    limit: int = Query(default=100, ge=1, le=1000),
+    offset: int = Query(default=0, ge=0),
+):
+    """List all entities with basic info (canonical name, type, fact count)."""
+    engine = request.app.state.engine
+    if engine is None:
+        raise HTTPException(503, detail="Engine not initialized")
+
+    import sqlite3
+    import json
+    conn = sqlite3.connect(str(engine._config.db_path))
+    conn.row_factory = sqlite3.Row
+    try:
+        total = conn.execute(
+            "SELECT COUNT(*) FROM canonical_entities WHERE profile_id = ?",
+            (profile,),
+        ).fetchone()[0]
+
+        rows = conn.execute("""
+            SELECT ce.entity_id, ce.canonical_name, ce.entity_type,
+                   ce.fact_count, ce.first_seen, ce.last_seen,
+                   ep.knowledge_summary, ep.compiled_truth,
+                   ep.compilation_confidence, ep.last_compiled_at
+            FROM canonical_entities ce
+            LEFT JOIN entity_profiles ep
+              ON ce.entity_id = ep.entity_id AND ep.profile_id = ce.profile_id
+            WHERE ce.profile_id = ?
+            ORDER BY ce.fact_count DESC
+            LIMIT ? OFFSET ?
+        """, (profile, limit, offset)).fetchall()
+
+        entities = []
+        for r in rows:
+            summary = r["knowledge_summary"] or ""
+            entities.append({
+                "entity_id": r["entity_id"],
+                "name": r["canonical_name"],
+                "type": r["entity_type"] or "unknown",
+                "fact_count": r["fact_count"] or 0,
+                "first_seen": r["first_seen"],
+                "last_seen": r["last_seen"],
+                "summary_preview": summary[:200] if summary else "",
+                "has_compiled_truth": bool(r["compiled_truth"]),
+                "confidence": r["compilation_confidence"] or 0.5,
+                "last_compiled_at": r["last_compiled_at"],
+            })
+
+        return {"entities": entities, "total": total, "limit": limit, "offset": offset}
+    finally:
+        conn.close()
+
+
+@router.get("/{entity_name}")
+async def get_entity(
+    entity_name: str,
+    request: Request,
+    profile: str = Query(default="default"),
+    project: str = Query(default=""),
+):
+    """Get compiled truth + timeline for an entity."""
+    engine = request.app.state.engine
+    if engine is None:
+        raise HTTPException(503, detail="Engine not initialized")
+
+    import sqlite3
+    import json
+    conn = sqlite3.connect(str(engine._config.db_path))
+    conn.row_factory = sqlite3.Row
+    try:
+        # Search by canonical_name (case-insensitive)
+        row = conn.execute("""
+            SELECT ep.compiled_truth, ep.timeline, ep.fact_ids_json,
+                   ep.last_compiled_at, ep.compilation_confidence,
+                   ep.knowledge_summary, ce.entity_type
+            FROM entity_profiles ep
+            JOIN canonical_entities ce ON ep.entity_id = ce.entity_id
+            WHERE LOWER(ce.canonical_name) = LOWER(?)
+              AND ep.profile_id = ?
+              AND ep.project_name = ?
+        """, (entity_name, profile, project)).fetchone()
+
+        if not row:
+            raise HTTPException(404, detail=f"Entity '{entity_name}' not found")
+
+        return {
+            "entity_name": entity_name,
+            "entity_type": row["entity_type"],
+            "compiled_truth": row["compiled_truth"] or "",
+            "knowledge_summary": row["knowledge_summary"] or "",
+            "timeline": json.loads(row["timeline"]) if row["timeline"] else [],
+            "source_fact_ids": json.loads(row["fact_ids_json"]) if row["fact_ids_json"] else [],
+            "last_compiled_at": row["last_compiled_at"],
+            "confidence": row["compilation_confidence"],
+        }
+    finally:
+        conn.close()
+
+
+@router.post("/{entity_name}/recompile")
+async def recompile_entity(
+    entity_name: str,
+    request: Request,
+    profile: str = Query(default="default"),
+    project: str = Query(default=""),
+):
+    """Force immediate recompilation of an entity."""
+    engine = request.app.state.engine
+    if engine is None:
+        raise HTTPException(503, detail="Engine not initialized")
+
+    import sqlite3
+    conn = sqlite3.connect(str(engine._config.db_path))
+    conn.row_factory = sqlite3.Row
+    try:
+        entity = conn.execute(
+            "SELECT entity_id, canonical_name, entity_type FROM canonical_entities "
+            "WHERE LOWER(canonical_name) = LOWER(?) AND profile_id = ?",
+            (entity_name, profile),
+        ).fetchone()
+
+        if not entity:
+            raise HTTPException(404, detail=f"Entity '{entity_name}' not found")
+
+        from superlocalmemory.learning.entity_compiler import EntityCompiler
+        compiler = EntityCompiler(str(engine._config.db_path), engine._config)
+        result = compiler.compile_entity(
+            profile, project, entity["entity_id"], entity["canonical_name"],
+        )
+
+        if result:
+            return {"ok": True, **result}
+        return {"ok": False, "reason": "no facts to compile"}
+    finally:
+        conn.close()

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

@@ -0,0 +1,110 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under the Elastic License 2.0 - see LICENSE file
+# Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
+
+"""Ingestion endpoint — accepts data from external adapters.
+
+POST /ingest with {content, source_type, dedup_key, metadata}.
+Deduplicates by source_type + dedup_key. Stores via MemoryEngine.
+Admission control: max 10 concurrent ingestions (HTTP 429 on overflow).
+
+Part of Qualixar | Author: Varun Pratap Bhardwaj
+"""
+
+from __future__ import annotations
+
+import json
+import sqlite3
+import threading
+from datetime import datetime, timezone
+
+from fastapi import APIRouter, HTTPException, Request
+from pydantic import BaseModel
+
+router = APIRouter(tags=["ingestion"])
+
+_MAX_CONCURRENT = 10
+_active_count = 0
+_active_lock = threading.Lock()
+
+
+class IngestRequest(BaseModel):
+    content: str
+    source_type: str
+    dedup_key: str
+    metadata: dict = {}
+
+
+@router.post("/ingest")
+async def ingest(req: IngestRequest, request: Request):
+    """Ingest content from an external adapter.
+
+    Deduplicates by (source_type, dedup_key). Returns 429 if too many
+    concurrent ingestions. Stores via the singleton MemoryEngine.
+    """
+    global _active_count
+
+    engine = request.app.state.engine
+    if engine is None:
+        raise HTTPException(503, detail="Engine not initialized")
+
+    if not req.content:
+        raise HTTPException(400, detail="content required")
+    if not req.source_type:
+        raise HTTPException(400, detail="source_type required")
+    if not req.dedup_key:
+        raise HTTPException(400, detail="dedup_key required")
+
+    # Admission control
+    with _active_lock:
+        if _active_count >= _MAX_CONCURRENT:
+            raise HTTPException(
+                429,
+                detail="Too many concurrent ingestions",
+                headers={"Retry-After": "5"},
+            )
+        _active_count += 1
+
+    try:
+        # Dedup check
+        conn = sqlite3.connect(str(engine._config.db_path))
+        try:
+            existing = conn.execute(
+                "SELECT id FROM ingestion_log WHERE source_type=? AND dedup_key=?",
+                (req.source_type, req.dedup_key),
+            ).fetchone()
+            if existing:
+                return {"ingested": False, "reason": "already_ingested"}
+        finally:
+            conn.close()
+
+        # Store via engine
+        metadata = {**req.metadata, "source_type": req.source_type}
+        fact_ids = engine.store(req.content, metadata=metadata)
+
+        # Log to ingestion_log
+        conn = sqlite3.connect(str(engine._config.db_path))
+        try:
+            conn.execute(
+                "INSERT OR IGNORE INTO ingestion_log "
+                "(source_type, dedup_key, fact_ids, metadata, status, ingested_at) "
+                "VALUES (?, ?, ?, ?, 'ingested', ?)",
+                (
+                    req.source_type,
+                    req.dedup_key,
+                    json.dumps(fact_ids),
+                    json.dumps(req.metadata),
+                    datetime.now(timezone.utc).isoformat(),
+                ),
+            )
+            conn.commit()
+        finally:
+            conn.close()
+
+        return {"ingested": True, "fact_ids": fact_ids}
+
+    except Exception as exc:
+        raise HTTPException(500, detail=str(exc))
+    finally:
+        with _active_lock:
+            _active_count -= 1

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

@@ -0,0 +1,186 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under the Elastic License 2.0 - see LICENSE file
+# Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
+
+"""SLM Mesh — FastAPI routes for P2P agent communication.
+
+Mounted at /mesh/* in the unified daemon. Uses MeshBroker for all operations.
+
+Part of Qualixar | Author: Varun Pratap Bhardwaj
+"""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from fastapi import APIRouter, HTTPException, Request
+from pydantic import BaseModel
+
+router = APIRouter(prefix="/mesh", tags=["mesh"])
+
+
+# -- Request models --
+
+class RegisterRequest(BaseModel):
+    session_id: str
+    summary: str = ""
+    host: str = "127.0.0.1"
+    port: int = 0
+
+
+class DeregisterRequest(BaseModel):
+    peer_id: str
+
+
+class HeartbeatRequest(BaseModel):
+    peer_id: str
+
+
+class SummaryRequest(BaseModel):
+    peer_id: str
+    summary: str
+
+
+class SendRequest(BaseModel):
+    from_peer: str = ""
+    to: str
+    content: str
+    type: str = "text"
+
+
+class ReadRequest(BaseModel):
+    message_ids: list[int]
+
+
+class StateSetRequest(BaseModel):
+    key: str
+    value: str
+    set_by: str
+
+
+class LockRequest(BaseModel):
+    file_path: str
+    locked_by: str
+    action: str  # acquire, release, query
+
+
+# -- Helpers --
+
+def _get_broker(request: Request):
+    broker = getattr(request.app.state, 'mesh_broker', None)
+    if broker is None:
+        raise HTTPException(503, detail="Mesh broker not initialized")
+    # Check if mesh is enabled
+    config = getattr(request.app.state, 'config', None)
+    if config and not getattr(config, 'mesh_enabled', True):
+        raise HTTPException(503, detail="Mesh disabled in config")
+    return broker
+
+
+# -- Routes --
+
+@router.post("/register")
+async def register(req: RegisterRequest, request: Request):
+    broker = _get_broker(request)
+    if not req.session_id:
+        raise HTTPException(400, detail="session_id required")
+    return broker.register_peer(req.session_id, req.summary, req.host, req.port)
+
+
+@router.post("/deregister")
+async def deregister(req: DeregisterRequest, request: Request):
+    broker = _get_broker(request)
+    result = broker.deregister_peer(req.peer_id)
+    if not result.get("ok"):
+        raise HTTPException(404, detail=result.get("error", "peer not found"))
+    return result
+
+
+@router.get("/peers")
+async def peers(request: Request):
+    broker = _get_broker(request)
+    return {"peers": broker.list_peers()}
+
+
+@router.post("/heartbeat")
+async def heartbeat(req: HeartbeatRequest, request: Request):
+    broker = _get_broker(request)
+    result = broker.heartbeat(req.peer_id)
+    if not result.get("ok"):
+        raise HTTPException(404, detail=result.get("error", "peer not found"))
+    return result
+
+
+@router.post("/summary")
+async def summary(req: SummaryRequest, request: Request):
+    broker = _get_broker(request)
+    result = broker.update_summary(req.peer_id, req.summary)
+    if not result.get("ok"):
+        raise HTTPException(404, detail=result.get("error", "peer not found"))
+    return result
+
+
+@router.post("/send")
+async def send(req: SendRequest, request: Request):
+    broker = _get_broker(request)
+    result = broker.send_message(req.from_peer, req.to, req.content, req.type)
+    if not result.get("ok"):
+        raise HTTPException(404, detail=result.get("error", ""))
+    return result
+
+
+@router.get("/inbox/{peer_id}")
+async def inbox(peer_id: str, request: Request):
+    broker = _get_broker(request)
+    return {"messages": broker.get_inbox(peer_id)}
+
+
+@router.post("/inbox/{peer_id}/read")
+async def mark_read(peer_id: str, req: ReadRequest, request: Request):
+    broker = _get_broker(request)
+    return broker.mark_read(peer_id, req.message_ids)
+
+
+@router.get("/state")
+async def state_all(request: Request):
+    broker = _get_broker(request)
+    return {"state": broker.get_state()}
+
+
+@router.post("/state")
+async def state_set(req: StateSetRequest, request: Request):
+    broker = _get_broker(request)
+    if not req.key:
+        raise HTTPException(400, detail="key required")
+    return broker.set_state(req.key, req.value, req.set_by)
+
+
+@router.get("/state/{key}")
+async def state_get(key: str, request: Request):
+    broker = _get_broker(request)
+    result = broker.get_state_key(key)
+    if result is None:
+        raise HTTPException(404, detail="key not found")
+    return result
+
+
+@router.post("/lock")
+async def lock(req: LockRequest, request: Request):
+    broker = _get_broker(request)
+    if not req.file_path or not req.locked_by:
+        raise HTTPException(400, detail="file_path and locked_by required")
+    if req.action not in ("acquire", "release", "query"):
+        raise HTTPException(400, detail="action must be acquire, release, or query")
+    return broker.lock_action(req.file_path, req.locked_by, req.action)
+
+
+@router.get("/events")
+async def events(request: Request):
+    broker = _get_broker(request)
+    return {"events": broker.get_events()}
+
+
+@router.get("/status")
+async def status(request: Request):
+    broker = _get_broker(request)
+    return broker.get_status()