superlocalmemory 4.1.13 → 4.1.15

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

@@ -1,197 +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
-
-"""Optimize API routes — single canonical route file (INTERFACE-CONTRACT v2 §5 R2-01).
-
-All optimize endpoints live here.
-"""
-
-from __future__ import annotations
-
-import logging
-from typing import Any, Literal
-
-from fastapi import APIRouter, HTTPException
-from pydantic import BaseModel
-
-logger = logging.getLogger("superlocalmemory.server.routes.optimize")
-
-router = APIRouter(prefix="/api/optimize", tags=["optimize"])
-
-# F-03 fix: module-level singleton — constructed once, shared by /savings + CLI
-from superlocalmemory.optimize.metrics.estimator import SavingsEstimator as _SavingsEstimator  # noqa: E402
-_savings_estimator = _SavingsEstimator()
-
-
-class ConfigUpdateRequest(BaseModel):
-    """Partial config update — only provided fields are changed."""
-    enabled: bool | None = None
-    proxy_enabled: bool | None = None
-    cache_enabled: bool | None = None
-    semantic_enabled: bool | None = None
-    compress_enabled: bool | None = None
-    compress_mode: Literal['safe', 'aggressive'] | None = None
-    compress_prose: bool | None = None
-
-
-@router.get("/config")
-async def get_config() -> dict[str, Any]:
-    """Return current optimize config as JSON."""
-    try:
-        from superlocalmemory.optimize.config import get_shared_store
-        cfg = get_shared_store().get()
-        return cfg.as_dict()
-    except Exception as exc:
-        logger.warning("GET /api/optimize/config failed: %s", exc)
-        raise HTTPException(status_code=500, detail=str(exc))
-
-
-@router.put("/config")
-async def put_config(body: ConfigUpdateRequest) -> dict[str, Any]:
-    """Update optimize config (partial). Daemon hot-reloads within 2s."""
-    try:
-        import dataclasses
-        from superlocalmemory.optimize.config import get_shared_store
-        store = get_shared_store()
-        cfg = store.get()
-        updates: dict[str, Any] = {}
-        for field_name in ConfigUpdateRequest.model_fields:
-            val = getattr(body, field_name, None)
-            if val is not None:
-                updates[field_name] = val
-        if updates:
-            cfg = dataclasses.replace(cfg, **updates)
-            store.save(cfg)
-        return {"status": "ok", "updated": list(updates.keys())}
-    except ValueError as exc:
-        raise HTTPException(status_code=400, detail=str(exc))
-    except Exception as exc:
-        logger.warning("PUT /api/optimize/config failed: %s", exc)
-        raise HTTPException(status_code=500, detail=str(exc))
-
-
-@router.get("/status")
-async def get_status() -> dict[str, Any]:
-    """Concise enabled/disabled summary of each optimize sub-feature (M3).
-
-    REST-convention companion to `slm optimize status` (which reads config
-    locally). Returns a per-feature on/off view, the compression mode, and a
-    top-level `healthy` flag so external pollers have a stable endpoint.
-    """
-    try:
-        from superlocalmemory.optimize.config import get_shared_store
-        cfg = get_shared_store().get()
-        return {
-            "healthy": True,
-            "enabled": cfg.enabled,
-            "features": {
-                "proxy": cfg.proxy_enabled,
-                "cache": cfg.cache_enabled,
-                "compression": cfg.compress_enabled,
-                "semantic_cache": cfg.semantic_enabled,
-            },
-            "compress_mode": cfg.compress_mode,
-            "config_version": cfg.config_version,
-        }
-    except Exception as exc:
-        logger.warning("GET /api/optimize/status failed: %s", exc)
-        # Fail-open: report unhealthy rather than 500 so a poller can
-        # distinguish "daemon up but optimize degraded" from "daemon down".
-        return {"healthy": False, "error": "internal error"}
-
-
-@router.get("/savings")
-async def get_savings() -> dict[str, Any]:
-    """Return savings estimates from live metrics + CacheDB.
-
-    Field names match INTERFACE-CONTRACT §5 exactly.
-    """
-    try:
-        from superlocalmemory.optimize.config import get_shared_store
-        from superlocalmemory.optimize.metrics.counters import get_metrics
-        from superlocalmemory.optimize.storage.db import CacheDB
-
-        cfg = get_shared_store().get()
-        collector = get_metrics()
-        db = CacheDB()
-        snap = collector.snapshot(
-            cache_size_bytes=db.db_size_bytes(),
-            cache_entry_count=db.entry_count(),
-        )
-
-        # F-03 fix: use module-level singleton instead of per-request instantiation
-        # DASH-V6 fix: attribute may EXIST but be None; getattr default only
-        # covers the missing case, so coerce None -> default to avoid .lower() crash.
-        active_model = getattr(cfg, "active_model", None) or "anthropic"
-        # Determine provider from model
-        provider = "anthropic"
-        for key in ("anthropic", "openai", "gemini"):
-            if key in active_model.lower():
-                provider = key
-                break
-        est = _savings_estimator.estimate(snap, provider=provider)
-
-        # compress_ratio from snap (byte-based, survives restart)
-        if snap.compress_bytes_original > 0:
-            compress_ratio = snap.compress_bytes_after / snap.compress_bytes_original
-        else:
-            compress_ratio = None
-
-        total = snap.hits + snap.misses
-        hit_rate = snap.hits / total if total > 0 else 0.0
-
-        # F-02 fix: response keys match INTERFACE-CONTRACT §5 exactly
-        return {
-            "tokens_saved_input": snap.tokens_saved_input,
-            "tokens_saved_output": snap.tokens_saved_output,
-            "calls_skipped": snap.calls_skipped,
-            "compress_ratio": round(compress_ratio, 4) if compress_ratio is not None else None,
-            "cost_saved": {"usd": est["usd"], "inr": est["inr"]},
-            "hit_rate": round(hit_rate, 4),
-            "cache_bytes": snap.cache_size_bytes,
-            "entries": snap.cache_entry_count,
-            # diagnostic fields — non-conflicting extras
-            "hits": snap.hits,
-            "misses": snap.misses,
-            "tokens_saved_compress": snap.tokens_saved_compress,
-            "is_stale": est["is_stale"],
-            "pricing_date": est["pricing_date"],
-        }
-    except Exception as exc:
-        logger.warning("GET /api/optimize/savings failed: %s", exc)
-        raise HTTPException(status_code=500, detail=str(exc))
-
-
-@router.get("/stats")
-async def get_stats() -> dict[str, Any]:
-    """Return raw metrics snapshot as JSON."""
-    try:
-        from superlocalmemory.optimize.metrics.counters import get_metrics
-        from superlocalmemory.optimize.storage.db import CacheDB
-
-        collector = get_metrics()
-        db = CacheDB()
-        snap = collector.snapshot(
-            cache_size_bytes=db.db_size_bytes(),
-            cache_entry_count=db.entry_count(),
-        )
-        # Return all 16 fields as dict
-        import dataclasses
-        return dataclasses.asdict(snap)
-    except Exception as exc:
-        logger.warning("GET /api/optimize/stats failed: %s", exc)
-        raise HTTPException(status_code=500, detail=str(exc))
-
-
-@router.delete("/cache/clear")
-async def delete_cache_clear(tenant: str = "default") -> dict[str, Any]:
-    """Delete all cache entries for a tenant."""
-    try:
-        from superlocalmemory.optimize.storage.db import CacheDB
-        db = CacheDB()
-        deleted = db.clear_tenant(tenant)
-        return {"success": True, "deleted": deleted}
-    except Exception as exc:
-        logger.warning("DELETE /api/optimize/cache/clear failed: %s", exc)
-        raise HTTPException(status_code=500, detail=str(exc))

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

