omo-memory 0.1.11 → 0.1.13

package/dist/globalMemory.js

@@ -0,0 +1,162 @@
+import { mkdirSync, readdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import Database from "better-sqlite3";
+import { importCandidates, listGlobalMemoryFromDb } from "./globalMemoryImport.js";
+import { migrate } from "./memoryDb.js";
+import { resolveProjectContext } from "./projectContext.js";
+const STATE_DB_SUFFIX = join(".omo", "memory", "state.sqlite");
+const REQUIRED_TABLES = ["schema_meta", "projects", "events"];
+export function initGlobalMemory(globalDbPath) {
+    mkdirSync(dirname(globalDbPath), { recursive: true });
+    const db = new Database(globalDbPath);
+    try {
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS sources (
+        id TEXT PRIMARY KEY,
+        db_path TEXT UNIQUE NOT NULL,
+        schema_version INTEGER NOT NULL,
+        imported_at TEXT NOT NULL,
+        last_seen_at TEXT NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS global_projects (
+        id TEXT PRIMARY KEY,
+        source_id TEXT NOT NULL,
+        source_project_id TEXT NOT NULL,
+        repo_root TEXT NOT NULL,
+        git_remote TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        last_seen_at TEXT NOT NULL,
+        UNIQUE(source_id, source_project_id)
+      );
+      CREATE TABLE IF NOT EXISTS global_sessions (
+        id TEXT PRIMARY KEY,
+        source_id TEXT NOT NULL,
+        source_session_id TEXT NOT NULL,
+        source_project_id TEXT NOT NULL,
+        host TEXT NOT NULL,
+        adapter TEXT NOT NULL,
+        started_at TEXT NOT NULL,
+        ended_at TEXT,
+        git_branch TEXT,
+        git_head TEXT,
+        UNIQUE(source_id, source_session_id)
+      );
+      CREATE TABLE IF NOT EXISTS global_events (
+        id TEXT PRIMARY KEY,
+        source_id TEXT NOT NULL,
+        source_event_id TEXT NOT NULL,
+        source_session_id TEXT NOT NULL,
+        source_project_id TEXT NOT NULL,
+        type TEXT NOT NULL,
+        summary TEXT NOT NULL,
+        payload_json TEXT,
+        created_at TEXT NOT NULL,
+        UNIQUE(source_id, source_event_id)
+      );
+      CREATE TABLE IF NOT EXISTS global_handoffs (
+        id TEXT PRIMARY KEY,
+        source_id TEXT NOT NULL,
+        source_handoff_id TEXT NOT NULL,
+        source_project_id TEXT NOT NULL,
+        source_session_id TEXT,
+        summary_md TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        UNIQUE(source_id, source_handoff_id)
+      );
+    `);
+        migrate(db);
+        return { dbPath: globalDbPath };
+    }
+    finally {
+        db.close();
+    }
+}
+export function scanForMemoryDbs(rootPath) {
+    const candidates = [];
+    const skipped = [];
+    for (const dbPath of findStateDbs(rootPath)) {
+        const scan = scanSourceDb(dbPath);
+        if (scan.kind === "candidate")
+            candidates.push(scan.candidate);
+        else
+            skipped.push({ dbPath, reason: scan.reason });
+    }
+    return { candidates, skipped };
+}
+export function migrateToGlobalMemory(input) {
+    const scan = scanForMemoryDbs(input.rootPath);
+    initGlobalMemory(input.globalDbPath);
+    return importCandidates(input.globalDbPath, scan, resolveProjectContext());
+}
+export function listGlobalMemory(globalDbPath) {
+    return listGlobalMemoryFromDb(globalDbPath);
+}
+function findStateDbs(rootPath) {
+    const dbPaths = [];
+    const visit = (path) => {
+        let entries;
+        try {
+            entries = readdirSync(path, { withFileTypes: true });
+        }
+        catch (error) {
+            if (error instanceof Error)
+                return;
+            throw error;
+        }
+        for (const entry of entries) {
+            const entryPath = join(path, entry.name);
+            if (entry.isDirectory())
+                visit(entryPath);
+            else if (entry.isFile() && entryPath.endsWith(STATE_DB_SUFFIX))
+                dbPaths.push(entryPath);
+        }
+    };
+    visit(rootPath);
+    return dbPaths.sort();
+}
+function scanSourceDb(dbPath) {
+    let db;
+    try {
+        db = new Database(dbPath, { readonly: true, fileMustExist: true });
+    }
+    catch (error) {
+        if (error instanceof Error)
+            return { kind: "skipped", reason: error.message };
+        throw error;
+    }
+    try {
+        for (const tableName of REQUIRED_TABLES) {
+            if (!tableExists(db, tableName))
+                return { kind: "skipped", reason: `missing table ${tableName}` };
+        }
+        return {
+            kind: "candidate",
+            candidate: { dbPath, schemaVersion: readSchemaVersion(db), projectCount: readCount(db, "projects"), eventCount: readCount(db, "events") },
+        };
+    }
+    catch (error) {
+        if (error instanceof Error)
+            return { kind: "skipped", reason: error.message };
+        throw error;
+    }
+    finally {
+        db.close();
+    }
+}
+function tableExists(db, tableName) {
+    const row = db.prepare("SELECT COUNT(*) AS count FROM sqlite_master WHERE type = 'table' AND name = ?").get(tableName);
+    return row !== undefined && row.count === 1;
+}
+function readSchemaVersion(db) {
+    const row = db
+        .prepare("SELECT value FROM schema_meta WHERE key IN ('schema_version', 'version') ORDER BY CASE key WHEN 'schema_version' THEN 0 ELSE 1 END LIMIT 1")
+        .get();
+    if (row === undefined)
+        return 0;
+    const parsed = Number.parseInt(row.value, 10);
+    return Number.isFinite(parsed) ? parsed : 0;
+}
+function readCount(db, tableName) {
+    const row = db.prepare(`SELECT COUNT(*) AS count FROM ${tableName}`).get();
+    return row?.count ?? 0;
+}

package/dist/globalMemoryCanonical.js

@@ -0,0 +1,32 @@
+export function upsertAggregateProject(db, project) {
+    const now = new Date().toISOString();
+    db.prepare(`
+    INSERT INTO projects (id, repo_root, git_remote, created_at, last_seen_at)
+    VALUES (?, ?, ?, ?, ?)
+    ON CONFLICT(id) DO UPDATE SET repo_root = excluded.repo_root, git_remote = excluded.git_remote, last_seen_at = excluded.last_seen_at
+  `).run(project.id, project.repoRoot, project.gitRemote, now, now);
+}
+export function upsertCanonicalSession(db, sourceId, aggregateProjectId, row) {
+    db.prepare(`
+    INSERT INTO sessions (id, project_id, host, adapter, started_at, ended_at, git_branch, git_head)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(id) DO UPDATE SET host = excluded.host, adapter = excluded.adapter, ended_at = excluded.ended_at, git_branch = excluded.git_branch, git_head = excluded.git_head
+  `).run(globalRowId(sourceId, row.id), aggregateProjectId, row.host, row.adapter, row.startedAt, row.endedAt, row.gitBranch, row.gitHead);
+}
+export function upsertCanonicalEvent(db, sourceId, aggregateProjectId, row) {
+    db.prepare(`
+    INSERT INTO events (id, session_id, project_id, type, summary, payload_json, created_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(id) DO UPDATE SET session_id = excluded.session_id, type = excluded.type, summary = excluded.summary, payload_json = excluded.payload_json, created_at = excluded.created_at
+  `).run(globalRowId(sourceId, row.id), row.sessionId === null ? null : globalRowId(sourceId, row.sessionId), aggregateProjectId, row.type, row.summary, row.payloadJson, row.createdAt);
+}
+export function upsertCanonicalHandoff(db, sourceId, aggregateProjectId, row) {
+    db.prepare(`
+    INSERT INTO handoffs (id, project_id, session_id, summary_md, created_at)
+    VALUES (?, ?, ?, ?, ?)
+    ON CONFLICT(id) DO UPDATE SET session_id = excluded.session_id, summary_md = excluded.summary_md, created_at = excluded.created_at
+  `).run(globalRowId(sourceId, row.id), aggregateProjectId, row.sessionId === null ? null : globalRowId(sourceId, row.sessionId), row.summaryMd, row.createdAt);
+}
+function globalRowId(sourceId, sourceRowId) {
+    return `${sourceId}:${sourceRowId}`;
+}

package/dist/globalMemoryImport.js

@@ -0,0 +1,194 @@
+import { createHash } from "node:crypto";
+import Database from "better-sqlite3";
+import { upsertAggregateProject, upsertCanonicalEvent, upsertCanonicalHandoff, upsertCanonicalSession, } from "./globalMemoryCanonical.js";
+import { redactSecrets, sanitizeGitRemote } from "./privacy.js";
+const GLOBAL_TABLES = ["sources", "global_projects", "global_sessions", "global_events", "global_handoffs"];
+export function importCandidates(globalDbPath, scan, aggregateProject) {
+    const global = new Database(globalDbPath);
+    const skipped = [...scan.skipped];
+    try {
+        const before = readGlobalCounts(global);
+        const imported = { sources: 0, projects: 0, sessions: 0, events: 0, handoffs: 0 };
+        for (const candidate of scan.candidates) {
+            const result = importCandidate(global, candidate, aggregateProject);
+            if (result.kind === "skipped") {
+                skipped.push({ dbPath: candidate.dbPath, reason: result.reason });
+            }
+            else {
+                imported.sources += result.imported.sources;
+                imported.projects += result.imported.projects;
+                imported.sessions += result.imported.sessions;
+                imported.events += result.imported.events;
+                imported.handoffs += result.imported.handoffs;
+            }
+        }
+        return { sources: scan.candidates.length - (skipped.length - scan.skipped.length), imported, before, after: readGlobalCounts(global), skipped };
+    }
+    finally {
+        global.close();
+    }
+}
+export function listGlobalMemoryFromDb(globalDbPath) {
+    const db = new Database(globalDbPath, { readonly: true, fileMustExist: true });
+    try {
+        return {
+            sources: db
+                .prepare("SELECT id, db_path AS dbPath, schema_version AS schemaVersion, imported_at AS importedAt, last_seen_at AS lastSeenAt FROM sources ORDER BY db_path ASC")
+                .all(),
+            counts: readGlobalCounts(db),
+        };
+    }
+    finally {
+        db.close();
+    }
+}
+function importCandidate(global, candidate, aggregateProject) {
+    let source;
+    try {
+        source = new Database(candidate.dbPath, { readonly: true, fileMustExist: true });
+    }
+    catch (error) {
+        if (error instanceof Error)
+            return { kind: "skipped", reason: error.message };
+        throw error;
+    }
+    try {
+        const sourceId = sourceIdForPath(candidate.dbPath);
+        const now = new Date().toISOString();
+        const rows = {
+            projects: readProjects(source).map(redactProjectRow),
+            sessions: readSessions(source),
+            events: readEvents(source).map(redactEventRow),
+            handoffs: readHandoffs(source).map(redactHandoffRow),
+        };
+        const write = global.transaction(() => {
+            const counts = { sources: 0, projects: 0, sessions: 0, events: 0, handoffs: 0 };
+            upsertAggregateProject(global, aggregateProject);
+            counts.sources += global
+                .prepare("INSERT INTO sources (id, db_path, schema_version, imported_at, last_seen_at) VALUES (?, ?, ?, ?, ?) ON CONFLICT(db_path) DO UPDATE SET schema_version = excluded.schema_version, last_seen_at = excluded.last_seen_at")
+                .run(sourceId, candidate.dbPath, candidate.schemaVersion, now, now).changes;
+            for (const row of rows.projects)
+                counts.projects += upsertProject(global, sourceId, row);
+            for (const row of rows.sessions)
+                counts.sessions += upsertSession(global, sourceId, row);
+            for (const row of rows.events)
+                counts.events += upsertEvent(global, sourceId, row);
+            for (const row of rows.handoffs)
+                counts.handoffs += upsertHandoff(global, sourceId, row);
+            for (const row of rows.sessions)
+                upsertCanonicalSession(global, sourceId, aggregateProject.id, row);
+            for (const row of rows.events)
+                upsertCanonicalEvent(global, sourceId, aggregateProject.id, row);
+            for (const row of rows.handoffs)
+                upsertCanonicalHandoff(global, sourceId, aggregateProject.id, row);
+            return counts;
+        });
+        return { kind: "imported", imported: write() };
+    }
+    catch (error) {
+        if (error instanceof Error)
+            return { kind: "skipped", reason: error.message };
+        throw error;
+    }
+    finally {
+        source.close();
+    }
+}
+function readProjects(db) {
+    return db
+        .prepare("SELECT id, repo_root AS repoRoot, git_remote AS gitRemote, created_at AS createdAt, last_seen_at AS lastSeenAt FROM projects ORDER BY id ASC")
+        .all();
+}
+function readSessions(db) {
+    if (!tableExists(db, "sessions"))
+        return [];
+    return db
+        .prepare("SELECT id, project_id AS projectId, host, adapter, started_at AS startedAt, ended_at AS endedAt, git_branch AS gitBranch, git_head AS gitHead FROM sessions ORDER BY id ASC")
+        .all();
+}
+function readEvents(db) {
+    return db
+        .prepare("SELECT id, session_id AS sessionId, project_id AS projectId, type, summary, payload_json AS payloadJson, created_at AS createdAt FROM events ORDER BY id ASC")
+        .all();
+}
+function readHandoffs(db) {
+    if (!tableExists(db, "handoffs"))
+        return [];
+    return db
+        .prepare("SELECT id, project_id AS projectId, session_id AS sessionId, summary_md AS summaryMd, created_at AS createdAt FROM handoffs ORDER BY id ASC")
+        .all();
+}
+function upsertProject(db, sourceId, row) {
+    return db
+        .prepare(`
+      INSERT INTO global_projects (id, source_id, source_project_id, repo_root, git_remote, created_at, last_seen_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(source_id, source_project_id) DO UPDATE SET repo_root = excluded.repo_root, git_remote = excluded.git_remote, last_seen_at = excluded.last_seen_at
+    `)
+        .run(globalRowId(sourceId, row.id), sourceId, row.id, row.repoRoot, row.gitRemote ?? "", row.createdAt, row.lastSeenAt).changes;
+}
+function redactProjectRow(row) {
+    return { ...row, gitRemote: sanitizeGitRemote(row.gitRemote) };
+}
+function redactEventRow(row) {
+    return {
+        ...row,
+        summary: redactSecrets(row.summary),
+        payloadJson: row.payloadJson === null ? null : redactSecrets(row.payloadJson),
+    };
+}
+function redactHandoffRow(row) {
+    return { ...row, summaryMd: redactSecrets(row.summaryMd) };
+}
+function upsertSession(db, sourceId, row) {
+    return db
+        .prepare(`
+      INSERT INTO global_sessions (id, source_id, source_session_id, source_project_id, host, adapter, started_at, ended_at, git_branch, git_head)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(source_id, source_session_id) DO UPDATE SET source_project_id = excluded.source_project_id, host = excluded.host, adapter = excluded.adapter, ended_at = excluded.ended_at, git_branch = excluded.git_branch, git_head = excluded.git_head
+    `)
+        .run(globalRowId(sourceId, row.id), sourceId, row.id, row.projectId, row.host, row.adapter, row.startedAt, row.endedAt, row.gitBranch, row.gitHead).changes;
+}
+function upsertEvent(db, sourceId, row) {
+    return db
+        .prepare(`
+      INSERT INTO global_events (id, source_id, source_event_id, source_session_id, source_project_id, type, summary, payload_json, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(source_id, source_event_id) DO UPDATE SET source_session_id = excluded.source_session_id, source_project_id = excluded.source_project_id, type = excluded.type, summary = excluded.summary, payload_json = excluded.payload_json, created_at = excluded.created_at
+    `)
+        .run(globalRowId(sourceId, row.id), sourceId, row.id, row.sessionId ?? "", row.projectId, row.type, row.summary, row.payloadJson, row.createdAt).changes;
+}
+function upsertHandoff(db, sourceId, row) {
+    return db
+        .prepare(`
+      INSERT INTO global_handoffs (id, source_id, source_handoff_id, source_project_id, source_session_id, summary_md, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(source_id, source_handoff_id) DO UPDATE SET source_project_id = excluded.source_project_id, source_session_id = excluded.source_session_id, summary_md = excluded.summary_md, created_at = excluded.created_at
+    `)
+        .run(globalRowId(sourceId, row.id), sourceId, row.id, row.projectId, row.sessionId, row.summaryMd, row.createdAt).changes;
+}
+function readGlobalCounts(db) {
+    if (!GLOBAL_TABLES.every((tableName) => tableExists(db, tableName)))
+        return { sources: 0, projects: 0, sessions: 0, events: 0, handoffs: 0 };
+    return {
+        sources: readGlobalCount(db, "sources"),
+        projects: readGlobalCount(db, "global_projects"),
+        sessions: readGlobalCount(db, "global_sessions"),
+        events: readGlobalCount(db, "global_events"),
+        handoffs: readGlobalCount(db, "global_handoffs"),
+    };
+}
+function readGlobalCount(db, tableName) {
+    const row = db.prepare(`SELECT COUNT(*) AS count FROM ${tableName}`).get();
+    return row?.count ?? 0;
+}
+function tableExists(db, tableName) {
+    const row = db.prepare("SELECT COUNT(*) AS count FROM sqlite_master WHERE type = 'table' AND name = ?").get(tableName);
+    return row !== undefined && row.count === 1;
+}
+function sourceIdForPath(dbPath) {
+    return `src_${createHash("sha256").update(dbPath).digest("hex").slice(0, 24)}`;
+}
+function globalRowId(sourceId, sourceRowId) {
+    return `${sourceId}:${sourceRowId}`;
+}

package/dist/graphTui.js

@@ -0,0 +1,239 @@
+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;
+}