omo-memory 0.1.13 → 0.1.15

package/dist/graphTui.js

@@ -1,239 +0,0 @@
-import { spawn } from "node:child_process";
-import { BoxRenderable, createCliRenderer, TextRenderable } from "@opentui/core";
-const SNAPSHOT_ENV = "OMO_MEMORY_GRAPH_TUI_SNAPSHOT";
-const COLORS = {
-    background: "#101419",
-    border: "#516071",
-    detail: "#17212b",
-    text: "#d8dee9",
-    muted: "#94a3b8",
-    accent: "#7dd3fc",
-};
-export async function runGraphTui(options) {
-    const existingSnapshot = parseSnapshot(process.env[SNAPSHOT_ENV]);
-    if (process.versions["bun"] === undefined) {
-        const graphSnapshot = existingSnapshot ?? (await createGraphSnapshot(options));
-        await runWithBun(options, graphSnapshot);
-        return;
-    }
-    if (existingSnapshot === null) {
-        throw new Error("graph tui OpenTUI renderer requires a graph snapshot");
-    }
-    const renderer = await createCliRenderer({
-        targetFps: 12,
-        maxFps: 12,
-        screenMode: "main-screen",
-        consoleMode: "disabled",
-        clearOnShutdown: false,
-    });
-    renderer.setTerminalTitle("OMO Ontology Graph");
-    let state = { options, selectedId: null, snapshot: existingSnapshot };
-    let graph = loadGraph(state);
-    state = { ...state, selectedId: graph.detail?.id ?? null };
-    const root = new BoxRenderable(renderer, {
-        id: "graph-root",
-        width: "100%",
-        height: "100%",
-        flexDirection: "column",
-        backgroundColor: COLORS.background,
-        padding: 1,
-        gap: 1,
-    });
-    const title = new TextRenderable(renderer, { id: "graph-title", content: "", fg: COLORS.accent, height: 1, truncate: true });
-    const body = new BoxRenderable(renderer, { id: "graph-body", flexGrow: 1, flexDirection: "row", gap: 1 });
-    const nodesPane = new BoxRenderable(renderer, {
-        id: "graph-nodes-pane",
-        width: "50%",
-        height: "100%",
-        border: true,
-        borderColor: COLORS.border,
-        title: "Nodes",
-        padding: 1,
-        backgroundColor: COLORS.background,
-    });
-    const detailPane = new BoxRenderable(renderer, {
-        id: "graph-detail-pane",
-        flexGrow: 1,
-        height: "100%",
-        border: true,
-        borderColor: COLORS.border,
-        title: "Detail Pane",
-        padding: 1,
-        backgroundColor: COLORS.detail,
-    });
-    const nodesText = new TextRenderable(renderer, { id: "graph-nodes", content: "", fg: COLORS.text, wrapMode: "word" });
-    const detailText = new TextRenderable(renderer, { id: "graph-detail", content: "", fg: COLORS.text, wrapMode: "word" });
-    const footer = new TextRenderable(renderer, { id: "graph-footer", content: "", fg: COLORS.muted, height: 1, truncate: true });
-    nodesPane.add(nodesText);
-    detailPane.add(detailText);
-    body.add(nodesPane);
-    body.add(detailPane);
-    root.add(title);
-    root.add(body);
-    root.add(footer);
-    renderer.root.add(root);
-    const render = () => {
-        graph = loadGraph(state);
-        state = { ...state, selectedId: graph.detail?.id ?? null };
-        title.content = titleText(graph, state.options.query);
-        nodesText.content = nodesContent(graph);
-        detailText.content = detailContent(graph);
-        footer.content = "q quit | ArrowUp/ArrowDown/Tab select | Legend: D durable, W working, T temporary, E ephemeral";
-        renderer.requestRender();
-    };
-    await new Promise((resolve) => {
-        const quit = () => {
-            renderer.keyInput.removeAllListeners("keypress");
-            renderer.destroy();
-            resolve();
-        };
-        renderer.keyInput.on("keypress", (key) => {
-            if (key.name === "q" || (key.name === "c" && key.ctrl)) {
-                quit();
-                return;
-            }
-            const nextId = nextSelectedId(graph.nodes, state.selectedId, key.name);
-            if (nextId !== state.selectedId) {
-                state = { ...state, selectedId: nextId };
-                render();
-            }
-        });
-        writeCaptureFrame(graph, state.options.query);
-        renderer.start();
-        render();
-    });
-}
-async function runWithBun(options, snapshot) {
-    const scriptPath = process.argv[1];
-    if (scriptPath === undefined)
-        throw new Error("graph tui requires a CLI script path");
-    const args = [scriptPath, "graph", "tui", "--db", options.dbPath];
-    if (options.query !== undefined)
-        args.push("--query", options.query);
-    await new Promise((resolve, reject) => {
-        const child = spawn("bun", args, {
-            stdio: "inherit",
-            env: { ...process.env, [SNAPSHOT_ENV]: JSON.stringify(snapshot) },
-        });
-        child.once("error", (error) => {
-            reject(new Error(`graph tui requires Bun for OpenTUI native FFI: ${error.message}`));
-        });
-        child.once("exit", (code, signal) => {
-            if (code === 0) {
-                resolve();
-                return;
-            }
-            reject(new Error(`graph tui OpenTUI runtime exited with ${signal ?? code ?? "unknown status"}`));
-        });
-    });
-}
-async function createGraphSnapshot(options) {
-    const { projectOntologyGraph } = await import("./ontologyGraph.js");
-    const graph = projectOntologyGraph({
-        dbPath: options.dbPath,
-        ...(options.query === undefined ? {} : { query: options.query }),
-    });
-    const details = graph.nodes
-        .map((node) => projectOntologyGraph({
-        dbPath: options.dbPath,
-        ...(options.query === undefined ? {} : { query: options.query }),
-        selectedId: node.id,
-    }).detail)
-        .filter((detail) => detail !== null);
-    return { graph, details };
-}
-function parseSnapshot(raw) {
-    if (raw === undefined)
-        return null;
-    const parsed = JSON.parse(raw);
-    if (!isGraphSnapshot(parsed))
-        throw new Error("invalid graph tui snapshot");
-    return parsed;
-}
-function isRecord(value) {
-    return value !== null && typeof value === "object";
-}
-function isGraphSnapshot(value) {
-    if (!isRecord(value))
-        return false;
-    return isRecord(value["graph"]) && Array.isArray(value["details"]);
-}
-function loadGraph(state) {
-    const selectedId = state.selectedId ?? state.snapshot.graph.detail?.id ?? state.snapshot.graph.nodes[0]?.id ?? null;
-    const detail = selectedId === null ? state.snapshot.graph.detail : (state.snapshot.details.find((item) => item.id === selectedId) ?? null);
-    return {
-        ...state.snapshot.graph,
-        nodes: state.snapshot.graph.nodes.map((node) => ({ ...node, selected: node.id === selectedId })),
-        detail,
-    };
-}
-function titleText(graph, query) {
-    const queryLabel = query === undefined ? "all concepts" : `query "${query}"`;
-    return `OMO Ontology Graph - ${queryLabel} - ${graph.nodes.length} nodes / ${graph.edges.length} edges`;
-}
-function nodesContent(graph) {
-    if (graph.nodes.length === 0)
-        return graph.message ?? "No ontology graph data is available yet.";
-    const edges = graph.edges.map((edge) => `  ${edge.sourceId} -> ${edge.targetId} [${edge.label}]`);
-    return [...graph.nodes.map((node) => nodeLine(node)), "", "Relations", ...(edges.length === 0 ? ["  none in current filter"] : edges)].join("\n");
-}
-function detailContent(graph) {
-    if (graph.detail === null)
-        return graph.message ?? "No ontology graph data is available yet.";
-    const detail = graph.detail;
-    return [
-        `Label: ${detail.label}`,
-        `Kind: ${detail.kind}`,
-        `Retention: ${classCode(detail.retentionClass)} ${detail.retentionClass}`,
-        `Score: ${detail.scoreLabel}`,
-        `Refs: ${detail.refCount}`,
-        `Projects: ${detail.projectSpread}`,
-        `First seen: ${detail.firstSeen ?? "unknown"}`,
-        `Last seen: ${detail.lastSeen ?? "unknown"}`,
-        `Project: ${detail.project.repoRoot}`,
-        `Remote: ${detail.project.gitRemote ?? "none"}`,
-        "",
-        "Description:",
-        detail.description ?? "none",
-        "",
-        `Aliases: ${detail.aliases.length === 0 ? "none" : detail.aliases.join(", ")}`,
-    ].join("\n");
-}
-function writeCaptureFrame(graph, query) {
-    process.stdout.write([
-        titleText(graph, query),
-        "",
-        "Nodes",
-        nodesContent(graph),
-        "",
-        "Detail",
-        detailContent(graph),
-        "",
-        "Legend: D durable, W working, T temporary, E ephemeral",
-        "",
-    ].join("\n"));
-}
-function nodeLine(node) {
-    const marker = node.selected ? ">" : " ";
-    return `${marker} ${classCode(node.retentionClass)} ${node.label} (${node.kind}, ${node.scoreLabel}, refs ${node.refCount})`;
-}
-function classCode(retentionClass) {
-    const normalized = retentionClass.toLowerCase();
-    if (normalized === "durable")
-        return "D";
-    if (normalized === "temporary")
-        return "T";
-    if (normalized === "ephemeral")
-        return "E";
-    return "W";
-}
-function nextSelectedId(nodes, selectedId, keyName) {
-    if (nodes.length === 0)
-        return null;
-    const currentIndex = Math.max(0, nodes.findIndex((node) => node.id === selectedId));
-    const delta = keyName === "up" ? -1 : keyName === "down" || keyName === "tab" ? 1 : 0;
-    if (delta === 0)
-        return selectedId;
-    const nextIndex = (currentIndex + delta + nodes.length) % nodes.length;
-    return nodes[nextIndex]?.id ?? selectedId;
-}