@@ -1,173 +0,0 @@
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later - see LICENSE file
-# Part of SuperLocalMemory v3.4.22 — LLD-01 §4.4 / §4.5
-
-"""POST /internal/prewarm — populates the context cache for a session.
-
-Bug fix: ``hooks/prewarm_auth.authorize`` (which gates loopback →
-origin → install-token → body-size) was implemented and unit-tested,
-but no FastAPI route mounted it. The hot-path ``post_tool_async_hook``
-POSTs to ``/internal/prewarm`` after every tool call to refresh the
-``active_brain_cache`` row for the current session/topic. Without a
-route registered here, those POSTs 404'd silently, the cache never
-populated, and every ``UserPromptSubmit`` ended up a structural miss.
-
-Design notes
-------------
-* All 4 gates from LLD-01 §4.4 run before any engine work: loopback
-  peer, absence of browser ``Origin`` header, valid install-token, body
-  <= ``MAX_BODY_BYTES``. On any gate failure we return the decision's
-  status code with ``application/json`` error envelope and do not touch
-  the engine. This is LLD-07 SEC-HR-03 applied at the edge.
-* The route is async; the actual cache write (``ContextCache.upsert``)
-  is synchronous SQLite and runs on the default executor via
-  ``asyncio.to_thread`` so we never block the event loop.
-* Body schema is intentionally narrow: ``{"session_id": str,
-  "prompt": str, "content": str, "fact_ids": list[str]}``. Missing or
-  wrong-type fields produce 400.
-* Never raises past this function. Any unexpected exception is caught,
-  logged at ``debug`` to avoid log flooding under a hostile peer, and
-  returned as 500 JSON. The hot path ``post_tool_async_hook`` treats
-  any non-2xx as "fire-and-forget, try again later", so degradation is
-  graceful.
-"""
-
-from __future__ import annotations
-
-import asyncio
-import logging
-import time
-
-from fastapi import APIRouter, Request
-from fastapi.responses import JSONResponse
-
-logger = logging.getLogger(__name__)
-
-router = APIRouter(tags=["internal"])
-
-
-_ALLOWED_BODY_KEYS = frozenset({"session_id", "prompt", "content", "fact_ids"})
-
-
-@router.post("/internal/prewarm")
-async def prewarm(request: Request) -> JSONResponse:
-    """Write (or refresh) a context-cache entry for the caller's session.
-
-    Gates (LLD-01 §4.4):
-      1. Loopback-only client (127.0.0.1 / ::1 / localhost).
-      2. Reject browser-originated calls (any ``Origin`` header).
-      3. Install-token present and constant-time-verified.
-      4. Body <= ``MAX_BODY_BYTES``.
-
-    On success, returns ``{"ok": true}``. On any failure, returns the
-    AuthDecision's status with a terse JSON body. Never exposes engine
-    error detail to the caller.
-    """
-    # Gates 1-3 first (cheap; reject hostile peers before reading body).
-    try:
-        from superlocalmemory.hooks.prewarm_auth import (
-            MAX_BODY_BYTES,
-            authorize,
-            check_body_size,
-        )
-    except Exception as exc:  # pragma: no cover — primitives always present
-        logger.debug("prewarm: auth primitives unimportable: %s", exc)
-        return JSONResponse({"error": "server_error"}, status_code=500)
-
-    client_host = request.client.host if request.client else ""
-    headers = {k.lower(): v for k, v in request.headers.items()}
-
-    decision = authorize(client_host=client_host, headers=headers)
-    if not decision.allowed:
-        return JSONResponse(
-            {"error": decision.reason}, status_code=decision.status,
-        )
-
-    # Gate 4 — read body with a hard size cap. FastAPI/Starlette has no
-    # cheap way to check the Content-Length up front in all servers, so
-    # we read at most MAX_BODY_BYTES+1 and reject if we got more.
-    try:
-        body_bytes = await request.body()
-    except Exception as exc:  # pragma: no cover
-        logger.debug("prewarm: body read failed: %s", exc)
-        return JSONResponse({"error": "bad_body"}, status_code=400)
-    ok, reason = check_body_size(body_bytes)
-    if not ok:
-        return JSONResponse({"error": reason}, status_code=413)
-
-    try:
-        import json as _json
-        payload = _json.loads(body_bytes or b"{}")
-    except Exception:
-        return JSONResponse({"error": "invalid_json"}, status_code=400)
-
-    if not isinstance(payload, dict):
-        return JSONResponse({"error": "invalid_json"}, status_code=400)
-
-    # Narrow contract: reject unknown keys to keep the surface small.
-    # S10-SEC-N-02: fixed error tag, never echo attacker-supplied keys.
-    unknown = set(payload.keys()) - _ALLOWED_BODY_KEYS
-    if unknown:
-        return JSONResponse(
-            {"error": "unknown_keys"}, status_code=400,
-        )
-
-    session_id = payload.get("session_id")
-    prompt = payload.get("prompt")
-    content = payload.get("content")
-    fact_ids = payload.get("fact_ids") or []
-    if not isinstance(session_id, str) or not session_id:
-        return JSONResponse({"error": "session_id_required"}, status_code=400)
-    if not isinstance(prompt, str) or not prompt:
-        return JSONResponse({"error": "prompt_required"}, status_code=400)
-    if not isinstance(content, str) or not content:
-        return JSONResponse({"error": "content_required"}, status_code=400)
-    if not isinstance(fact_ids, list) or not all(
-        isinstance(f, str) for f in fact_ids
-    ):
-        return JSONResponse({"error": "fact_ids_list"}, status_code=400)
-
-    try:
-        topic_sig = await asyncio.to_thread(_compute_topic_sig, prompt)
-        await asyncio.to_thread(
-            _upsert_cache,
-            session_id=session_id,
-            topic_sig=topic_sig,
-            content=content,
-            fact_ids=fact_ids,
-        )
-    except Exception as exc:  # pragma: no cover — defensive
-        logger.debug("prewarm: upsert failed: %s", exc)
-        return JSONResponse({"error": "upsert_failed"}, status_code=500)
-
-    return JSONResponse({"ok": True})
-
-
-def _compute_topic_sig(prompt: str) -> str:
-    """Lazy import so module import is free of hot-path SLM modules."""
-    from superlocalmemory.core.topic_signature import compute_topic_signature
-    return compute_topic_signature(prompt)
-
-
-def _upsert_cache(
-    *, session_id: str, topic_sig: str,
-    content: str, fact_ids: list[str],
-) -> None:
-    from superlocalmemory.core.context_cache import CacheEntry, ContextCache
-    from superlocalmemory.server.routes.helpers import get_active_profile
-    cache = ContextCache()
-    try:
-        cache.upsert(CacheEntry(
-            session_id=session_id,
-            topic_sig=topic_sig,
-            content=content,
-            fact_ids=tuple(fact_ids),
-            provenance="prewarm_post_tool",
-            computed_at=int(time.time()),
-            profile_id=get_active_profile(),  # so non-default profiles hit
-        ))
-    finally:
-        cache.close()
-
-
-__all__ = ("router",)

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

