@monoes/monograph 1.2.0 → 1.2.2

package/src/graph/wcc.ts

@@ -20,59 +20,168 @@ export function weaklyConnectedComponents(db: MonographDb): string[][] {
   if (nodeRows.length === 0) return [];
 
   const nodes = nodeRows.map(r => r.id);
+  const { parent, rank } = buildUnionFind(nodes);
 
-  // Union-Find
+  for (const { source_id: src, target_id: tgt } of edgeRows) {
+    if (src === tgt) continue;
+    if (!parent.has(src) || !parent.has(tgt)) continue;
+    ufUnion(parent, rank, src, tgt);
+  }
+
+  return groupByRoot(nodes, parent);
+}
+
+// ---------------------------------------------------------------------------
+// Summary stats — avoids name resolution and component array materialisation
+// ---------------------------------------------------------------------------
+
+export interface WccStats {
+  /** Total number of weakly connected components */
+  componentCount: number;
+  /** Size of the largest component */
+  largestSize: number;
+  /** Size of the smallest component */
+  smallestSize: number;
+  /** Mean component size */
+  meanSize: number;
+  /** Number of isolated nodes (component size = 1) */
+  isolatedNodeCount: number;
+}
+
+/**
+ * Lightweight summary statistics for all WCCs.
+ * Does not materialise component arrays — returns aggregate numbers only.
+ */
+export function wccStats(db: MonographDb): WccStats {
+  const components = weaklyConnectedComponents(db);
+  if (components.length === 0) {
+    return { componentCount: 0, largestSize: 0, smallestSize: 0, meanSize: 0, isolatedNodeCount: 0 };
+  }
+
+  const sizes = components.map(c => c.length);
+  const total = sizes.reduce((a, b) => a + b, 0);
+  return {
+    componentCount: sizes.length,
+    largestSize: sizes[0], // already sorted descending
+    smallestSize: sizes[sizes.length - 1],
+    meanSize: Math.round((total / sizes.length) * 100) / 100,
+    isolatedNodeCount: sizes.filter(s => s === 1).length,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Structured text formatter for LLM consumption
+// ---------------------------------------------------------------------------
+
+/**
+ * Format WCC results as structured text for LLM consumption.
+ *
+ * Resolves node IDs to names and file paths for the top-N largest components.
+ * Small/isolated components are summarised in aggregate to avoid token waste.
+ *
+ * @param db - The MonographDb instance (for name resolution)
+ * @param components - Result of weaklyConnectedComponents()
+ * @param topN - Number of largest components to detail (default: 5)
+ * @returns Structured text string suitable for LLM context injection
+ */
+export function formatWcc(db: MonographDb, components: string[][], topN = 5): string {
+  if (components.length === 0) {
+    return 'Weakly connected components: no nodes found.';
+  }
+
+  const isolatedCount = components.filter(c => c.length === 1).length;
+  const nonTrivial = components.filter(c => c.length > 1);
+  const display = nonTrivial.slice(0, topN);
+
+  // Batch-resolve all node IDs in the displayed components
+  const allIds = display.flat();
+  const CHUNK = 200;
+  const nodeInfo = new Map<string, { name: string; filePath: string | null }>();
+
+  for (let i = 0; i < allIds.length; i += CHUNK) {
+    const chunk = allIds.slice(i, i + CHUNK);
+    const ph = chunk.map(() => '?').join(',');
+    const rows = db
+      .prepare(`SELECT id, name, file_path FROM nodes WHERE id IN (${ph})`)
+      .all(...chunk) as { id: string; name: string; file_path: string | null }[];
+    for (const row of rows) nodeInfo.set(row.id, { name: row.name ?? row.id, filePath: row.file_path });
+  }
+
+  const lines: string[] = [
+    `Weakly connected components: ${components.length} total` +
+      (isolatedCount > 0 ? ` (${isolatedCount} isolated node${isolatedCount === 1 ? '' : 's'})` : ''),
+    '',
+  ];
+
+  for (let ci = 0; ci < display.length; ci++) {
+    const comp = display[ci];
+    lines.push(`Component ${ci + 1} (${comp.length} nodes):`);
+    for (const id of comp) {
+      const info = nodeInfo.get(id);
+      const name = info?.name ?? id;
+      const fp = info?.filePath;
+      lines.push(`  ${name}${fp ? ` — ${fp}` : ''}`);
+    }
+    if (ci < display.length - 1) lines.push('');
+  }
+
+  if (nonTrivial.length > topN) {
+    lines.push('');
+    lines.push(`... (${nonTrivial.length - topN} more non-trivial component${nonTrivial.length - topN === 1 ? '' : 's'} omitted)`);
+  }
+
+  return lines.join('\n');
+}
+
+// ---------------------------------------------------------------------------
+// Internal union-find helpers
+// ---------------------------------------------------------------------------
+
+function buildUnionFind(nodes: string[]): { parent: Map<string, string>; rank: Map<string, number> } {
   const parent = new Map<string, string>();
   const rank = new Map<string, number>();
-
   for (const n of nodes) {
     parent.set(n, n);
     rank.set(n, 0);
   }
+  return { parent, rank };
+}
 
-  function find(x: string): string {
-    let root = x;
-    while (parent.get(root) !== root) root = parent.get(root)!;
-    // Path compression
-    let cur = x;
-    while (cur !== root) {
-      const next = parent.get(cur)!;
-      parent.set(cur, root);
-      cur = next;
-    }
-    return root;
-  }
-
-  function union(a: string, b: string): void {
-    const ra = find(a);
-    const rb = find(b);
-    if (ra === rb) return;
-    const rankA = rank.get(ra) ?? 0;
-    const rankB = rank.get(rb) ?? 0;
-    if (rankA < rankB) {
-      parent.set(ra, rb);
-    } else if (rankA > rankB) {
-      parent.set(rb, ra);
-    } else {
-      parent.set(rb, ra);
-      rank.set(ra, rankA + 1);
-    }
+function ufFind(parent: Map<string, string>, x: string): string {
+  let root = x;
+  while (parent.get(root) !== root) root = parent.get(root)!;
+  // Path compression
+  let cur = x;
+  while (cur !== root) {
+    const next = parent.get(cur)!;
+    parent.set(cur, root);
+    cur = next;
   }
+  return root;
+}
 
-  for (const { source_id: src, target_id: tgt } of edgeRows) {
-    if (src === tgt) continue;
-    if (!parent.has(src) || !parent.has(tgt)) continue;
-    union(src, tgt);
+function ufUnion(parent: Map<string, string>, rank: Map<string, number>, a: string, b: string): void {
+  const ra = ufFind(parent, a);
+  const rb = ufFind(parent, b);
+  if (ra === rb) return;
+  const rankA = rank.get(ra) ?? 0;
+  const rankB = rank.get(rb) ?? 0;
+  if (rankA < rankB) {
+    parent.set(ra, rb);
+  } else if (rankA > rankB) {
+    parent.set(rb, ra);
+  } else {
+    parent.set(rb, ra);
+    rank.set(ra, rankA + 1);
   }
+}
 
-  // Group nodes by root
+function groupByRoot(nodes: string[], parent: Map<string, string>): string[][] {
   const components = new Map<string, string[]>();
   for (const n of nodes) {
-    const root = find(n);
+    const root = ufFind(parent, n);
     if (!components.has(root)) components.set(root, []);
     components.get(root)!.push(n);
   }
-
-  // Return sorted by size descending
   return [...components.values()].sort((a, b) => b.length - a.length);
 }

package/src/index.ts

@@ -32,7 +32,7 @@ export * from './groups/group-sync.js';
 export * from './mcp-tools/group-query.js';
 export * from './mcp-tools/group-list.js';
 export * from './mcp-tools/group-sync.js';
-// wiki/wiki-store.js re-exported via mcp-tools/wiki.js to avoid WikiPage duplicate
+// wiki/wiki-store.js intentionally not re-exported: its WikiPage conflicts with mcp-tools/wiki.ts's WikiPage
 export * from './wiki/prompt-builder.js';
 export * from './wiki/wiki-generator.js';
 export * from './wiki/gist-publisher.js';

package/src/mcp-tools/api-impact.ts

@@ -134,15 +134,22 @@ export function getMonographApiImpact(
   // 3. Forward BFS on CALLS edges from handler
   const bfsResults = forwardBfs(handler.id, db, MAX_DEPTH);
 
-  // 4. Resolve node details for each callee
+  // 4. Resolve node details for all callees in a single batch query (avoids N+1).
   const callees: Array<{ depth: number; node: MonographNode }> = [];
-  for (const { depth, nodeId } of bfsResults) {
-    const nodeRow = db
-      .prepare('SELECT * FROM nodes WHERE id = ?')
-      .get(nodeId) as Record<string, unknown> | undefined;
-    if (nodeRow) {
+  if (bfsResults.length > 0) {
+    const calleeIds = bfsResults.map((b) => b.nodeId);
+    const depthByNodeId = new Map(bfsResults.map((b) => [b.nodeId, b.depth]));
+    const placeholders = calleeIds.map(() => '?').join(',');
+    const nodeRows = db
+      .prepare(`SELECT * FROM nodes WHERE id IN (${placeholders})`)
+      .all(...calleeIds) as Record<string, unknown>[];
+    for (const nodeRow of nodeRows) {
+      const nodeId = nodeRow.id as string;
+      const depth = depthByNodeId.get(nodeId) ?? 0;
       callees.push({ depth, node: rowToNode(nodeRow) });
     }
+    // Restore BFS order (sort by depth ascending)
+    callees.sort((a, b) => a.depth - b.depth);
   }
 
   // 5. Find processes that include the handler or any callee via STEP_IN_PROCESS

package/src/mcp-tools/context.ts

@@ -31,6 +31,31 @@ export interface MonographContextResult {
   inProcesses: Array<{ id: string; name: string }>;
 }
 
+// ── Shared helper: query related nodes by edge relation and direction ──────────
+
+function queryRelated(
+  db: Database.Database,
+  nodeId: string,
+  relation: string,
+  inbound: boolean,
+  limit = 50,
+): MonographNode[] {
+  // inbound=true  → this node is the target; source nodes are the result
+  // inbound=false → this node is the source; target nodes are the result
+  const [filterCol, joinCol] = inbound
+    ? ['target_id', 'source_id']
+    : ['source_id', 'target_id'];
+
+  const rows = db
+    .prepare(
+      `SELECT n.* FROM nodes n JOIN edges e ON n.id = e.${joinCol}
+       WHERE e.${filterCol} = ? AND e.relation = ? LIMIT ?`,
+    )
+    .all(nodeId, relation, limit) as Record<string, unknown>[];
+
+  return rows.map(rowToNode);
+}
+
 // ── Implementation ─────────────────────────────────────────────────────────────
 
 export function getMonographContext(
@@ -58,37 +83,11 @@ export function getMonographContext(
   const node = rowToNode(nodeRow);
   const nodeId = node.id;
 
-  // 2. Callers: nodes that CALL this node (inbound CALLS edges)
-  const callerRows = db
-    .prepare(
-      `SELECT n.* FROM nodes n JOIN edges e ON n.id = e.source_id
-       WHERE e.target_id = ? AND e.relation = 'CALLS' LIMIT ?`,
-    )
-    .all(nodeId, LIMIT) as Record<string, unknown>[];
-
-  // 3. Callees: nodes this node CALLS (outbound CALLS edges)
-  const calleeRows = db
-    .prepare(
-      `SELECT n.* FROM nodes n JOIN edges e ON n.id = e.target_id
-       WHERE e.source_id = ? AND e.relation = 'CALLS' LIMIT ?`,
-    )
-    .all(nodeId, LIMIT) as Record<string, unknown>[];
-
-  // 4. Imports: what this node imports (outbound IMPORTS edges)
-  const importRows = db
-    .prepare(
-      `SELECT n.* FROM nodes n JOIN edges e ON n.id = e.target_id
-       WHERE e.source_id = ? AND e.relation = 'IMPORTS' LIMIT ?`,
-    )
-    .all(nodeId, LIMIT) as Record<string, unknown>[];
-
-  // 5. ImportedBy: what imports this node (inbound IMPORTS edges)
-  const importedByRows = db
-    .prepare(
-      `SELECT n.* FROM nodes n JOIN edges e ON n.id = e.source_id
-       WHERE e.target_id = ? AND e.relation = 'IMPORTS' LIMIT ?`,
-    )
-    .all(nodeId, LIMIT) as Record<string, unknown>[];
+  // 2–5. Callers / callees / imports / importedBy via shared helper
+  const callers    = queryRelated(db, nodeId, 'CALLS',   true,  LIMIT);
+  const callees    = queryRelated(db, nodeId, 'CALLS',   false, LIMIT);
+  const imports    = queryRelated(db, nodeId, 'IMPORTS', false, LIMIT);
+  const importedBy = queryRelated(db, nodeId, 'IMPORTS', true,  LIMIT);
 
   // 6. Community: from node's community_id field
   let community: { id: number; label?: string } | null = null;
@@ -108,13 +107,5 @@ export function getMonographContext(
     )
     .all(nodeId, LIMIT) as Array<{ id: string; name: string }>;
 
-  return {
-    node,
-    callers: callerRows.map(rowToNode),
-    callees: calleeRows.map(rowToNode),
-    imports: importRows.map(rowToNode),
-    importedBy: importedByRows.map(rowToNode),
-    community,
-    inProcesses: processRows,
-  };
+  return { node, callers, callees, imports, importedBy, community, inProcesses: processRows };
 }

package/src/mcp-tools/cypher.ts

@@ -1,8 +1,9 @@
 import type Database from 'better-sqlite3';
-import { executeCypherQuery } from '../query/cypher-parser.js';
+import { executeCypherQuery, formatCypherResult } from '../query/cypher-parser.js';
 import type { CypherResult } from '../query/cypher-parser.js';
 
 export type { CypherResult };
+export { formatCypherResult };
 
 /**
  * Execute a restricted read-only Cypher-style query against the Monograph graph.
@@ -14,3 +15,15 @@ export type { CypherResult };
 export function getMonographCypher(db: Database.Database, query: string): CypherResult {
   return executeCypherQuery(db, query);
 }
+
+/**
+ * Execute a Cypher-style query and return structured text for LLM consumption.
+ * Rows with filePath + startLine fields are rendered as "file:line" navigation hints.
+ *
+ * @param db - Open better-sqlite3 database handle
+ * @param query - Cypher MATCH query string
+ * @returns Formatted string suitable for direct injection into LLM context
+ */
+export function getMonographCypherText(db: Database.Database, query: string): string {
+  return formatCypherResult(executeCypherQuery(db, query));
+}

package/src/mcp-tools/detect-changes.ts

@@ -13,6 +13,9 @@ export interface MonographDetectChangesResult {
 
 // ── Implementation ─────────────────────────────────────────────────────────────
 
+const MAX_FILES = 200;    // cap on changed-file count to prevent unbounded IN clauses
+const MAX_STDOUT = 1_048_576; // 1 MiB stdout cap for git output
+
 export function detectMonographChanges(
   db: Database.Database,
   input: { baseBranch?: string; includeTests?: boolean },
@@ -33,15 +36,17 @@ export function detectMonographChanges(
     const result = spawnSync('git', ['diff', '--name-only', `${baseBranch}...HEAD`], {
       cwd: repoPath,
       encoding: 'utf-8',
+      maxBuffer: MAX_STDOUT,
     });
     if (result.error) throw result.error;
     if (result.status !== 0) throw new Error(result.stderr ?? `git exited ${result.status}`);
-    const output = result.stdout.trim();
+    const output = (result.stdout ?? '').slice(0, MAX_STDOUT).trim();
 
     changedFiles = output
       .split('\n')
       .map(f => f.trim())
-      .filter(f => f.length > 0);
+      .filter(f => f.length > 0)
+      .slice(0, MAX_FILES); // cap to prevent unbounded IN clauses
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     return { changedFiles: [], affectedSymbols: [], affectedProcesses: [], error: message };
@@ -56,22 +61,25 @@ export function detectMonographChanges(
     return { changedFiles: [], affectedSymbols: [], affectedProcesses: [] };
   }
 
-  // Query DB for symbols in changed files
+  // Query DB for symbols in changed files (batch if needed)
   let affectedSymbols: Array<{ name: string; filePath: string; label: string }> = [];
   let affectedSymbolIds: string[] = [];
 
   try {
-    const placeholders = changedFiles.map(() => '?').join(',');
-    const rows = db
-      .prepare(`SELECT id, name, file_path, label FROM nodes WHERE file_path IN (${placeholders})`)
-      .all(...changedFiles) as Array<{ id: string; name: string; file_path: string; label: string }>;
-
-    affectedSymbols = rows.map(r => ({
-      name: r.name,
-      filePath: r.file_path,
-      label: r.label,
-    }));
-    affectedSymbolIds = rows.map(r => r.id);
+    // Process in batches of 50 to keep SQLite IN clause size bounded
+    const BATCH = 50;
+    const allRows: Array<{ id: string; name: string; file_path: string; label: string }> = [];
+    for (let i = 0; i < changedFiles.length; i += BATCH) {
+      const batch = changedFiles.slice(i, i + BATCH);
+      const placeholders = batch.map(() => '?').join(',');
+      const rows = db
+        .prepare(`SELECT id, name, file_path, label FROM nodes WHERE file_path IN (${placeholders})`)
+        .all(...batch) as Array<{ id: string; name: string; file_path: string; label: string }>;
+      allRows.push(...rows);
+    }
+
+    affectedSymbols = allRows.map(r => ({ name: r.name, filePath: r.file_path, label: r.label }));
+    affectedSymbolIds = allRows.map(r => r.id);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     return { changedFiles, affectedSymbols: [], affectedProcesses: [], error: message };
@@ -83,15 +91,22 @@ export function detectMonographChanges(
 
   if (affectedSymbolIds.length > 0) {
     try {
-      const placeholders = affectedSymbolIds.map(() => '?').join(',');
-      const processRows = db
-        .prepare(
-          `SELECT DISTINCT n.id, n.name
-           FROM nodes n JOIN edges e ON n.id = e.source_id
-           WHERE e.relation = 'STEP_IN_PROCESS' AND e.target_id IN (${placeholders})`,
-        )
-        .all(...affectedSymbolIds) as Array<{ id: string; name: string }>;
-      affectedProcesses = processRows;
+      // Also batch symbol IDs to keep IN clause bounded
+      const BATCH = 50;
+      const processSet = new Map<string, string>();
+      for (let i = 0; i < affectedSymbolIds.length; i += BATCH) {
+        const batch = affectedSymbolIds.slice(i, i + BATCH);
+        const placeholders = batch.map(() => '?').join(',');
+        const processRows = db
+          .prepare(
+            `SELECT DISTINCT n.id, n.name
+             FROM nodes n JOIN edges e ON n.id = e.source_id
+             WHERE e.relation = 'STEP_IN_PROCESS' AND e.target_id IN (${placeholders})`,
+          )
+          .all(...batch) as Array<{ id: string; name: string }>;
+        for (const row of processRows) processSet.set(row.id, row.name);
+      }
+      affectedProcesses = Array.from(processSet.entries()).map(([id, name]) => ({ id, name }));
     } catch {
       // Non-fatal: return what we have
     }

package/src/mcp-tools/explain.ts

@@ -40,7 +40,10 @@ export function explainNode(db: Database.Database, name: string): ExplainResult
   ).all(node.id) as { name: string; relation: string }[];
 
   const connectionCount = outRows.length + inRows.length;
-  const fileLine = node.filePath ? ` defined in \`${node.filePath}\`` : '';
+  const fileRef = node.filePath
+    ? (node.startLine != null ? `${node.filePath}:${node.startLine}` : node.filePath)
+    : null;
+  const fileLine = fileRef ? ` defined in \`${fileRef}\`` : '';
 
   let explanation = `**${node.name}** is a ${node.label}${fileLine}.`;
 

package/src/mcp-tools/graph-query.ts

@@ -20,6 +20,8 @@ function rowToNode(row: Record<string, unknown>): MonographNode {
 export interface GraphQueryInput {
   query: string;
   mode?: 'bfs' | 'dfs';
+  /** Direction of edge traversal. 'both' includes incoming edges (callers) and outgoing (callees). Default: 'out' */
+  direction?: 'out' | 'in' | 'both';
   tokenBudget?: number;
   depth?: number;
 }
@@ -40,6 +42,7 @@ export function queryGraph(
   input: GraphQueryInput,
 ): GraphQueryResult {
   const mode = input.mode ?? 'bfs';
+  const direction = input.direction ?? 'out';
   const tokenBudget = input.tokenBudget ?? 2000;
   const maxDepth = input.depth ?? 3;
 
@@ -64,15 +67,33 @@ export function queryGraph(
   if (!truncated) {
     // BFS or DFS expansion
     const frontier: Array<{ id: string; depth: number }> = seeds.map(s => ({ id: s.id, depth: 0 }));
-    const edgeStmt = db.prepare(
+
+    // Prepare edge traversal statements for each direction.
+    // 'out' follows outgoing edges (what this node calls/imports/uses).
+    // 'in' follows incoming edges (what calls/imports/uses this node).
+    // 'both' follows both directions — needed for full context (callers + callees).
+    const outEdgeStmt = db.prepare(
       `SELECT n.* FROM nodes n JOIN edges e ON n.id = e.target_id WHERE e.source_id = ? LIMIT 20`
     );
+    const inEdgeStmt = db.prepare(
+      `SELECT n.* FROM nodes n JOIN edges e ON n.id = e.source_id WHERE e.target_id = ? LIMIT 20`
+    );
+    const getNeighbors = (id: string): Record<string, unknown>[] => {
+      if (direction === 'out') return outEdgeStmt.all(id) as Record<string, unknown>[];
+      if (direction === 'in') return inEdgeStmt.all(id) as Record<string, unknown>[];
+      // 'both': union of outgoing and incoming, deduplicated by id
+      const outRows = outEdgeStmt.all(id) as Record<string, unknown>[];
+      const inRows = inEdgeStmt.all(id) as Record<string, unknown>[];
+      const seen = new Set(outRows.map(r => r['id'] as string));
+      return [...outRows, ...inRows.filter(r => !seen.has(r['id'] as string))];
+    };
+
 
     if (mode === 'bfs') {
       while (frontier.length > 0 && !truncated) {
         const { id, depth } = frontier.shift()!;
         if (depth >= maxDepth) continue;
-        const neighbors = edgeStmt.all(id) as Record<string, unknown>[];
+        const neighbors = getNeighbors(id);
         for (const row of neighbors) {
           const node = rowToNode(row);
           if (visited.has(node.id)) continue;
@@ -89,7 +110,7 @@ export function queryGraph(
       while (stack.length > 0 && !truncated) {
         const { id, depth } = stack.pop()!;
         if (depth >= maxDepth) continue;
-        const neighbors = edgeStmt.all(id) as Record<string, unknown>[];
+        const neighbors = getNeighbors(id);
         for (let i = neighbors.length - 1; i >= 0; i--) {
           const node = rowToNode(neighbors[i]!);
           if (visited.has(node.id)) continue;

package/src/mcp-tools/group-list.ts

@@ -14,6 +14,7 @@ export interface GroupRepoInfo {
   path: string;
   indexedAt: string | null;
   nodeCount: number;
+  error?: string;
 }
 
 export interface GroupListResult {
@@ -29,13 +30,12 @@ function getRepoDbPath(repoPath: string): string {
   return join(repoPath, '.monomind', 'monograph.db');
 }
 
-function readRepStats(
-  repoName: string,
+function readRepoStats(
   repoPath: string,
-): { indexedAt: string | null; nodeCount: number } {
+): { indexedAt: string | null; nodeCount: number; error?: string } {
   const dbPath = getRepoDbPath(repoPath);
   if (!existsSync(dbPath)) {
-    return { indexedAt: null, nodeCount: 0 };
+    return { indexedAt: null, nodeCount: 0, error: 'index not found' };
   }
 
   let db: Database.Database | null = null;
@@ -48,13 +48,10 @@ function readRepStats(
 
     const countRow = db.prepare(`SELECT COUNT(*) as cnt FROM nodes`).get() as { cnt: number };
 
-    return {
-      indexedAt: metaRow?.value ?? null,
-      nodeCount: countRow.cnt,
-    };
+    return { indexedAt: metaRow?.value ?? null, nodeCount: countRow.cnt };
   } catch (err) {
-    console.warn(`[group-list] Error reading repo "${repoName}": ${err}`);
-    return { indexedAt: null, nodeCount: 0 };
+    const message = err instanceof Error ? err.message : String(err);
+    return { indexedAt: null, nodeCount: 0, error: message };
   } finally {
     db?.close();
   }
@@ -70,12 +67,13 @@ export async function getGroupList(configPath?: string): Promise<GroupListResult
   const config = parseGroupConfig(resolvedPath);
 
   const repos: GroupRepoInfo[] = config.repos.map((repo) => {
-    const { indexedAt, nodeCount } = readRepStats(repo.name, repo.path);
+    const { indexedAt, nodeCount, error } = readRepoStats(repo.path);
     return {
       name: repo.name,
       path: repo.path,
       indexedAt,
       nodeCount,
+      ...(error ? { error } : {}),
     };
   });