package/dist/mcpOntologyTools.js

@@ -1,117 +0,0 @@
-import { z } from "zod";
-import { applyConceptExtraction, extractConceptCandidates } from "./conceptExtraction.js";
-import { listGlobalMemory, migrateToGlobalMemory, scanForMemoryDbs } from "./globalMemory.js";
-import { memoryPaths } from "./memoryReport.js";
-import { createDurableMemory, listOntologyRows, supersedeDurableMemory, updateDurableRetention } from "./ontologyCore.js";
-import { resolveProjectContext } from "./projectContext.js";
-import { recomputeRetentionScores } from "./retentionRecompute.js";
-const retentionClassSchema = z.enum(["forget", "temporary", "working", "durable", "permanent"]);
-const nonBlankStringSchema = z.string().trim().min(1);
-export function registerGlobalOntologyTools(server) {
-    server.registerTool("memory_global_scan", {
-        title: "Scan Global OMO Memory Sources",
-        description: "Explicitly scan a filesystem root for local OMO memory SQLite databases without importing them.",
-        inputSchema: { rootPath: nonBlankStringSchema },
-    }, async ({ rootPath }) => jsonResult(scanForMemoryDbs(rootPath)));
-    server.registerTool("memory_global_migrate", {
-        title: "Migrate OMO Memory To Global SQLite",
-        description: "Explicitly create or update a global OMO memory SQLite database from discovered local memory databases.",
-        inputSchema: { rootPath: nonBlankStringSchema, globalDbPath: nonBlankStringSchema },
-    }, async ({ rootPath, globalDbPath }) => jsonResult(migrateToGlobalMemory({ rootPath, globalDbPath })));
-    server.registerTool("memory_global_list", {
-        title: "List Global OMO Memory",
-        description: "List sources and counts from an explicit global OMO memory SQLite database.",
-        inputSchema: { globalDbPath: nonBlankStringSchema },
-    }, async ({ globalDbPath }) => jsonResult(listGlobalMemory(globalDbPath)));
-    registerOntologyTools(server);
-}
-function registerOntologyTools(server) {
-    server.registerTool("memory_ontology_candidates", {
-        title: "Extract OMO Ontology Candidates",
-        description: "Return deterministic ontology candidate labels from a short event summary without writing rows.",
-        inputSchema: { summary: nonBlankStringSchema, eventType: nonBlankStringSchema.optional() },
-    }, async ({ summary, eventType }) => jsonResult({ candidates: extractConceptCandidates(summary, eventType) }));
-    server.registerTool("memory_ontology_extract", {
-        title: "Write OMO Ontology Extraction",
-        description: "Explicitly extract concepts from a short event summary and write event-to-concept references.",
-        inputSchema: {
-            sourceEventId: nonBlankStringSchema,
-            summary: nonBlankStringSchema,
-            eventType: nonBlankStringSchema.optional(),
-        },
-    }, async ({ sourceEventId, summary, eventType }) => jsonResult(applyConceptExtraction(memoryPaths().dbPath, resolveProjectContext(), sourceEventId, summary, eventType)));
-    server.registerTool("memory_ontology_score", {
-        title: "Recompute OMO Ontology Scores",
-        description: "Explicitly recompute ontology retention scores for the local OMO memory SQLite database.",
-        inputSchema: { nowIso: z.string().datetime().optional() },
-    }, async ({ nowIso }) => jsonResult(recomputeRetentionScores({ dbPath: memoryPaths().dbPath, nowIso: nowIso ?? new Date().toISOString() })));
-    server.registerTool("memory_ontology_promote", {
-        title: "Promote OMO Durable Memory",
-        description: "Explicitly promote a summarized memory into durable ontology storage.",
-        inputSchema: {
-            type: nonBlankStringSchema,
-            summary: nonBlankStringSchema,
-            body: nonBlankStringSchema.optional(),
-            sourceEventId: nonBlankStringSchema.optional(),
-            sourceHandoffId: nonBlankStringSchema.optional(),
-            confidence: z.number().min(0).max(1).optional(),
-            status: nonBlankStringSchema.optional(),
-            retentionClass: retentionClassSchema.optional(),
-        },
-    }, async ({ type, summary, body, sourceEventId, sourceHandoffId, confidence, status, retentionClass }) => jsonResult(createDurableMemory(memoryPaths().dbPath, resolveProjectContext(), {
-        type,
-        summary,
-        ...(body === undefined ? {} : { body }),
-        ...(sourceEventId === undefined ? {} : { sourceEventId }),
-        ...(sourceHandoffId === undefined ? {} : { sourceHandoffId }),
-        ...(confidence === undefined ? {} : { confidence }),
-        ...(status === undefined ? {} : { status }),
-        ...(retentionClass === undefined ? {} : { retentionClass }),
-    })));
-    server.registerTool("memory_ontology_demote", {
-        title: "Demote OMO Durable Memory",
-        description: "Explicitly change the retention class for a durable ontology memory.",
-        inputSchema: { durableId: nonBlankStringSchema, retentionClass: retentionClassSchema.default("temporary") },
-    }, async ({ durableId, retentionClass }) => jsonResult(updateDurableRetention(memoryPaths().dbPath, resolveProjectContext(), durableId, { retentionClass })));
-    server.registerTool("memory_ontology_supersede", {
-        title: "Supersede OMO Durable Memory",
-        description: "Explicitly mark a durable memory superseded and create a successor memory.",
-        inputSchema: {
-            durableId: nonBlankStringSchema,
-            reason: nonBlankStringSchema.optional(),
-            newSummary: nonBlankStringSchema.optional(),
-        },
-    }, async ({ durableId, reason, newSummary }) => jsonResult(supersedeDurableMemory(memoryPaths().dbPath, resolveProjectContext(), durableId, {
-        ...(reason === undefined ? {} : { reason }),
-        ...(newSummary === undefined ? {} : { newSummary }),
-    })));
-    server.registerTool("memory_ontology_recall", {
-        title: "Recall OMO Ontology Rows",
-        description: "Explicitly recall ontology concepts and durable memories matching a query.",
-        inputSchema: { query: nonBlankStringSchema, limit: z.number().int().positive().max(100).default(10) },
-    }, async ({ query, limit }) => jsonResult(recallOntology(query, limit)));
-}
-function jsonResult(value) {
-    return { content: [{ type: "text", text: JSON.stringify(value, null, 2) }] };
-}
-function recallOntology(query, limit) {
-    const rows = listOntologyRows(memoryPaths().dbPath, resolveProjectContext());
-    const normalizedQuery = query.toLowerCase();
-    const queryTerms = normalizedQuery.split(/[^a-z0-9_-]+/).filter((term) => term.length >= 3);
-    return {
-        concepts: rows.concepts.filter((concept) => matchesConcept(concept, normalizedQuery, queryTerms)).slice(0, limit),
-        durableMemories: rows.durableMemories.filter((memory) => matchesDurableMemory(memory, normalizedQuery, queryTerms)).slice(0, limit),
-    };
-}
-function matchesConcept(concept, normalizedQuery, queryTerms) {
-    return matchesText([concept.label, concept.description ?? "", concept.aliasesJson], normalizedQuery, queryTerms);
-}
-function matchesDurableMemory(memory, normalizedQuery, queryTerms) {
-    return matchesText([memory.type, memory.summary, memory.body ?? ""], normalizedQuery, queryTerms);
-}
-function matchesText(values, normalizedQuery, queryTerms) {
-    const normalizedValues = values.map((value) => value.toLowerCase());
-    if (normalizedValues.some((value) => value.includes(normalizedQuery)))
-        return true;
-    return queryTerms.length > 0 && queryTerms.every((term) => normalizedValues.some((value) => value.includes(term)));
-}

