akm-cli 0.7.5 → 0.8.0-rc2

package/dist/indexer/graph-boost.js

@@ -2,7 +2,7 @@
  * Search-time graph-boost integration for the `akm index` graph pass (#207).
  *
  * This module is the consumer half of the graph-extraction pass. It loads
- * the persisted `graph.json` (when present) and exposes a single helper,
+ * the persisted graph snapshot from SQLite and exposes a single helper,
  * {@link computeGraphBoost}, that the existing FTS5+boosts loop in
  * `src/indexer/db-search.ts` calls per-entry to obtain an additive boost
  * value.
@@ -13,12 +13,26 @@
  *   - There is no second `SearchHit` scorer. `searchDatabase` continues to
  *     own ranking; this module just answers "what additive boost does the
  *     graph contribute for this (query, entry) pair?".
- *   - Missing/stale/unparseable `graph.json` → boost is `0`. The pipeline
+ *   - Missing graph rows → boost is `0`. The pipeline
  *     degrades gracefully to its non-graph behaviour, exactly as today.
  */
-import fs from "node:fs";
-import { warn } from "../core/warn";
-import { GRAPH_FILE_SCHEMA_VERSION, getGraphFilePath } from "./graph-extraction";
+import { loadStoredGraphMeta, loadStoredGraphSnapshot } from "./graph-db";
+function normalizeGraphName(value) {
+    return value.trim().toLowerCase();
+}
+let cachedParsedGraph;
+function resolveGraphBoostWeights(config) {
+    const configured = config?.search?.graphBoost;
+    return {
+        directBoostPerEntity: configured?.directBoostPerEntity ?? GRAPH_DIRECT_BOOST_PER_ENTITY,
+        directBoostCap: configured?.directBoostCap ?? GRAPH_DIRECT_BOOST_CAP,
+        hopBoostPerEntity: configured?.hopBoostPerEntity ?? GRAPH_HOP_BOOST_PER_ENTITY,
+        hopBoostCap: configured?.hopBoostCap ?? GRAPH_HOP_BOOST_CAP,
+        maxHops: Math.min(Math.max(configured?.maxHops ?? GRAPH_MAX_HOPS, 1), GRAPH_MAX_HOPS_HARD_CAP),
+        confidenceMode: configured?.confidenceMode ?? GRAPH_CONFIDENCE_MODE,
+        confidenceWeight: configured?.confidenceWeight ?? GRAPH_CONFIDENCE_WEIGHT,
+    };
+}
 /**
  * Per-entry weights, exposed as constants so tests can read them and so the
  * single-source-of-truth for "how much does the graph contribute" is here
@@ -29,20 +43,47 @@ export const GRAPH_DIRECT_BOOST_PER_ENTITY = 0.25;
 export const GRAPH_DIRECT_BOOST_CAP = 0.75;
 export const GRAPH_HOP_BOOST_PER_ENTITY = 0.1;
 export const GRAPH_HOP_BOOST_CAP = 0.3;
+export const GRAPH_MAX_HOPS = 1;
+export const GRAPH_CONFIDENCE_MODE = "blend";
+export const GRAPH_CONFIDENCE_WEIGHT = 0.2;
+const GRAPH_MAX_HOPS_HARD_CAP = 3;
+function normalizeConfidence(raw) {
+    if (typeof raw !== "number" || !Number.isFinite(raw))
+        return undefined;
+    return Math.max(0, Math.min(1, raw));
+}
+function combineConfidence(...parts) {
+    let out;
+    for (const part of parts) {
+        const value = normalizeConfidence(part);
+        if (value === undefined)
+            continue;
+        out = out === undefined ? value : out * value;
+    }
+    return out;
+}
+function toConfidenceMultiplier(rawConfidence, weights) {
+    if (weights.confidenceMode === "off")
+        return 1;
+    const confidence = normalizeConfidence(rawConfidence) ?? 1;
+    if (weights.confidenceMode === "multiply")
+        return confidence;
+    const blendWeight = Math.max(0, Math.min(1, weights.confidenceWeight));
+    return 1 - blendWeight + blendWeight * confidence;
+}
 /**
  * Load the graph file for a stash root and pre-compute everything that's
  * shared across all entries scored for one query. Returns `null` when:
- *   - `graph.json` does not exist.
- *   - The file fails to parse.
- *   - The schema version doesn't match (treated like "missing" so an old
- *     index keeps working until the next `akm index --full`).
+ *   - No graph snapshot exists in SQLite.
  *   - The query produces no token-level entity matches (no boost is
  *     possible, so we skip the per-entry overhead entirely).
  */
-export function loadGraphBoostContext(stashRoot, query) {
-    const graph = readGraphFile(stashRoot);
-    if (!graph)
+export function loadGraphBoostContext(stashRoot, query, config, db) {
+    const stashRoots = Array.isArray(stashRoot) ? stashRoot : [stashRoot];
+    const parsed = readParsedGraphContext(stashRoots, db);
+    if (!parsed)
         return null;
+    const weights = resolveGraphBoostWeights(config);
     const queryTokens = query
         .toLowerCase()
         .split(/[\s\-_/]+/)
@@ -53,20 +94,21 @@ export function loadGraphBoostContext(stashRoot, query) {
     // is small (capped per-asset at extract time) and lets the per-entry
     // path do a single set membership test.
     const allEntities = new Set();
-    const nodesByPath = new Map();
-    for (const node of graph.files) {
-        nodesByPath.set(node.path, node);
+    for (const node of parsed.graph.files) {
         for (const entity of node.entities)
             allEntities.add(entity);
     }
     // An entity matches the query when any of its sub-tokens equals or
-    // contains a query token. Cheap and forgiving — exact substring match is
-    // sufficient because both sides are already lower-cased at extract time.
+    // contains a query token. Matching is case-insensitive; the graph keeps
+    // canonical display strings and we normalize only for comparisons here.
     const matchedEntities = new Set();
     for (const entity of allEntities) {
-        const entityTokens = entity.split(/[\s\-_/]+/).filter(Boolean);
+        const normalizedEntity = normalizeGraphName(entity);
+        const entityTokens = normalizedEntity.split(/[\s\-_/]+/).filter(Boolean);
         for (const qt of queryTokens) {
-            if (entity === qt || entity.includes(qt) || entityTokens.some((et) => et === qt)) {
+            if (normalizedEntity === qt ||
+                normalizedEntity.includes(qt) ||
+                entityTokens.some((et) => et === qt || et.includes(qt))) {
                 matchedEntities.add(entity);
                 break;
             }
@@ -74,20 +116,47 @@ export function loadGraphBoostContext(stashRoot, query) {
     }
     if (matchedEntities.size === 0)
         return null;
-    // One-hop neighbours: any entity that appears on the other end of a
-    // relation whose other endpoint is in matchedEntities.
-    const oneHopEntities = new Set();
-    for (const node of graph.files) {
-        for (const rel of node.relations) {
-            if (matchedEntities.has(rel.from) && !matchedEntities.has(rel.to)) {
-                oneHopEntities.add(rel.to);
-            }
-            else if (matchedEntities.has(rel.to) && !matchedEntities.has(rel.from)) {
-                oneHopEntities.add(rel.from);
+    const connectedEntities = new Set();
+    const connectedConfidence = new Map();
+    const visited = new Set();
+    let frontier = new Map();
+    for (const entity of matchedEntities) {
+        const seed = parsed.entityConfidence.get(entity) ?? 1;
+        frontier.set(entity, seed);
+        visited.add(entity);
+    }
+    for (let hop = 1; hop <= weights.maxHops; hop += 1) {
+        const next = new Map();
+        for (const [entity, pathConfidence] of frontier.entries()) {
+            const neighbors = parsed.adjacency.get(entity);
+            if (!neighbors)
+                continue;
+            for (const [neighbor, edgeConfidence] of neighbors.entries()) {
+                const neighborPathConfidence = Math.max(0, Math.min(1, pathConfidence * edgeConfidence));
+                const currentBest = connectedConfidence.get(neighbor) ?? 0;
+                if (neighborPathConfidence > currentBest)
+                    connectedConfidence.set(neighbor, neighborPathConfidence);
+                if (visited.has(neighbor))
+                    continue;
+                visited.add(neighbor);
+                next.set(neighbor, Math.max(next.get(neighbor) ?? 0, neighborPathConfidence));
+                connectedEntities.add(neighbor);
             }
         }
+        if (next.size === 0)
+            break;
+        frontier = next;
     }
-    return { nodesByPath, matchedEntities, oneHopEntities };
+    return {
+        graph: parsed.graph,
+        nodesByPath: parsed.nodesByPath,
+        matchedEntities,
+        connectedEntities,
+        connectedConfidence,
+        entityConfidence: parsed.entityConfidence,
+        adjacency: parsed.adjacency,
+        weights,
+    };
 }
 /**
  * Compute the graph-boost contribution for a single scored entry.
@@ -100,80 +169,164 @@ export function computeGraphBoost(context, filePath) {
     const node = context.nodesByPath.get(filePath);
     if (!node)
         return 0;
-    let directHits = 0;
-    let hopHits = 0;
+    let directBoostRaw = 0;
+    let hopBoostRaw = 0;
     for (const entity of node.entities) {
-        if (context.matchedEntities.has(entity))
-            directHits += 1;
-        else if (context.oneHopEntities.has(entity))
-            hopHits += 1;
+        if (context.matchedEntities.has(entity)) {
+            const directConfidence = combineConfidence(node.confidence, context.entityConfidence.get(entity));
+            directBoostRaw +=
+                context.weights.directBoostPerEntity * toConfidenceMultiplier(directConfidence, context.weights);
+        }
+        else if (context.connectedEntities.has(entity)) {
+            const hopConfidence = combineConfidence(node.confidence, context.entityConfidence.get(entity), context.connectedConfidence.get(entity));
+            hopBoostRaw += context.weights.hopBoostPerEntity * toConfidenceMultiplier(hopConfidence, context.weights);
+        }
     }
-    const directBoost = Math.min(GRAPH_DIRECT_BOOST_CAP, directHits * GRAPH_DIRECT_BOOST_PER_ENTITY);
-    const hopBoost = Math.min(GRAPH_HOP_BOOST_CAP, hopHits * GRAPH_HOP_BOOST_PER_ENTITY);
+    const directBoost = Math.min(context.weights.directBoostCap, directBoostRaw);
+    const hopBoost = Math.min(context.weights.hopBoostCap, hopBoostRaw);
     return directBoost + hopBoost;
 }
-/**
- * Lightweight reader — extracted so the boost loader and tests share one
- * code path. Tolerant of missing files (returns null) but logs a warning
- * when an existing file fails to parse so corruption is visible.
- */
-function readGraphFile(stashRoot) {
-    const target = getGraphFilePath(stashRoot);
-    let raw;
-    try {
-        raw = fs.readFileSync(target, "utf8");
-    }
-    catch {
-        // Missing → no boost. Not an error: the user simply hasn't enabled
-        // graph extraction yet, or the pass hasn't run.
+export function collectGraphRelatedHit(context, filePath) {
+    const node = context.nodesByPath.get(filePath);
+    if (!node)
         return null;
+    const entities = [];
+    for (const entity of node.entities) {
+        if (context.matchedEntities.has(entity)) {
+            entities.push({
+                name: entity,
+                kind: "matched",
+                ...(context.entityConfidence.get(entity) !== undefined
+                    ? { confidence: context.entityConfidence.get(entity) }
+                    : {}),
+            });
+            continue;
+        }
+        if (context.connectedEntities.has(entity)) {
+            entities.push({
+                name: entity,
+                kind: "connected",
+                ...(context.connectedConfidence.get(entity) !== undefined
+                    ? { confidence: context.connectedConfidence.get(entity) }
+                    : {}),
+            });
+        }
     }
-    let parsed;
-    try {
-        parsed = JSON.parse(raw);
-    }
-    catch (err) {
-        warn(`graph boost: failed to parse ${target}: ${err instanceof Error ? err.message : String(err)}`);
+    if (entities.length === 0)
         return null;
+    const relatedNames = new Set(entities.map((entity) => entity.name));
+    const relations = node.relations
+        .filter((relation) => relatedNames.has(relation.from) || relatedNames.has(relation.to))
+        .map((relation) => ({
+        from: relation.from,
+        to: relation.to,
+        ...(relation.type ? { type: relation.type } : {}),
+        ...(normalizeConfidence(relation.confidence) !== undefined
+            ? { confidence: normalizeConfidence(relation.confidence) }
+            : {}),
+    }));
+    return {
+        path: filePath,
+        type: node.type,
+        entities: entities.sort((a, b) => a.name.localeCompare(b.name)),
+        relations,
+    };
+}
+export function listRelatedPathsForFile(stashRoot, filePath, limit = 5, db) {
+    const parsed = readParsedGraphContext([stashRoot], db);
+    if (!parsed)
+        return [];
+    const node = parsed.nodesByPath.get(filePath);
+    if (!node)
+        return [];
+    const entitySet = new Set(node.entities.map(normalizeGraphName));
+    const results = [];
+    for (const candidate of parsed.graph.files) {
+        if (candidate.path === filePath)
+            continue;
+        const sharedEntities = candidate.entities.filter((entity) => entitySet.has(normalizeGraphName(entity)));
+        if (sharedEntities.length === 0)
+            continue;
+        const relationCount = candidate.relations.filter((relation) => entitySet.has(normalizeGraphName(relation.from)) || entitySet.has(normalizeGraphName(relation.to))).length;
+        results.push({
+            path: candidate.path,
+            type: candidate.type,
+            sharedEntities: [...new Set(sharedEntities)].sort((a, b) => a.localeCompare(b)),
+            relationCount,
+        });
     }
-    if (!isGraphFile(parsed) || parsed.schemaVersion !== GRAPH_FILE_SCHEMA_VERSION) {
+    results.sort((a, b) => b.sharedEntities.length - a.sharedEntities.length ||
+        b.relationCount - a.relationCount ||
+        a.path.localeCompare(b.path));
+    return results.slice(0, Math.max(1, limit));
+}
+/**
+ * Load and normalize graph data from SQLite once, then reuse it across all
+ * per-entry boost lookups in the current query.
+ */
+function readParsedGraphContext(stashRoots, db) {
+    const sortedRoots = [...new Set(stashRoots)].sort((a, b) => a.localeCompare(b));
+    if (sortedRoots.length === 0)
         return null;
+    const metas = sortedRoots
+        .map((stashRoot) => loadStoredGraphMeta(stashRoot, db))
+        .filter((meta) => meta !== null);
+    if (metas.length === 0)
+        return null;
+    const cacheKey = metas.map((meta) => `${meta.stashPath}\u0000${meta.generatedAt}`).join("\u0001");
+    if (cachedParsedGraph && cachedParsedGraph.cacheKey === cacheKey)
+        return cachedParsedGraph.context;
+    const snapshots = metas
+        .map((meta) => loadStoredGraphSnapshot(meta.stashPath, db))
+        .filter((snapshot) => snapshot !== null);
+    if (snapshots.length === 0)
+        return null;
+    const graph = {
+        schemaVersion: Math.max(...snapshots.map((snapshot) => snapshot.schemaVersion)),
+        generatedAt: snapshots
+            .map((snapshot) => snapshot.generatedAt)
+            .sort()
+            .at(-1) ?? new Date(0).toISOString(),
+        stashRoot: snapshots[0]?.stashPath ?? "",
+        files: snapshots.flatMap((snapshot) => snapshot.files),
+        entities: [...new Set(snapshots.flatMap((snapshot) => snapshot.entities))],
+        relations: snapshots.flatMap((snapshot) => snapshot.relations),
+    };
+    const nodesByPath = new Map();
+    const entityConfidence = new Map();
+    const adjacency = new Map();
+    function setBestEntityConfidence(entity, confidence) {
+        const normalized = normalizeConfidence(confidence);
+        if (normalized === undefined)
+            return;
+        const current = entityConfidence.get(entity);
+        if (current === undefined || normalized > current)
+            entityConfidence.set(entity, normalized);
     }
-    return parsed;
-}
-function isGraphFile(value) {
-    if (typeof value !== "object" || value === null)
-        return false;
-    const obj = value;
-    if (typeof obj.schemaVersion !== "number")
-        return false;
-    if (typeof obj.generatedAt !== "string")
-        return false;
-    if (typeof obj.stashRoot !== "string")
-        return false;
-    if (!Array.isArray(obj.files))
-        return false;
-    for (const f of obj.files) {
-        if (typeof f !== "object" || f === null)
-            return false;
-        const node = f;
-        if (typeof node.path !== "string")
-            return false;
-        if (typeof node.type !== "string")
-            return false;
-        if (!Array.isArray(node.entities) || !node.entities.every((e) => typeof e === "string"))
-            return false;
-        if (!Array.isArray(node.relations))
-            return false;
-        for (const r of node.relations) {
-            if (typeof r !== "object" || r === null)
-                return false;
-            const rel = r;
-            if (typeof rel.from !== "string" || typeof rel.to !== "string")
-                return false;
-            if (rel.type !== undefined && typeof rel.type !== "string")
-                return false;
+    function setBestEdgeConfidence(from, to, confidence) {
+        const normalized = normalizeConfidence(confidence);
+        if (!adjacency.has(from))
+            adjacency.set(from, new Map());
+        const neighbors = adjacency.get(from);
+        if (!neighbors)
+            return;
+        const current = neighbors.get(to);
+        const next = normalized ?? 1;
+        if (current === undefined || next > current)
+            neighbors.set(to, next);
+    }
+    for (const node of graph.files) {
+        nodesByPath.set(node.path, node);
+        for (const entity of node.entities) {
+            setBestEntityConfidence(entity, node.confidence);
+        }
+        for (const rel of node.relations) {
+            const edgeConfidence = combineConfidence(node.confidence, rel.confidence);
+            setBestEdgeConfidence(rel.from, rel.to, edgeConfidence);
+            setBestEdgeConfidence(rel.to, rel.from, edgeConfidence);
         }
     }
-    return true;
+    const context = { graph, nodesByPath, entityConfidence, adjacency };
+    cachedParsedGraph = { cacheKey, context };
+    return context;
 }

package/dist/indexer/graph-db.js

@@ -0,0 +1,201 @@
+import fs from "node:fs";
+import { getDbPath } from "../core/paths";
+import { closeDatabase, openExistingDatabase } from "./db";
+function withReadableGraphDb(db, fn) {
+    if (db)
+        return fn(db);
+    const dbPath = getDbPath();
+    if (!fs.existsSync(dbPath))
+        throw new Error("GRAPH_DB_MISSING");
+    const opened = openExistingDatabase(dbPath);
+    try {
+        return fn(opened);
+    }
+    finally {
+        closeDatabase(opened);
+    }
+}
+function uniqueSorted(values) {
+    return [...new Set(values)].sort((a, b) => a.localeCompare(b));
+}
+export function replaceStoredGraph(db, graph) {
+    const upsertMeta = db.prepare(`INSERT INTO graph_meta (
+       stash_root,
+       schema_version,
+       generated_at,
+       considered_files,
+       extracted_files,
+       entity_count,
+       relation_count,
+       extraction_coverage,
+       density
+     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(stash_root) DO UPDATE SET
+       schema_version = excluded.schema_version,
+       generated_at = excluded.generated_at,
+       considered_files = excluded.considered_files,
+       extracted_files = excluded.extracted_files,
+       entity_count = excluded.entity_count,
+       relation_count = excluded.relation_count,
+       extraction_coverage = excluded.extraction_coverage,
+       density = excluded.density`);
+    const deleteRelations = db.prepare("DELETE FROM graph_file_relations WHERE stash_root = ?");
+    const deleteEntities = db.prepare("DELETE FROM graph_file_entities WHERE stash_root = ?");
+    const deleteFiles = db.prepare("DELETE FROM graph_files WHERE stash_root = ?");
+    const insertFile = db.prepare(`INSERT INTO graph_files (stash_root, file_path, file_order, file_type, body_hash, confidence)
+     VALUES (?, ?, ?, ?, ?, ?)`);
+    const insertEntity = db.prepare(`INSERT INTO graph_file_entities (stash_root, file_path, entity_order, entity)
+     VALUES (?, ?, ?, ?)`);
+    const insertRelation = db.prepare(`INSERT INTO graph_file_relations (
+       stash_root,
+       file_path,
+       relation_order,
+       from_entity,
+       to_entity,
+       relation_type,
+       confidence
+     ) VALUES (?, ?, ?, ?, ?, ?, ?)`);
+    const quality = graph.quality;
+    db.transaction(() => {
+        upsertMeta.run(graph.stashRoot, graph.schemaVersion, graph.generatedAt, quality?.consideredFiles ?? graph.files.length, quality?.extractedFiles ?? graph.files.length, quality?.entityCount ?? graph.entities?.length ?? 0, quality?.relationCount ?? graph.relations?.length ?? 0, quality?.extractionCoverage ?? 0, quality?.density ?? 0);
+        deleteRelations.run(graph.stashRoot);
+        deleteEntities.run(graph.stashRoot);
+        deleteFiles.run(graph.stashRoot);
+        for (const [fileOrder, node] of graph.files.entries()) {
+            insertFile.run(graph.stashRoot, node.path, fileOrder, node.type, node.bodyHash ?? null, node.confidence ?? null);
+            for (const [entityOrder, entity] of node.entities.entries()) {
+                insertEntity.run(graph.stashRoot, node.path, entityOrder, entity);
+            }
+            for (const [relationOrder, relation] of node.relations.entries()) {
+                insertRelation.run(graph.stashRoot, node.path, relationOrder, relation.from, relation.to, relation.type ?? null, relation.confidence ?? null);
+            }
+        }
+    })();
+}
+export function deleteStoredGraph(db, stashPath) {
+    db.transaction(() => {
+        db.prepare("DELETE FROM graph_file_relations WHERE stash_root = ?").run(stashPath);
+        db.prepare("DELETE FROM graph_file_entities WHERE stash_root = ?").run(stashPath);
+        db.prepare("DELETE FROM graph_files WHERE stash_root = ?").run(stashPath);
+        db.prepare("DELETE FROM graph_meta WHERE stash_root = ?").run(stashPath);
+    })();
+}
+export function loadStoredGraphMeta(stashPath, db) {
+    try {
+        return withReadableGraphDb(db, (readDb) => {
+            try {
+                const row = readDb
+                    .prepare(`SELECT
+               stash_root,
+               schema_version,
+               generated_at,
+               considered_files,
+               extracted_files,
+               entity_count,
+               relation_count,
+               extraction_coverage,
+               density
+             FROM graph_meta
+             WHERE stash_root = ?`)
+                    .get(stashPath);
+                if (!row)
+                    return null;
+                return {
+                    stashPath: row.stash_root,
+                    graphPath: getDbPath(),
+                    schemaVersion: row.schema_version,
+                    generatedAt: row.generated_at,
+                    quality: {
+                        consideredFiles: row.considered_files,
+                        extractedFiles: row.extracted_files,
+                        entityCount: row.entity_count,
+                        relationCount: row.relation_count,
+                        extractionCoverage: row.extraction_coverage,
+                        density: row.density,
+                    },
+                };
+            }
+            catch {
+                return null;
+            }
+        });
+    }
+    catch {
+        return null;
+    }
+}
+export function loadStoredGraphSnapshot(stashPath, db) {
+    try {
+        return withReadableGraphDb(db, (readDb) => {
+            const meta = loadStoredGraphMeta(stashPath, readDb);
+            if (!meta)
+                return null;
+            try {
+                const fileRows = readDb
+                    .prepare(`SELECT file_path, file_type, body_hash, confidence
+             FROM graph_files
+             WHERE stash_root = ?
+             ORDER BY file_order`)
+                    .all(stashPath);
+                const entityRows = readDb
+                    .prepare(`SELECT file_path, entity
+             FROM graph_file_entities
+             WHERE stash_root = ?
+             ORDER BY file_path, entity_order`)
+                    .all(stashPath);
+                const relationRows = readDb
+                    .prepare(`SELECT file_path, from_entity, to_entity, relation_type, confidence
+             FROM graph_file_relations
+             WHERE stash_root = ?
+             ORDER BY file_path, relation_order`)
+                    .all(stashPath);
+                const entitiesByPath = new Map();
+                for (const row of entityRows) {
+                    const bucket = entitiesByPath.get(row.file_path);
+                    if (bucket)
+                        bucket.push(row.entity);
+                    else
+                        entitiesByPath.set(row.file_path, [row.entity]);
+                }
+                const relationsByPath = new Map();
+                for (const row of relationRows) {
+                    const relation = {
+                        from: row.from_entity,
+                        to: row.to_entity,
+                        ...(row.relation_type ? { type: row.relation_type } : {}),
+                        ...(typeof row.confidence === "number" ? { confidence: row.confidence } : {}),
+                    };
+                    const bucket = relationsByPath.get(row.file_path);
+                    if (bucket)
+                        bucket.push(relation);
+                    else
+                        relationsByPath.set(row.file_path, [relation]);
+                }
+                const files = fileRows.map((row) => ({
+                    path: row.file_path,
+                    type: row.file_type,
+                    ...(row.body_hash ? { bodyHash: row.body_hash } : {}),
+                    entities: entitiesByPath.get(row.file_path) ?? [],
+                    relations: relationsByPath.get(row.file_path) ?? [],
+                    ...(typeof row.confidence === "number" ? { confidence: row.confidence } : {}),
+                }));
+                return {
+                    stashPath: meta.stashPath,
+                    graphPath: meta.graphPath,
+                    schemaVersion: meta.schemaVersion,
+                    generatedAt: meta.generatedAt,
+                    ...(meta.quality ? { quality: meta.quality } : {}),
+                    files,
+                    entities: uniqueSorted(files.flatMap((file) => file.entities)),
+                    relations: files.flatMap((file) => file.relations),
+                };
+            }
+            catch {
+                return null;
+            }
+        });
+    }
+    catch {
+        return null;
+    }
+}