@@ -1,292 +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 Routes
- - AGPL-3.0-or-later
-
-Routes: /api/profiles, /api/profiles/{name}/switch,
-        /api/profiles/create, DELETE /api/profiles/{name}
-
-SQLite is the single source of truth for profiles. profiles.json
-is kept in sync as a cache for backward compatibility.
-"""
-import asyncio
-import logging
-from datetime import datetime, timezone
-
-from fastapi import APIRouter, HTTPException, Request
-
-from superlocalmemory.server.route_mutations import authorize_route_mutation
-
-from .helpers import (
-    get_db_connection, validate_profile_name,
-    ProfileSwitch, DB_PATH,
-    sync_profiles, ensure_profile_in_db, ensure_profile_in_json,
-    delete_profile_from_db,
-    _load_profiles_json, _save_profiles_json,
-)
-from superlocalmemory.storage.memory_write import memory_write
-from superlocalmemory.server.profile_runtime import (
-    commit_daemon_profile_switch,
-    get_profile_runtime,
-    TransitionDrainTimeout,
-)
-
-logger = logging.getLogger("superlocalmemory.routes.profiles")
-router = APIRouter()
-
-
-def _internal_error(detail: str = "Internal server error") -> HTTPException:
-    """SEC-H-02: log full traceback server-side; return a generic message to the client."""
-    logger.exception("profiles route error")
-    return HTTPException(status_code=500, detail=detail)
-
-# WebSocket manager reference (set by ui_server.py at startup)
-ws_manager = None
-
-
-def _get_memory_count(profile: str) -> int:
-    """Get memory count for a profile."""
-    try:
-        conn = get_db_connection()
-        cursor = conn.cursor()
-        try:
-            cursor.execute(
-                "SELECT COUNT(*) FROM atomic_facts WHERE profile_id = ?", (profile,),
-            )
-            count = cursor.fetchone()[0]
-        except Exception:
-            cursor.execute(
-                "SELECT COUNT(*) FROM memories WHERE profile = ?", (profile,),
-            )
-            count = cursor.fetchone()[0]
-        conn.close()
-        return count
-    except Exception:
-        return 0
-
-
-@router.get("/api/profiles")
-async def list_profiles(request: Request):
-    """List available memory profiles (synced from SQLite + profiles.json)."""
-    try:
-        merged = sync_profiles()
-        active = get_profile_runtime(request.app.state).snapshot.profile_id
-
-        profiles = []
-        for p in merged:
-            # profile_id is the canonical key (PK, FK target, used by engine)
-            pid = p.get('profile_id', p.get('name', ''))
-            count = _get_memory_count(pid)
-            profiles.append({
-                "name": pid,
-                "description": p.get('description', ''),
-                "memory_count": count,
-                "created_at": p.get('created_at', ''),
-                "last_used": p.get('last_used', ''),
-                "is_active": pid == active,
-            })
-
-        return {
-            "profiles": profiles,
-            "active_profile": active,
-            "total_profiles": len(profiles),
-        }
-
-    except Exception:
-        raise _internal_error("Profile list error")
-
-
-@router.post("/api/profiles/{name}/switch")
-async def switch_profile(name: str, request: Request):
-    """Switch active memory profile (persists to both config stores)."""
-    try:
-        if not validate_profile_name(name):
-            raise HTTPException(status_code=400, detail="Invalid profile name.")
-
-        merged = sync_profiles()
-        merged_ids = {p.get('profile_id', p.get('name', '')) for p in merged}
-
-        if name not in merged_ids:
-            available = ', '.join(sorted(merged_ids))
-            raise HTTPException(
-                status_code=404,
-                detail=f"Profile '{name}' not found. Available: {available}",
-            )
-
-        authorization = authorize_route_mutation(
-            request,
-            operation="update",
-            source_agent_id="http-profile-switch",
-            profile_id=name,
-        )
-        # RBAC (C4): a logged-in user may only activate a workspace they belong
-        # to — this is the read boundary. Switching sets the active tenant for
-        # subsequent reads, so a non-member must not be able to enter it. The
-        # machine owner (no user session) switches freely.
-        from superlocalmemory.server.rbac_enforce import resolve_principal
-        _principal = resolve_principal(request)
-        if _principal.get("kind") == "user":
-            _rbac = getattr(request.app.state, "rbac", None)
-            if _rbac is not None and _rbac.get_role(_principal["user_id"], name) is None:
-                raise HTTPException(
-                    status_code=403,
-                    detail="You are not a member of this workspace.",
-                )
-        runtime = get_profile_runtime(request.app.state)
-        previous = runtime.snapshot.profile_id
-        try:
-            snapshot = await asyncio.to_thread(
-                runtime.transition,
-                name,
-                lambda prior, target: commit_daemon_profile_switch(
-                    request.app.state,
-                    prior,
-                    target,
-                ),
-            )
-        except TransitionDrainTimeout as exc:
-            raise HTTPException(
-                status_code=503,
-                detail=str(exc),
-            )
-
-        count = _get_memory_count(name)
-
-        if ws_manager:
-            await ws_manager.broadcast({
-                "type": "profile_switched", "profile": name,
-                "previous": previous, "memory_count": count,
-                "timestamp": datetime.now(timezone.utc).isoformat(),
-            })
-
-        authorization.complete()
-        return {
-            "success": True, "active_profile": name,
-            "previous_profile": previous, "memory_count": count,
-            "generation": snapshot.generation,
-            "message": f"Switched to profile '{name}' ({count} memories).",
-        }
-
-    except HTTPException:
-        raise
-    except Exception:
-        raise _internal_error("Profile switch error")
-
-
-@router.post("/api/profiles/create")
-async def create_profile(body: ProfileSwitch, request: Request):
-    """Create a new memory profile (writes to BOTH SQLite and profiles.json)."""
-    try:
-        name = body.profile_name
-        if not validate_profile_name(name):
-            raise HTTPException(status_code=400, detail="Invalid profile name")
-
-        # Check both stores for duplicates
-        merged = sync_profiles()
-        merged_ids = {p.get('profile_id', p.get('name', '')) for p in merged}
-        if name in merged_ids:
-            raise HTTPException(status_code=409, detail=f"Profile '{name}' already exists")
-
-        authorization = authorize_route_mutation(
-            request,
-            operation="update",
-            source_agent_id="http-profile-create",
-        )
-        # RBAC (C3): creating a tenant is an administrative action.
-        from superlocalmemory.access.rbac import Permission as _Perm
-        from superlocalmemory.server.rbac_enforce import require_manage as _rbac_manage
-        _principal = _rbac_manage(request)
-        # Write to BOTH stores atomically
-        desc = f'Memory profile: {name}'
-        ensure_profile_in_db(name, desc)
-        ensure_profile_in_json(name, desc)
-
-        # A logged-in user who creates a workspace becomes its admin so they
-        # can manage it immediately (profile_id == name here). The machine
-        # owner needs no membership row (implicit root).
-        if _principal.get("kind") == "user":
-            rbac = getattr(request.app.state, "rbac", None)
-            if rbac is not None:
-                try:
-                    rbac.set_membership(name, _principal["user_id"], "admin",
-                                        added_by=_principal["username"])
-                except Exception:
-                    pass
-
-        authorization.complete()
-        return {"success": True, "profile": name, "message": f"Profile '{name}' created"}
-
-    except HTTPException:
-        raise
-    except Exception:
-        raise _internal_error("Profile create error")
-
-
-@router.delete("/api/profiles/{name}")
-async def delete_profile(name: str, request: Request):
-    """Delete a profile. Moves its memories to 'default'."""
-    try:
-        if name == 'default':
-            raise HTTPException(status_code=400, detail="Cannot delete 'default' profile")
-
-        merged = sync_profiles()
-        merged_ids = {p.get('profile_id', p.get('name', '')) for p in merged}
-        if name not in merged_ids:
-            raise HTTPException(status_code=404, detail=f"Profile '{name}' not found")
-
-        runtime = get_profile_runtime(request.app.state)
-        if runtime.snapshot.profile_id == name:
-            raise HTTPException(status_code=400, detail="Cannot delete active profile.")
-
-        json_config = _load_profiles_json()
-
-        authorization = authorize_route_mutation(
-            request,
-            operation="delete",
-            source_agent_id="http-profile-delete",
-            profile_id=name,
-        )
-        # RBAC (C3): deleting a tenant is administrative. Check MANAGE on the
-        # profile being deleted (not the active one).
-        from superlocalmemory.server.rbac_enforce import require_manage as _rbac_manage
-        _rbac_manage(request, profile=name)
-        # Move data to default before deleting (bypasses CASCADE).
-        # memory_write: write lock + busy_timeout — two UPDATEs are atomic.
-        moved = 0
-        with memory_write(DB_PATH) as conn:
-            try:
-                cur = conn.execute(
-                    "UPDATE atomic_facts SET profile_id = 'default' WHERE profile_id = ?",
-                    (name,),
-                )
-                moved = cur.rowcount
-            except Exception:
-                pass
-            try:
-                cur2 = conn.execute(
-                    "UPDATE memories SET profile_id = 'default' WHERE profile_id = ?",
-                    (name,),
-                )
-                moved += cur2.rowcount
-            except Exception:
-                pass
-
-        # Delete from BOTH stores
-        delete_profile_from_db(name)
-
-        profiles = json_config.get('profiles', {})
-        profiles.pop(name, None)
-        json_config['profiles'] = profiles
-        _save_profiles_json(json_config)
-
-        authorization.complete()
-        return {
-            "success": True,
-            "message": f"Profile '{name}' deleted. {moved} memories moved to 'default'.",
-        }
-
-    except HTTPException:
-        raise
-    except Exception:
-        raise _internal_error("Profile delete error")