package/dist/ontologyCore.js

@@ -1,142 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { upsertProject } from "./memory.js";
-import { migrate, openMemoryDb } from "./memoryDb.js";
-import { redactSecrets } from "./privacy.js";
-export { listOntologyRows } from "./ontologyQueries.js";
-export { supersedeDurableMemory } from "./ontologySupersede.js";
-function nowIso() {
-    return new Date().toISOString();
-}
-function normalizeLabel(label) {
-    return label.trim().toLowerCase();
-}
-export function upsertConcept(dbPath, project, input) {
-    const db = openMemoryDb(dbPath);
-    try {
-        migrate(db);
-        upsertProject(db, project);
-        const label = normalizeLabel(input.label);
-        const now = nowIso();
-        const existing = db.prepare(`SELECT id FROM concepts WHERE project_id = ? AND label = ? LIMIT 1`).get(project.id, label);
-        if (existing?.id) {
-            db.prepare("UPDATE concepts SET last_seen = ?, updated_at = ? WHERE id = ? AND project_id = ?").run(now, now, existing.id, project.id);
-            const row = db
-                .prepare(`SELECT id, kind, label, description, aliases_json AS aliasesJson, payload_json AS payloadJson,
-             valid_from AS validFrom, valid_to AS validTo, created_at AS createdAt, updated_at AS updatedAt,
-             COALESCE(score, 0) AS score, COALESCE(retention_class, 'working') AS retentionClass,
-             COALESCE(manual_pin, 0) AS manualPin, COALESCE(ref_count, 0) AS refCount,
-             COALESCE(project_spread, 1) AS projectSpread, first_seen AS firstSeen, last_seen AS lastSeen
-            FROM concepts WHERE id = ?`)
-                .get(existing.id);
-            return row;
-        }
-        const id = randomUUID();
-        const score = input.score ?? 0;
-        const retentionClass = input.retentionClass ?? "working";
-        const manualPin = input.manualPin ?? 0;
-        const created = now;
-        db.prepare(`
-      INSERT INTO concepts (
-        id, project_id, kind, label, description, aliases_json, payload_json,
-        valid_from, valid_to, created_at, updated_at,
-        score, retention_class, manual_pin, ref_count, project_spread, first_seen, last_seen
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(id, project.id, input.kind, label, input.description ?? null, "[]", "{}", null, null, created, created, score, retentionClass, manualPin, 0, 1, created, created);
-        const row = db
-            .prepare(`SELECT id, kind, label, description, aliases_json AS aliasesJson, payload_json AS payloadJson,
-          valid_from AS validFrom, valid_to AS validTo, created_at AS createdAt, updated_at AS updatedAt,
-          COALESCE(score, 0) AS score, COALESCE(retention_class, 'working') AS retentionClass,
-          COALESCE(manual_pin, 0) AS manualPin, COALESCE(ref_count, 0) AS refCount,
-          COALESCE(project_spread, 1) AS projectSpread, first_seen AS firstSeen, last_seen AS lastSeen
-         FROM concepts WHERE id = ?`)
-            .get(id);
-        return row;
-    }
-    finally {
-        db.close();
-    }
-}
-export function createDurableMemory(dbPath, project, input) {
-    const db = openMemoryDb(dbPath);
-    try {
-        migrate(db);
-        upsertProject(db, project);
-        const id = randomUUID();
-        const created = nowIso();
-        const redactedSummary = redactSecrets(input.summary);
-        const redactedBody = input.body == null ? null : redactSecrets(input.body);
-        const status = input.status ?? "active";
-        const retentionClass = input.retentionClass ?? "durable";
-        const confidence = input.confidence ?? 0;
-        db.prepare(`
-      INSERT INTO durable_memories (
-        id, project_id, type, summary, body, source_event_id, source_handoff_id,
-        confidence, status, retention_class, valid_from, valid_to, created_at, updated_at
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(id, project.id, input.type, redactedSummary, redactedBody, input.sourceEventId ?? null, input.sourceHandoffId ?? null, confidence, status, retentionClass, null, null, created, created);
-        const row = db
-            .prepare(`SELECT id, type, summary, body, source_event_id AS sourceEventId, source_handoff_id AS sourceHandoffId,
-          confidence, status, COALESCE(retention_class, 'durable') AS retentionClass,
-          valid_from AS validFrom, valid_to AS validTo, created_at AS createdAt, updated_at AS updatedAt
-         FROM durable_memories WHERE id = ?`)
-            .get(id);
-        return row;
-    }
-    finally {
-        db.close();
-    }
-}
-export function recordMemoryReference(dbPath, project, input) {
-    const db = openMemoryDb(dbPath);
-    try {
-        migrate(db);
-        upsertProject(db, project);
-        const id = randomUUID();
-        const created = nowIso();
-        const refKind = input.refKind ?? "mentions";
-        const weight = input.weight ?? 1;
-        const inserted = db
-            .prepare(`
-      INSERT INTO memory_references (
-        id, project_id, source_type, source_id, target_type, target_id, ref_kind, weight, created_at
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-      ON CONFLICT(project_id, source_type, source_id, target_type, target_id, ref_kind) DO NOTHING
-    `)
-            .run(id, project.id, input.sourceType, input.sourceId, input.targetType, input.targetId, refKind, weight, created);
-        if (inserted.changes > 0 && input.targetType === "concept") {
-            db.prepare("UPDATE concepts SET ref_count = COALESCE(ref_count, 0) + 1, last_seen = ?, updated_at = ? WHERE id = ? AND project_id = ?").run(created, created, input.targetId, project.id);
-        }
-        const row = db
-            .prepare(`SELECT id, source_type AS sourceType, source_id AS sourceId, target_type AS targetType, target_id AS targetId,
-          ref_kind AS refKind, weight, created_at AS createdAt
-         FROM memory_references
-         WHERE project_id = ? AND source_type = ? AND source_id = ? AND target_type = ? AND target_id = ? AND ref_kind = ?`)
-            .get(project.id, input.sourceType, input.sourceId, input.targetType, input.targetId, refKind);
-        return row;
-    }
-    finally {
-        db.close();
-    }
-}
-export function updateDurableRetention(dbPath, project, durableId, update) {
-    const db = openMemoryDb(dbPath);
-    try {
-        migrate(db);
-        const existing = db.prepare("SELECT retention_class FROM durable_memories WHERE id = ? AND project_id = ?").get(durableId, project.id);
-        if (!existing) {
-            throw new Error("durable memory not found for project");
-        }
-        const now = nowIso();
-        db.prepare("UPDATE durable_memories SET retention_class = COALESCE(?, retention_class), updated_at = ? WHERE id = ? AND project_id = ?").run(update.retentionClass ?? null, now, durableId, project.id);
-        const row = db
-            .prepare(`SELECT id, type, summary, body, source_event_id AS sourceEventId, source_handoff_id AS sourceHandoffId,
-          confidence, status, COALESCE(retention_class, 'durable') AS retentionClass,
-          valid_from AS validFrom, valid_to AS validTo, created_at AS createdAt, updated_at AS updatedAt
-         FROM durable_memories WHERE id = ?`)
-            .get(durableId);
-        return row;
-    }
-    finally {
-        db.close();
-    }
-}

package/dist/ontologyGraph.js

@@ -1,173 +0,0 @@
-import { migrate, openMemoryDb } from "./memoryDb.js";
-import { redactSecrets, sanitizeGitRemote } from "./privacy.js";
-function isRecord(value) {
-    return value !== null && typeof value === "object";
-}
-function text(value) {
-    return typeof value === "string" ? value : String(value ?? "");
-}
-function nullableText(value) {
-    return value === null || value === undefined ? null : text(value);
-}
-function parseAliases(value) {
-    if (typeof value !== "string")
-        return [];
-    try {
-        const parsed = JSON.parse(value);
-        if (!Array.isArray(parsed))
-            return [];
-        return parsed.filter((item) => typeof item === "string").map(redactSecrets);
-    }
-    catch (error) {
-        if (error instanceof SyntaxError)
-            return [];
-        throw error;
-    }
-}
-function numberValue(value) {
-    return typeof value === "number" && Number.isFinite(value) ? value : Number(value ?? 0);
-}
-function projectFrom(row) {
-    return {
-        id: row.projectId,
-        repoRoot: redactSecrets(row.repoRoot),
-        gitRemote: sanitizeGitRemote(row.gitRemote),
-    };
-}
-function parseConceptRow(value) {
-    if (!isRecord(value)) {
-        throw new Error("invalid concept row");
-    }
-    return {
-        id: text(value["id"]),
-        projectId: text(value["projectId"]),
-        kind: text(value["kind"]),
-        label: text(value["label"]),
-        description: nullableText(value["description"]),
-        aliases: parseAliases(value["aliasesJson"]),
-        score: numberValue(value["score"]),
-        retentionClass: text(value["retentionClass"]),
-        refCount: numberValue(value["refCount"]),
-        projectSpread: numberValue(value["projectSpread"]),
-        firstSeen: nullableText(value["firstSeen"]),
-        lastSeen: nullableText(value["lastSeen"]),
-        repoRoot: text(value["repoRoot"]),
-        gitRemote: nullableText(value["gitRemote"]),
-    };
-}
-function parseRelationRow(value) {
-    if (!isRecord(value)) {
-        throw new Error("invalid relation row");
-    }
-    return {
-        id: text(value["id"]),
-        projectId: text(value["projectId"]),
-        sourceId: text(value["sourceId"]),
-        targetId: text(value["targetId"]),
-        relation: text(value["relation"]),
-        weight: numberValue(value["weight"]),
-        repoRoot: text(value["repoRoot"]),
-        gitRemote: nullableText(value["gitRemote"]),
-    };
-}
-function matchesQuery(row, query) {
-    const haystack = `${row.label}\n${row.description ?? ""}\n${row.aliases.join("\n")}`.toLowerCase();
-    return haystack.includes(query);
-}
-function toNode(row, selectedId) {
-    const score = Math.round(row.score);
-    const retentionClass = redactSecrets(row.retentionClass);
-    return {
-        id: row.id,
-        kind: redactSecrets(row.kind),
-        label: redactSecrets(row.label),
-        description: row.description === null ? null : redactSecrets(row.description),
-        aliases: row.aliases,
-        retentionClass,
-        score,
-        scoreLabel: `${score} ${retentionClass}`,
-        refCount: Math.round(row.refCount),
-        projectSpread: Math.round(row.projectSpread),
-        project: projectFrom(row),
-        selected: selectedId === row.id,
-    };
-}
-function toDetail(row) {
-    const score = Math.round(row.score);
-    const retentionClass = redactSecrets(row.retentionClass);
-    return {
-        id: row.id,
-        label: redactSecrets(row.label),
-        kind: redactSecrets(row.kind),
-        description: row.description === null ? null : redactSecrets(row.description),
-        aliases: row.aliases,
-        retentionClass,
-        score,
-        scoreLabel: `${score} ${retentionClass}`,
-        refCount: Math.round(row.refCount),
-        projectSpread: Math.round(row.projectSpread),
-        firstSeen: row.firstSeen,
-        lastSeen: row.lastSeen,
-        project: projectFrom(row),
-    };
-}
-function toEdge(row) {
-    const weight = Number(row.weight.toFixed(2));
-    const relation = redactSecrets(row.relation);
-    return {
-        id: row.id,
-        sourceId: row.sourceId,
-        targetId: row.targetId,
-        relation,
-        label: `${relation} ${weight.toFixed(2)}`,
-        weight,
-        project: projectFrom(row),
-    };
-}
-export function projectOntologyGraph(options) {
-    const db = openMemoryDb(options.dbPath);
-    try {
-        migrate(db);
-        const query = options.query?.trim().toLowerCase() ?? "";
-        const conceptRows = db
-            .prepare(`
-        SELECT c.id, c.project_id AS projectId, c.kind, c.label, c.description, c.aliases_json AS aliasesJson,
-          COALESCE(c.score, 0) AS score, COALESCE(c.retention_class, 'working') AS retentionClass,
-          COALESCE(c.ref_count, 0) AS refCount, COALESCE(c.project_spread, 1) AS projectSpread,
-          c.first_seen AS firstSeen, c.last_seen AS lastSeen,
-          p.repo_root AS repoRoot, p.git_remote AS gitRemote
-        FROM concepts c
-        JOIN projects p ON p.id = c.project_id
-        WHERE c.valid_to IS NULL
-        ORDER BY lower(c.label) ASC, c.id ASC
-      `)
-            .all()
-            .map(parseConceptRow)
-            .filter((row) => query === "" || matchesQuery(row, query));
-        const conceptIds = new Set(conceptRows.map((row) => row.id));
-        const selectedId = options.selectedId && conceptIds.has(options.selectedId) ? options.selectedId : (conceptRows[0]?.id ?? null);
-        const nodes = conceptRows.map((row) => toNode(row, selectedId));
-        const selectedRow = selectedId === null ? undefined : conceptRows.find((row) => row.id === selectedId);
-        const relationRows = db
-            .prepare(`
-        SELECT r.id, r.project_id AS projectId, r.source_id AS sourceId, r.target_id AS targetId,
-          r.relation, COALESCE(r.weight, 1) AS weight, p.repo_root AS repoRoot, p.git_remote AS gitRemote
-        FROM relations r
-        JOIN projects p ON p.id = r.project_id
-        WHERE r.source_type = 'concept' AND r.target_type = 'concept' AND r.valid_to IS NULL
-        ORDER BY lower(r.relation) ASC, r.id ASC
-      `)
-            .all()
-            .map(parseRelationRow)
-            .filter((row) => conceptIds.has(row.sourceId) && conceptIds.has(row.targetId));
-        return {
-            nodes,
-            edges: relationRows.map(toEdge),
-            detail: selectedRow === undefined ? null : toDetail(selectedRow),
-            message: nodes.length === 0 ? "No ontology graph data is available yet." : null,
-        };
-    }
-    finally {
-        db.close();
-    }
-}