nlm-memory 0.12.0 → 0.13.1

package/dist/http/app.js

@@ -45,8 +45,12 @@ import { SourceRegistry, PgSourceRegistry, } from "../core/sources/source-regist
 import { ProviderRegistry, PgProviderRegistry, } from "../core/providers/provider-registry.js";
 import { listModels } from "../core/providers/provider-models.js";
 import { ingestSession, deriveSessionId } from "../core/ingest/ingest-session.js";
-import { listActions, undoAction, writeAction, writeActionsBatch, } from "../core/actions/actions-log.js";
+import { listActions, listActionsPg, undoAction, undoActionPg, writeAction, writeActionPg, writeActionsBatch, writeActionsBatchPg, } from "../core/actions/actions-log.js";
+import { PgSessionStore } from "../core/storage/pg-session-store.js";
 import { normalizeSignal } from "../core/signals/ingest-signal.js";
+import { normalizeExemplar } from "../core/exemplars/ingest-exemplar.js";
+import { extractExemplar } from "../core/exemplars/extract-exemplar.js";
+import { recallCode } from "../core/exemplars/recall-code.js";
 import { buildFailureModeBlock } from "../core/signals/failure-mode-recall.js";
 import { aggregateFailureModes } from "../core/signals/aggregate.js";
 const MIME_TYPES = {
@@ -73,6 +77,81 @@ const DATA_STAT_TABLES = [
     "sources",
     "providers",
 ];
+function sqliteDataStats(db, dbPath) {
+    const countOf = (table) => {
+        try {
+            const row = db.prepare(`SELECT COUNT(*) AS n FROM ${table}`).get();
+            return row?.n ?? 0;
+        }
+        catch {
+            return 0;
+        }
+    };
+    const tables = DATA_STAT_TABLES.map((name) => ({ name, rows: countOf(name) }));
+    const migrations = db
+        .prepare("SELECT version, name, applied_at FROM schema_migrations ORDER BY version")
+        .all();
+    const runtimes = db
+        .prepare("SELECT runtime, COUNT(*) AS n FROM sessions GROUP BY runtime ORDER BY n DESC")
+        .all();
+    let dbBytes = 0;
+    let dbPresent = false;
+    try {
+        dbBytes = statSync(dbPath).size;
+        dbPresent = true;
+    }
+    catch { /* file absent */ }
+    for (const sidecar of [`${dbPath}-wal`, `${dbPath}-shm`]) {
+        try {
+            dbBytes += statSync(sidecar).size;
+        }
+        catch { /* no sidecar */ }
+    }
+    return {
+        dbPath,
+        dbBytes,
+        dbPresent,
+        schemaVersion: migrations.length > 0 ? migrations[migrations.length - 1].version : null,
+        migrations,
+        tables,
+        runtimes,
+    };
+}
+async function pgDataStats(pool) {
+    const countOf = async (table) => {
+        try {
+            const r = await pool.query(`SELECT COUNT(*) AS n FROM ${table}`);
+            return Number(r.rows[0]?.n ?? 0);
+        }
+        catch {
+            return 0;
+        }
+    };
+    const tables = await Promise.all(DATA_STAT_TABLES.map(async (name) => ({ name, rows: await countOf(name) })));
+    const migrationsResult = await pool.query("SELECT version, name, applied_at FROM schema_migrations ORDER BY version");
+    const migrations = migrationsResult.rows.map((r) => ({
+        version: r.version,
+        name: r.name,
+        applied_at: String(r.applied_at),
+    }));
+    const runtimesResult = await pool.query("SELECT runtime, COUNT(*) AS n FROM sessions GROUP BY runtime ORDER BY n DESC");
+    const runtimes = runtimesResult.rows.map((r) => ({ runtime: r.runtime, n: Number(r.n) }));
+    let dbBytes = 0;
+    try {
+        const sizeResult = await pool.query("SELECT pg_database_size(current_database()) AS bytes");
+        dbBytes = Number(sizeResult.rows[0]?.bytes ?? 0);
+    }
+    catch { /* size unavailable */ }
+    return {
+        dbPath: "postgresql",
+        dbBytes,
+        dbPresent: true,
+        schemaVersion: migrations.length > 0 ? migrations[migrations.length - 1].version : null,
+        migrations,
+        tables,
+        runtimes,
+    };
+}
 function parseLimit(raw, fallback, max) {
     if (raw === undefined)
         return fallback;
@@ -787,50 +866,14 @@ function registerDatasetRoute(app, deps) {
 // ── Data management ─────────────────────────────────────────────
 // Storage stats, live-safe backup snapshot, and staged restore.
 function registerDataManagementRoutes(app, deps) {
-    app.get("/api/data/stats", (c) => {
+    app.get("/api/data/stats", async (c) => {
         if (!deps.liveStore || !deps.dbPath) {
             return c.json({ error: "data stats require liveStore + dbPath" }, 503);
         }
-        // TODO(#215a): replace rawDb() with port methods; cast until then
-        const db = deps.liveStore.rawDb();
-        const countOf = (table) => {
-            try {
-                const row = db.prepare(`SELECT COUNT(*) AS n FROM ${table}`).get();
-                return row?.n ?? 0;
-            }
-            catch {
-                return 0;
-            }
-        };
-        const tables = DATA_STAT_TABLES.map((name) => ({ name, rows: countOf(name) }));
-        const migrations = db
-            .prepare("SELECT version, name, applied_at FROM schema_migrations ORDER BY version")
-            .all();
-        const runtimes = db
-            .prepare("SELECT runtime, COUNT(*) AS n FROM sessions GROUP BY runtime ORDER BY n DESC")
-            .all();
-        let dbBytes = 0;
-        let dbPresent = false;
-        try {
-            dbBytes = statSync(deps.dbPath).size;
-            dbPresent = true;
-        }
-        catch { /* file absent */ }
-        for (const sidecar of [`${deps.dbPath}-wal`, `${deps.dbPath}-shm`]) {
-            try {
-                dbBytes += statSync(sidecar).size;
-            }
-            catch { /* no sidecar */ }
-        }
-        return c.json({
-            dbPath: deps.dbPath,
-            dbBytes,
-            dbPresent,
-            schemaVersion: migrations.length > 0 ? migrations[migrations.length - 1].version : null,
-            migrations,
-            tables,
-            runtimes,
-        });
+        const stats = deps.liveStore instanceof PgSessionStore
+            ? await pgDataStats(deps.liveStore.pool)
+            : sqliteDataStats(deps.liveStore.rawDb(), deps.dbPath);
+        return c.json(stats);
     });
     app.get("/api/data/backup", (c) => {
         const adminToken = process.env["NLM_MCP_TOKEN"];
@@ -846,9 +889,16 @@ function registerDataManagementRoutes(app, deps) {
         if (!deps.liveStore || !deps.dbPath) {
             return c.json({ error: "backup requires liveStore + dbPath" }, 503);
         }
+        // VACUUM INTO is a SQLite-only mechanism. PostgreSQL backups are delegated
+        // to the database layer (pg_dump / managed-PG snapshots / WAL archiving),
+        // not produced in-process by the daemon.
+        if (deps.liveStore instanceof PgSessionStore) {
+            return c.json({
+                error: "daemon backup is SQLite-only; for PostgreSQL use pg_dump or your managed-PG snapshot facility",
+            }, 501);
+        }
         const scratch = snapshotScratchPath(deps.dbPath);
         try {
-            // TODO(#215a): replace rawDb() with port methods; cast until then
             vacuumSnapshot(deps.liveStore.rawDb(), scratch);
             const bytes = readFileSync(scratch);
             const stamp = new Date().toISOString().slice(0, 10);
@@ -876,6 +926,13 @@ function registerDataManagementRoutes(app, deps) {
         }
         if (!deps.dbPath)
             return c.json({ error: "restore requires dbPath" }, 503);
+        // Staged restore swaps the SQLite file on restart — SQLite-only. PG restores
+        // go through pg_restore / managed-PG point-in-time recovery.
+        if (deps.liveStore instanceof PgSessionStore) {
+            return c.json({
+                error: "daemon restore is SQLite-only; for PostgreSQL use pg_restore or your managed-PG recovery facility",
+            }, 501);
+        }
         const form = await c.req.parseBody().catch(() => null);
         const file = form?.["file"];
         if (!(file instanceof File)) {
@@ -913,8 +970,10 @@ function registerActionRoutes(app, deps) {
         const parsed = parseActionInput(body);
         if (!parsed)
             return c.json({ error: "invalid action payload" }, 400);
-        // TODO(#215a): replace rawDb() with port methods; cast until then
-        const id = writeAction(deps.liveStore.rawDb(), parsed);
+        const store = deps.liveStore;
+        const id = store instanceof PgSessionStore
+            ? await writeActionPg(store.pool, parsed)
+            : writeAction(store.rawDb(), parsed);
         return c.json({ id, timestamp: new Date().toISOString() });
     });
     app.post("/api/action/batch", async (c) => {
@@ -928,39 +987,46 @@ function registerActionRoutes(app, deps) {
             .filter((x) => x !== null);
         if (inputs.length === 0)
             return c.json({ accepted: 0, ids: [] });
-        // TODO(#215a): replace rawDb() with port methods; cast until then
-        const ids = writeActionsBatch(deps.liveStore.rawDb(), inputs);
+        const store = deps.liveStore;
+        const ids = store instanceof PgSessionStore
+            ? await writeActionsBatchPg(store.pool, inputs)
+            : writeActionsBatch(store.rawDb(), inputs);
         return c.json({ accepted: ids.length, ids });
     });
-    app.post("/api/action/:id/undo", (c) => {
+    app.post("/api/action/:id/undo", async (c) => {
         if (!deps.liveStore)
             return c.json({ error: "actions require liveStore" }, 503);
-        // TODO(#215a): replace rawDb() with port methods; cast until then
-        const result = undoAction(deps.liveStore.rawDb(), c.req.param("id"));
+        const store = deps.liveStore;
+        const result = store instanceof PgSessionStore
+            ? await undoActionPg(store.pool, c.req.param("id"))
+            : undoAction(store.rawDb(), c.req.param("id"));
         if (!result)
             return c.json({ error: "action not found or already undone" }, 404);
         return c.json({ id: result.undoId, timestamp: new Date().toISOString() });
     });
-    app.get("/api/actions", (c) => {
+    app.get("/api/actions", async (c) => {
         if (!deps.liveStore)
             return c.json({ actions: [] });
         const limitRaw = c.req.query("limit");
         const subjectId = c.req.query("subject_id");
         const kind = c.req.query("kind");
         const limit = limitRaw ? Math.max(1, Math.min(500, Number.parseInt(limitRaw, 10))) : 100;
-        // TODO(#215a): replace rawDb() with port methods; cast until then
-        const rows = listActions(deps.liveStore.rawDb(), {
+        const opts = {
             limit,
             ...(subjectId ? { subjectId } : {}),
             ...(kind ? { kind } : {}),
-        });
+        };
+        const store = deps.liveStore;
+        const rows = store instanceof PgSessionStore
+            ? await listActionsPg(store.pool, opts)
+            : listActions(store.rawDb(), opts);
         return c.json({ actions: rows });
     });
 }
 function registerClassifierRoutes(app, deps) {
     app.get("/api/classifier/info", (c) => {
         const provider = deps.classifier?.provider ?? "ollama";
-        const model = deps.classifier?.model ?? "qwen3:4b-instruct-2507-q4_K_M";
+        const model = deps.classifier?.model ?? "qwen3.5:4b";
         return c.json({
             provider,
             model,
@@ -971,7 +1037,7 @@ function registerClassifierRoutes(app, deps) {
             },
             default_models: {
                 deepseek: ["deepseek-v4-flash", "deepseek-v4-pro", "deepseek-chat"],
-                ollama: ["qwen3:4b-instruct-2507-q4_K_M", "qwen2.5:3b-instruct", "llama3.2:3b", "mistral:7b"],
+                ollama: ["qwen3.5:4b", "qwen3:4b-instruct-2507-q4_K_M", "qwen2.5:3b-instruct", "llama3.2:3b", "mistral:7b"],
             },
             embedder: deps.embedderInfo ?? { provider: "ollama", model: "nomic-embed-text", dims: 768 },
         });
@@ -999,10 +1065,10 @@ function registerClassifierRoutes(app, deps) {
 // Each row = one transcript origin the daemon scans. UI uses these
 // endpoints to surface existing sources + let users add custom ones.
 function registerSourceRoutes(app, deps) {
-    app.get("/api/sources", (c) => {
+    app.get("/api/sources", async (c) => {
         if (!deps.sources)
             return c.json({ sources: [] });
-        return c.json({ sources: deps.sources.list() });
+        return c.json({ sources: await deps.sources.list() });
     });
     app.post("/api/sources", async (c) => {
         if (!deps.sources)
@@ -1011,11 +1077,10 @@ function registerSourceRoutes(app, deps) {
         const parsed = parseSourceInsert(body);
         if (!parsed)
             return c.json({ error: "invalid source payload" }, 400);
-        // TODO(#215a): PgSourceRegistry port; cast until then
-        if (deps.sources.getByName(parsed.name)) {
+        if (await deps.sources.getByName(parsed.name)) {
             return c.json({ error: `source named '${parsed.name}' already exists` }, 409);
         }
-        return c.json(deps.sources.insert(parsed), 201);
+        return c.json(await deps.sources.insert(parsed), 201);
     });
     app.patch("/api/sources/:id", async (c) => {
         if (!deps.sources)
@@ -1027,30 +1092,29 @@ function registerSourceRoutes(app, deps) {
         const patch = parseSourceUpdate(body);
         if (!patch)
             return c.json({ error: "invalid patch payload" }, 400);
-        const updated = deps.sources.update(id, patch);
+        const updated = await deps.sources.update(id, patch);
         if (!updated)
             return c.json({ error: `source ${id} not found` }, 404);
         return c.json(updated);
     });
-    app.delete("/api/sources/:id", (c) => {
+    app.delete("/api/sources/:id", async (c) => {
         if (!deps.sources)
             return c.json({ error: "sources registry unavailable" }, 503);
         const id = Number.parseInt(c.req.param("id"), 10);
         if (!Number.isFinite(id))
             return c.json({ error: "invalid id" }, 400);
-        const ok = deps.sources.delete(id);
+        const ok = await deps.sources.delete(id);
         if (!ok)
             return c.json({ error: `source ${id} not found` }, 404);
         return c.json({ deleted: id });
     });
-    app.post("/api/sources/:id/regenerate-token", (c) => {
+    app.post("/api/sources/:id/regenerate-token", async (c) => {
         if (!deps.sources)
             return c.json({ error: "sources registry unavailable" }, 503);
         const id = Number.parseInt(c.req.param("id"), 10);
         if (!Number.isFinite(id))
             return c.json({ error: "invalid id" }, 400);
-        // TODO(#215a): PgSourceRegistry port; cast until then
-        const token = deps.sources.regenerateToken(id);
+        const token = await deps.sources.regenerateToken(id);
         if (!token)
             return c.json({ error: "regenerate-token only applies to webhook sources" }, 400);
         return c.json({ token });
@@ -1067,8 +1131,7 @@ function registerIngestRoute(app, deps) {
         const match = /^Bearer\s+(\S+)$/i.exec(auth);
         if (!match || !match[1])
             return c.json({ error: "missing or malformed bearer token" }, 401);
-        // TODO(#215a): PgSourceRegistry port; cast until then
-        const source = deps.sources.findByToken(match[1]);
+        const source = await deps.sources.findByToken(match[1]);
         if (!source || source.kind !== "webhook")
             return c.json({ error: "invalid token" }, 401);
         if (!source.enabled)
@@ -1103,10 +1166,10 @@ function registerIngestRoute(app, deps) {
 // Each row = one LLM endpoint. Keys are redacted on every response
 // (rows carry hasApiKey:boolean instead).
 function registerProviderRoutes(app, deps) {
-    app.get("/api/providers", (c) => {
+    app.get("/api/providers", async (c) => {
         if (!deps.providers)
             return c.json({ providers: [] });
-        return c.json({ providers: deps.providers.list() });
+        return c.json({ providers: await deps.providers.list() });
     });
     app.post("/api/providers", async (c) => {
         if (!deps.providers)
@@ -1115,11 +1178,10 @@ function registerProviderRoutes(app, deps) {
         const parsed = parseProviderInsert(body);
         if (!parsed)
             return c.json({ error: "invalid provider payload" }, 400);
-        // TODO(#215a): PgProviderRegistry port; cast until then
-        if (deps.providers.getByName(parsed.name)) {
+        if (await deps.providers.getByName(parsed.name)) {
             return c.json({ error: `provider named '${parsed.name}' already exists` }, 409);
         }
-        return c.json(deps.providers.insert(parsed), 201);
+        return c.json(await deps.providers.insert(parsed), 201);
     });
     app.patch("/api/providers/:id", async (c) => {
         if (!deps.providers)
@@ -1131,18 +1193,18 @@ function registerProviderRoutes(app, deps) {
         const patch = parseProviderUpdate(body);
         if (!patch)
             return c.json({ error: "invalid patch payload" }, 400);
-        const updated = deps.providers.update(id, patch);
+        const updated = await deps.providers.update(id, patch);
         if (!updated)
             return c.json({ error: `provider ${id} not found` }, 404);
         return c.json(updated);
     });
-    app.delete("/api/providers/:id", (c) => {
+    app.delete("/api/providers/:id", async (c) => {
         if (!deps.providers)
             return c.json({ error: "providers registry unavailable" }, 503);
         const id = Number.parseInt(c.req.param("id"), 10);
         if (!Number.isFinite(id))
             return c.json({ error: "invalid id" }, 400);
-        const ok = deps.providers.delete(id);
+        const ok = await deps.providers.delete(id);
         if (!ok)
             return c.json({ error: `provider ${id} not found` }, 404);
         return c.json({ deleted: id });
@@ -1153,11 +1215,10 @@ function registerProviderRoutes(app, deps) {
         const id = Number.parseInt(c.req.param("id"), 10);
         if (!Number.isFinite(id))
             return c.json({ error: "invalid id" }, 400);
-        // TODO(#215a): PgProviderRegistry port; cast until then
-        const provider = deps.providers.get(id);
+        const provider = await deps.providers.get(id);
         if (!provider)
             return c.json({ error: `provider ${id} not found` }, 404);
-        const key = deps.providers.getSecret(id);
+        const key = await deps.providers.getSecret(id);
         try {
             const models = await listModels(provider, { apiKey: key });
             return c.json({ models });
@@ -1173,11 +1234,10 @@ function registerProviderRoutes(app, deps) {
         const id = Number.parseInt(c.req.param("id"), 10);
         if (!Number.isFinite(id))
             return c.json({ error: "invalid id" }, 400);
-        // TODO(#215a): PgProviderRegistry port; cast until then
-        const provider = deps.providers.get(id);
+        const provider = await deps.providers.get(id);
         if (!provider)
             return c.json({ error: `provider ${id} not found` }, 404);
-        const key = deps.providers.getSecret(id);
+        const key = await deps.providers.getSecret(id);
         const startedAt = Date.now();
         try {
             const models = await listModels(provider, { apiKey: key });
@@ -1412,6 +1472,28 @@ function registerSignalRoutes(app, deps) {
         catch {
             return c.json({ error: "signal insert failed" }, 500);
         }
+        // Best-effort code-exemplar capture: a code-bearing signal (git_sha or
+        // detail.code) becomes a retrievable exemplar. Gated by the flag and
+        // never allowed to fail the signal write — extractExemplar returns null
+        // when there's no code, and embedding is fire-and-forget.
+        if (process.env["NLM_CODE_EXEMPLARS_ENABLED"] === "1" &&
+            deps.exemplarStore &&
+            deps.installScope !== undefined) {
+            const exemplarStore = deps.exemplarStore;
+            try {
+                const exemplar = extractExemplar(signal, { installScope: deps.installScope });
+                if (exemplar) {
+                    const { id, skipped } = await exemplarStore.insert(exemplar);
+                    if (!skipped && deps.codeEmbedder) {
+                        void deps.codeEmbedder
+                            .embed(exemplar.taskContext + "\n" + exemplar.code, "document")
+                            .then((r) => exemplarStore.upsertEmbedding(id, r.vector))
+                            .catch(() => { });
+                    }
+                }
+            }
+            catch { /* capture is best-effort; never blocks signal ingest */ }
+        }
         return c.json({ id: signal.id, status: "accepted" }, 202);
     });
     app.get("/api/signals/failure-modes", async (c) => {
@@ -1439,6 +1521,67 @@ function registerSignalRoutes(app, deps) {
         const modes = aggregateFailureModes(rows);
         return c.json({ days, total: rows.length, modes });
     });
+    // ── Code exemplar routes (NLM_CODE_EXEMPLARS_ENABLED=1) ───────────────────
+    app.post("/api/exemplar", async (c) => {
+        if (!deps.exemplarStore || deps.installScope === undefined) {
+            return c.json({ error: "exemplar store not wired in this deployment" }, 503);
+        }
+        if (process.env["NLM_CODE_EXEMPLARS_ENABLED"] !== "1") {
+            return c.json({ error: "code exemplars disabled" }, 403);
+        }
+        let body;
+        try {
+            body = await c.req.json();
+        }
+        catch {
+            return c.json({ error: "body must be JSON" }, 400);
+        }
+        if (!body || typeof body !== "object" || Array.isArray(body)) {
+            return c.json({ error: "body must be a JSON object" }, 400);
+        }
+        let inp;
+        try {
+            inp = normalizeExemplar({ ...body, installScope: deps.installScope });
+        }
+        catch (e) {
+            return c.json({ error: e instanceof Error ? e.message : "invalid exemplar" }, 400);
+        }
+        const { id, skipped } = await deps.exemplarStore.insert(inp);
+        if (!skipped && deps.codeEmbedder) {
+            // Best-effort embedding: fire-and-forget, never blocks the response.
+            deps.codeEmbedder.embed(inp.taskContext + "\n" + inp.code, "document")
+                .then((r) => deps.exemplarStore.upsertEmbedding(id, r.vector))
+                .catch(() => { });
+        }
+        return c.json({ id, skipped, status: "accepted" }, 202);
+    });
+    app.get("/api/recall-code", async (c) => {
+        if (!deps.exemplarStore || deps.installScope === undefined) {
+            return c.json({ error: "exemplar store not wired in this deployment" }, 503);
+        }
+        if (process.env["NLM_CODE_EXEMPLARS_ENABLED"] !== "1") {
+            return c.json({ error: "code exemplars disabled" }, 403);
+        }
+        const query = c.req.query("q");
+        if (!query)
+            return c.json({ error: "q (query) is required" }, 400);
+        const kStr = c.req.query("k") ?? "5";
+        const k = Math.max(1, Math.min(20, Number.parseInt(kStr, 10) || 5));
+        const repo = c.req.query("repo");
+        const lang = c.req.query("lang");
+        const model = c.req.query("model");
+        const includeNegatives = c.req.query("negatives") !== "0";
+        const result = await recallCode({
+            query,
+            installScope: deps.installScope,
+            ...(repo ? { repo } : {}),
+            ...(lang ? { lang } : {}),
+            ...(model ? { model } : {}),
+            includeNegatives,
+            k,
+        }, deps.exemplarStore, deps.codeEmbedder ?? null, null);
+        return c.json(result);
+    });
 }
 function mountSpa(app, dist) {
     const indexHtml = join(dist, "index.html");