@monoes/monograph 1.5.5 → 1.5.7

package/src/pipeline/phases/god-nodes.ts

@@ -1,163 +0,0 @@
-import type { PipelinePhase, PipelineContext } from '../types.js';
-import type { GodNode, MonographEdge } from '../../types.js';
-import type { ParseOutput } from './parse.js';
-import type { CrossFileOutput } from './cross-file.js';
-
-const EXCLUDED_LABELS = new Set(['File', 'Folder', 'Community', 'Concept']);
-
-// Test files stay in the graph (useful for impact/navigation) but are excluded
-// from centrality rankings — a heavily-importing test suite is not a god node.
-const TEST_PATH_RE = /(\.test\.|\.spec\.|__tests__|__mocks__)/;
-function isTestNode(n: { filePath?: string | null }): boolean {
-  return !!(n.filePath && TEST_PATH_RE.test(n.filePath));
-}
-
-export type GodNodeCategory =
-  | 'HIGH_CENTRALITY'
-  | 'BRIDGE_NODE'
-  | 'ISOLATED_CLUSTER'
-  | 'CHURN_HOTSPOT'
-  | 'CIRCULAR_IMPORT'
-  | 'UNREACHABLE';
-
-export interface ContributingFactor {
-  metric: string;
-  value: number;
-  threshold: number;
-}
-
-export interface GodNodesThresholds {
-  p75FanIn: number;
-  p90FanIn: number;
-  p95FanIn: number;
-  p75FanOut: number;
-  p90FanOut: number;
-}
-
-export interface GodNodesOutput {
-  godNodes: (GodNode & { category: GodNodeCategory; contributingFactors: ContributingFactor[] })[];
-  thresholds: GodNodesThresholds;
-}
-
-function percentile(sorted: number[], p: number): number {
-  if (sorted.length === 0) return 0;
-  const idx = Math.floor((p / 100) * sorted.length);
-  return sorted[Math.min(idx, sorted.length - 1)];
-}
-
-export const godNodesPhase: PipelinePhase<GodNodesOutput> = {
-  name: 'god-nodes',
-  deps: ['cross-file', 'parse'],
-  async execute(ctx, deps) {
-    const { resolvedEdges } = deps.get('cross-file') as CrossFileOutput;
-    const { allEdges, symbolNodes } = deps.get('parse') as ParseOutput;
-    const allEdgesCombined: MonographEdge[] = [...allEdges, ...resolvedEdges];
-
-    const inDeg = new Map<string, number>();
-    const outDeg = new Map<string, number>();
-    for (const e of allEdgesCombined) {
-      outDeg.set(e.sourceId, (outDeg.get(e.sourceId) ?? 0) + 1);
-      inDeg.set(e.targetId, (inDeg.get(e.targetId) ?? 0) + 1);
-    }
-
-    // Compute degree distributions from all symbol nodes in a single pass
-    // (avoids two separate filter + map passes over potentially large arrays)
-    const allFanIn: number[] = [];
-    const allFanOut: number[] = [];
-    for (const n of symbolNodes) {
-      if (EXCLUDED_LABELS.has(n.label) || isTestNode(n)) continue;
-      allFanIn.push(inDeg.get(n.id) ?? 0);
-      allFanOut.push(outDeg.get(n.id) ?? 0);
-    }
-    allFanIn.sort((a, b) => a - b);
-    allFanOut.sort((a, b) => a - b);
-
-    const thresholds: GodNodesThresholds = {
-      p75FanIn: percentile(allFanIn, 75),
-      p90FanIn: percentile(allFanIn, 90),
-      p95FanIn: percentile(allFanIn, 95),
-      p75FanOut: percentile(allFanOut, 75),
-      p90FanOut: percentile(allFanOut, 90),
-    };
-
-    const p95FanIn = thresholds.p95FanIn;
-    const p75FanIn = thresholds.p75FanIn;
-    const p75FanOut = thresholds.p75FanOut;
-
-    const godNodes = symbolNodes
-      .filter(n => !EXCLUDED_LABELS.has(n.label) && !isTestNode(n)
-        && (inDeg.get(n.id) ?? 0) + (outDeg.get(n.id) ?? 0) > p95FanIn)
-      .map(n => {
-        const fanIn = inDeg.get(n.id) ?? 0;
-        const fanOut = outDeg.get(n.id) ?? 0;
-        const degree = fanIn + fanOut;
-
-        const contributingFactors: ContributingFactor[] = [];
-        if (fanIn > p95FanIn) {
-          contributingFactors.push({ metric: 'fanIn', value: fanIn, threshold: p95FanIn });
-        }
-        if (fanIn > p75FanIn) {
-          contributingFactors.push({ metric: 'fanInP75', value: fanIn, threshold: p75FanIn });
-        }
-        if (fanOut > p75FanOut) {
-          contributingFactors.push({ metric: 'fanOut', value: fanOut, threshold: p75FanOut });
-        }
-
-        let category: GodNodeCategory;
-        if (fanIn > p95FanIn && fanOut > p75FanOut) {
-          category = 'BRIDGE_NODE';
-        } else {
-          category = 'HIGH_CENTRALITY';
-        }
-
-        return {
-          ...n,
-          inDegree: fanIn,
-          outDegree: fanOut,
-          degree,
-          category,
-          contributingFactors,
-        };
-      })
-      .sort((a, b) => b.degree - a.degree)
-      .slice(0, 20);
-
-    return { godNodes, thresholds };
-  },
-};
-
-/**
- * Format god-node results as structured text with file:line hints for LLM navigation.
- */
-export function formatGodNodes(output: GodNodesOutput): string {
-  const { godNodes, thresholds } = output;
-  if (godNodes.length === 0) {
-    return 'god-nodes: none\nstatus: no high-centrality nodes detected\n';
-  }
-
-  const lines: string[] = [
-    `god-nodes: ${godNodes.length} high-centrality node(s) detected`,
-    `thresholds: fanIn p75=${thresholds.p75FanIn} p90=${thresholds.p90FanIn} p95=${thresholds.p95FanIn}; fanOut p75=${thresholds.p75FanOut} p90=${thresholds.p90FanOut}`,
-    '',
-  ];
-
-  for (let i = 0; i < godNodes.length; i++) {
-    const n = godNodes[i];
-    const loc = n.filePath
-      ? `${n.filePath}${n.startLine !== undefined ? `:${n.startLine}` : ''}`
-      : n.id;
-    lines.push(`[${i + 1}] ${n.name} (${n.label}) — ${n.category}`);
-    lines.push(`  file: ${loc}`);
-    lines.push(`  degree: ${n.degree} (fanIn=${n.inDegree}, fanOut=${n.outDegree})`);
-    for (const f of n.contributingFactors) {
-      lines.push(`  factor: ${f.metric}=${f.value} (threshold=${f.threshold})`);
-    }
-    lines.push('');
-  }
-
-  const bridgeCount = godNodes.filter(n => n.category === 'BRIDGE_NODE').length;
-  const highCentralityCount = godNodes.length - bridgeCount;
-  lines.push(`summary: ${highCentralityCount} HIGH_CENTRALITY, ${bridgeCount} BRIDGE_NODE`);
-
-  return lines.join('\n');
-}

package/src/pipeline/phases/import-resolver.ts

@@ -1,114 +0,0 @@
-import { readFileSync, readdirSync } from 'fs';
-import { join, resolve } from 'path';
-import type { PipelinePhase, PipelineContext } from '../types.js';
-
-export interface WorkspacePackage {
-  name: string;
-  path: string;
-}
-
-export interface ImportResolverOutput {
-  workspacePackages: WorkspacePackage[];
-  resolvedCount: number;
-}
-
-function globWorkspacePattern(repoPath: string, pattern: string): string[] {
-  if (!pattern.includes('*')) {
-    return [join(repoPath, pattern)];
-  }
-  const [base] = pattern.split('/*');
-  const baseDir = join(repoPath, base ?? '');
-  // Skip existsSync — readdirSync will throw ENOENT which the catch already handles.
-  try {
-    return readdirSync(baseDir, { withFileTypes: true })
-      .filter(d => d.isDirectory())
-      .map(d => join(baseDir, d.name));
-  } catch {
-    return [];
-  }
-}
-
-export function detectWorkspacePackages(repoPath: string): WorkspacePackage[] {
-  const pkgPath = join(repoPath, 'package.json');
-  let workspaceGlobs: string[] = [];
-  try {
-    const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
-    const ws = pkg.workspaces;
-    if (Array.isArray(ws)) workspaceGlobs = ws;
-    else if (ws && Array.isArray(ws.packages)) workspaceGlobs = ws.packages;
-  } catch {
-    return [];
-  }
-
-  const result: WorkspacePackage[] = [];
-  for (const glob of workspaceGlobs) {
-    const dirs = globWorkspacePattern(repoPath, glob);
-    for (const dir of dirs) {
-      const subPkgPath = join(dir, 'package.json');
-      try {
-        // existsSync guard removed — readFileSync throws ENOENT which the catch handles.
-        const subPkg = JSON.parse(readFileSync(subPkgPath, 'utf8'));
-        if (subPkg.name) {
-          result.push({ name: subPkg.name, path: resolve(dir) });
-        }
-      } catch { /* skip */ }
-    }
-  }
-
-  return result;
-}
-
-export function resolveWorkspaceImport(
-  importSpecifier: string,
-  packages: WorkspacePackage[],
-): string | null {
-  for (const pkg of packages) {
-    if (importSpecifier === pkg.name || importSpecifier.startsWith(pkg.name + '/')) {
-      return pkg.path;
-    }
-  }
-  return null;
-}
-
-/**
- * Build a Map<packageName, packagePath> index from a WorkspacePackage array.
- * Use this when resolveWorkspaceImport will be called many times (e.g. per import
- * statement across a whole repo) to reduce resolution cost from O(N*I) to O(N+I).
- */
-export function buildPackageIndex(packages: WorkspacePackage[]): Map<string, string> {
-  const index = new Map<string, string>();
-  for (const pkg of packages) {
-    index.set(pkg.name, pkg.path);
-  }
-  return index;
-}
-
-/**
- * O(1) workspace import resolution using a pre-built package index.
- * Falls back to prefix scan only for sub-path imports (e.g. `pkg/subpath`).
- */
-export function resolveWorkspaceImportFromIndex(
-  importSpecifier: string,
-  index: Map<string, string>,
-): string | null {
-  // Exact match: O(1)
-  const exact = index.get(importSpecifier);
-  if (exact !== undefined) return exact;
-  // Sub-path import: find the matching package name prefix
-  const slash = importSpecifier.indexOf('/', importSpecifier.startsWith('@') ? importSpecifier.indexOf('/') + 1 : 0);
-  if (slash !== -1) {
-    const pkgName = importSpecifier.slice(0, slash);
-    const path = index.get(pkgName);
-    if (path !== undefined) return path;
-  }
-  return null;
-}
-
-export const importResolverPhase: PipelinePhase<ImportResolverOutput> = {
-  name: 'import-resolver',
-  deps: ['cross-file'],
-  async execute(ctx: PipelineContext): Promise<ImportResolverOutput> {
-    const workspacePackages = detectWorkspacePackages(ctx.repoPath);
-    return { workspacePackages, resolvedCount: 0 };
-  },
-};

package/src/pipeline/phases/leiden.ts

@@ -1,77 +0,0 @@
-import louvain from 'graphology-communities-louvain';
-import type Graph from 'graphology';
-
-/**
- * Leiden-like community detection with post-processing refinement.
- *
- * Since `graphology-communities-leiden` does not exist as a published package,
- * this module implements a two-phase approach that improves on plain Louvain:
- *
- * Phase 1: Run Louvain with randomWalk disabled for deterministic output.
- * Phase 2: Merge singleton communities (size === 1) into the largest
- *           neighboring community, which mirrors the Leiden refinement idea
- *           of guaranteeing well-connected communities.
- *
- * The result is seed-stable because Louvain is run deterministically
- * (randomWalk: false) and the refinement step is purely deterministic.
- *
- * @param graph  Any graphology Graph instance (directed or undirected).
- * @returns      A mapping of nodeId → communityId (numeric).
- */
-export function leiden(graph: Graph, _options: { seed?: number } = {}): Record<string, number> {
-  if (graph.order === 0) {
-    return {};
-  }
-
-  // Phase 1: Louvain with deterministic settings
-  const communities: Record<string, number> = louvain(graph, { randomWalk: false });
-
-  // Phase 2: Refinement — merge singletons into their largest neighbor's community.
-  // Single pass over Object.entries to build both communitySizes and the singletonNodes Set,
-  // avoiding a separate Object.values scan. The singletonNodes Set enables O(1) skip in the
-  // refinement loop below instead of a map.get(commId) <= 1 test per node.
-  const communitySizes = new Map<number, number>();
-  for (const comm of Object.values(communities)) {
-    communitySizes.set(comm, (communitySizes.get(comm) ?? 0) + 1);
-  }
-  const singletonNodes = new Set<string>();
-  for (const [nodeId, commId] of Object.entries(communities)) {
-    if ((communitySizes.get(commId) ?? 0) <= 1) singletonNodes.add(nodeId);
-  }
-
-  // Refinement: merge singletons into their largest neighbor's community.
-  // Pass 1: update communitySizes eagerly (so adjacent singletons see each other's moves
-  //         and avoid mutual-swap cycles), collect community writes into `pending`.
-  // Pass 2: apply community writes — keeps the community map consistent at all times.
-  const pending = new Map<string, number>();
-  for (const [nodeId, commId] of Object.entries(communities)) {
-    if (!singletonNodes.has(nodeId)) continue; // O(1) skip for non-singletons
-
-    let bestComm = commId;
-    let bestSize = 0;
-
-    graph.forEachNeighbor(nodeId, (neighbor: string) => {
-      const neighborComm = communities[neighbor];
-      if (neighborComm === undefined) return;
-      const size = communitySizes.get(neighborComm) ?? 0;
-      if (size > bestSize) {
-        bestSize = size;
-        bestComm = neighborComm;
-      }
-    });
-
-    if (bestComm !== commId) {
-      // Update sizes eagerly so subsequent singletons see the correct community sizes
-      communitySizes.set(commId, (communitySizes.get(commId) ?? 1) - 1);
-      communitySizes.set(bestComm, (communitySizes.get(bestComm) ?? 0) + 1);
-      pending.set(nodeId, bestComm);
-    }
-  }
-
-  // Apply deferred community writes
-  for (const [nodeId, bestComm] of pending) {
-    communities[nodeId] = bestComm;
-  }
-
-  return communities;
-}

package/src/pipeline/phases/llm-extract.ts

@@ -1,178 +0,0 @@
-import type { PipelinePhase, PipelineContext } from '../types.js';
-import type { MonographNode, MonographEdge } from '../../types.js';
-import { makeId, toNormLabel, CONFIDENCE_SCORE } from '../../types.js';
-import { insertNodes } from '../../storage/node-store.js';
-import { insertEdges } from '../../storage/edge-store.js';
-import type { EdgeRelation } from '../../types.js';
-
-export interface LlmExtractOutput {
-  triplesExtracted: number;
-  sectionsProcessed: number;
-}
-
-const ALLOWED_RELATIONS = new Set<string>([
-  'DESCRIBES', 'CAUSES', 'CONTRASTS_WITH', 'PART_OF', 'RELATED_TO', 'USES',
-]);
-
-const SYSTEM_PROMPT = `You extract knowledge graph relationships from technical documentation chunks.
-
-Return ONLY a JSON array of relationships, each with:
-- "node_1": first concept (short, specific, lowercase, max 4 words)
-- "node_2": second concept (short, specific, lowercase, max 4 words)
-- "relation": one of DESCRIBES, CAUSES, CONTRASTS_WITH, PART_OF, RELATED_TO, USES
-- "edge": brief 3-6 word phrase describing the relationship
-
-Rules:
-- Concepts must be specific technical terms (not "thing", "item", "way", "use")
-- Maximum 8 relationships per chunk
-- Skip if text is too short, navigational, or has no meaningful concepts
-- Return [] for non-substantive content
-
-Return only valid JSON array, no explanation.`;
-
-interface Triple {
-  node_1: string;
-  node_2: string;
-  relation: string;
-  edge: string;
-}
-
-async function callClaude(content: string): Promise<Triple[] | null> {
-  try {
-    const { claudeCliCall } = await import('../../claude-cli.js');
-    const prompt = `${SYSTEM_PROMPT}\n\n${content.slice(0, 1500)}`;
-    const text = await claudeCliCall(prompt, 30_000);
-    const parsed = JSON.parse(text.match(/\[[\s\S]*\]/)?.[0] ?? '[]');
-    return Array.isArray(parsed) ? parsed as Triple[] : null;
-  } catch {
-    return null;
-  }
-}
-
-export const llmExtractPhase: PipelinePhase<LlmExtractOutput> = {
-  name: 'llm-extract',
-  deps: ['docs-parse', 'pdf-parse'],
-
-  async execute(ctx: PipelineContext) {
-    const maxSections = ctx.options.llmMaxSections;
-
-    if (maxSections <= 0 || ctx.options.codeOnly) {
-      return { triplesExtracted: 0, sectionsProcessed: 0 };
-    }
-
-    const { isClaudeCliAvailable } = await import('../../claude-cli.js');
-    if (!isClaudeCliAvailable()) {
-      // Say so. Returning 0 silently is indistinguishable from "your docs had
-      // nothing to infer", so `--llm` looked like it ran and found nothing —
-      // reported as "silently produces 0 inferred edges" (#43), with the
-      // reasonable but wrong conclusion that an API key was missing.
-      //
-      // No API key is involved: LLM work goes through `claude --print`, which
-      // reuses Claude Code's own auth. The only requirement is that `claude` is
-      // on PATH — which is why this can fail *inside* a Claude Code session,
-      // where users least expect it.
-      console.warn(
-        '[monograph] --llm skipped: the `claude` CLI was not found on PATH.\n' +
-        '  Semantic extraction runs through `claude --print` and needs no ANTHROPIC_API_KEY.\n' +
-        '  Install it with: npm install -g @anthropic-ai/claude-code',
-      );
-      return { triplesExtracted: 0, sectionsProcessed: 0 };
-    }
-
-    // Fetch Section nodes with non-trivial content
-    const sections = ctx.db
-      .prepare(`
-        SELECT id, name, properties FROM nodes
-        WHERE label = 'Section'
-        AND properties IS NOT NULL
-        AND json_extract(properties, '$.content') IS NOT NULL
-        AND length(json_extract(properties, '$.content')) > 200
-        LIMIT ?
-      `)
-      .all(maxSections) as { id: string; name: string; properties: string }[];
-
-    if (sections.length === 0) return { triplesExtracted: 0, sectionsProcessed: 0 };
-
-    const conceptNodes = new Map<string, MonographNode>();
-    const allEdges: MonographEdge[] = [];
-    const seenEdges = new Set<string>();
-    let sectionsProcessed = 0;
-
-    // Fetch existing concept IDs to avoid duplicate node creation
-    const existingConcepts = new Set<string>(
-      (ctx.db.prepare(`SELECT id FROM nodes WHERE label = 'Concept'`).all() as { id: string }[])
-        .map(r => r.id),
-    );
-
-    for (const section of sections) {
-      const props = JSON.parse(section.properties) as Record<string, unknown>;
-      const content = props.content as string | undefined;
-      if (!content) continue;
-
-      const triples = await callClaude(
-        `Section: "${section.name}"\n\n${content}`,
-      );
-      if (!triples || triples.length === 0) continue;
-
-      sectionsProcessed++;
-
-      for (const triple of triples) {
-        const { node_1, node_2, relation, edge } = triple;
-        if (!node_1 || !node_2 || !relation) continue;
-
-        const rel = relation.toUpperCase();
-        if (!ALLOWED_RELATIONS.has(rel)) continue;
-
-        // Normalize concept names (lowercase, collapse spaces)
-        const n1 = node_1.toLowerCase().trim().replace(/\s+/g, '_').replace(/[^a-z0-9_]/g, '');
-        const n2 = node_2.toLowerCase().trim().replace(/\s+/g, '_').replace(/[^a-z0-9_]/g, '');
-        if (!n1 || !n2 || n1 === n2) continue;
-
-        const c1Id = makeId('concept', n1);
-        const c2Id = makeId('concept', n2);
-
-        for (const [cId, cName] of [[c1Id, n1], [c2Id, n2]] as [string, string][]) {
-          if (!conceptNodes.has(cId) && !existingConcepts.has(cId)) {
-            conceptNodes.set(cId, {
-              id: cId, label: 'Concept',
-              name: cName.replace(/_/g, ' '), normLabel: toNormLabel(cName),
-              isExported: false,
-              properties: { source: 'llm', edgeLabel: edge },
-            });
-          }
-        }
-
-        // Section → concept_1 (DESCRIBES)
-        const e1Id = makeId(section.id, c1Id, 'describes');
-        if (!seenEdges.has(e1Id)) {
-          seenEdges.add(e1Id);
-          allEdges.push({
-            id: e1Id, sourceId: section.id, targetId: c1Id,
-            relation: 'DESCRIBES', confidence: 'INFERRED', confidenceScore: CONFIDENCE_SCORE.INFERRED,
-          });
-        }
-
-        // concept_1 → concept_2 (semantic relation)
-        const e2Id = makeId(c1Id, c2Id, rel.toLowerCase());
-        if (!seenEdges.has(e2Id)) {
-          seenEdges.add(e2Id);
-          allEdges.push({
-            id: e2Id, sourceId: c1Id, targetId: c2Id,
-            relation: rel as EdgeRelation, confidence: 'INFERRED', confidenceScore: CONFIDENCE_SCORE.INFERRED,
-            weight: 1,
-          });
-        }
-      }
-    }
-
-    if (conceptNodes.size > 0) insertNodes(ctx.db, [...conceptNodes.values()]);
-    if (allEdges.length > 0) insertEdges(ctx.db, allEdges);
-
-    ctx.onProgress?.({
-      phase: 'llm-extract',
-      message: `LLM processed ${sectionsProcessed} sections → ${allEdges.length} semantic edges, ${conceptNodes.size} new concepts`,
-    });
-
-    return { triplesExtracted: allEdges.length, sectionsProcessed };
-  },
-};

package/src/pipeline/phases/markdown.ts

@@ -1,121 +0,0 @@
-import { readFileSync, statSync } from 'fs';
-import { extname, basename, relative } from 'path';
-import type { PipelinePhase } from '../types.js';
-import type { MonographNode, MonographEdge } from '../../types.js';
-import { makeId, toNormLabel } from '../../types.js';
-import { insertNodes } from '../../storage/node-store.js';
-import { insertEdges } from '../../storage/edge-store.js';
-import type { StructureOutput } from './structure.js';
-
-const MARKDOWN_EXTENSIONS = new Set(['.md', '.mdx']);
-// Inline code span: `identifier`
-const INLINE_CODE_RE = /`([^`]+)`/g;
-// Module-level constant: compiled once per process, not per isIdentifier() call.
-const IDENTIFIER_RE = /^[A-Za-z_$][A-Za-z0-9_$.-]*$/;
-
-export interface MarkdownOutput {
-  documentNodes: MonographNode[];
-  referencesEdges: MonographEdge[];
-}
-
-export const markdownPhase: PipelinePhase<MarkdownOutput> = {
-  name: 'markdown',
-  // Must run after parse so symbols are already in the DB for name lookup.
-  // Also depends on structure to get the list of file nodes.
-  // Runs before communities so REFERENCES edges are visible to graph analyses.
-  deps: ['parse', 'structure'],
-  async execute(ctx, deps) {
-    if (ctx.options.codeOnly) return { documentNodes: [], referencesEdges: [] };
-    const { fileNodes } = deps.get('structure') as StructureOutput;
-    const documentNodes: MonographNode[] = [];
-    const referencesEdges: MonographEdge[] = [];
-
-    const mdFiles = fileNodes.filter(fn => {
-      const ext = extname(fn.name).toLowerCase();
-      return MARKDOWN_EXTENSIONS.has(ext);
-    });
-
-    for (const fileNode of mdFiles) {
-      // fileNode.filePath is already relative per codebase convention
-      const relPath = fileNode.filePath ?? '';
-      const absPath = `${ctx.repoPath}/${relPath}`;
-
-      let source: string;
-      try {
-        const stat = statSync(absPath);
-        if (stat.size > ctx.options.maxFileSizeBytes) continue;
-        source = readFileSync(absPath, 'utf-8');
-      } catch { continue; }
-
-      const nameWithoutExt = basename(relPath).replace(/\.(mdx?)$/, '');
-      // Use 'doc' suffix to avoid collision with the 'file'-suffixed File node
-      const docId = makeId(relPath.replace(/\//g, '_'), 'doc');
-
-      const docNode: MonographNode = {
-        id: docId,
-        label: 'Document',
-        name: nameWithoutExt,
-        normLabel: toNormLabel(nameWithoutExt),
-        filePath: relPath,
-        isExported: false,
-        language: 'markdown',
-      };
-      documentNodes.push(docNode);
-
-      // Extract inline code spans and match against symbol names in the DB
-      if (ctx.db) {
-        const spans = extractCodeSpans(source);
-        // Hoist prepared statement outside the span loop — avoids re-compiling the
-        // SQL query for every identifier in every markdown file (N+1 preparation).
-        const symbolLookup = ctx.db.prepare(
-          `SELECT id FROM nodes WHERE name = ?
-           AND label NOT IN ('File', 'Folder', 'Document')`,
-        );
-
-        for (const span of spans) {
-          // Only match single-word identifiers (not shell commands, paths, etc.)
-          if (!isIdentifier(span)) continue;
-
-          // Exact name match, excluding structural nodes to avoid matching file names
-          const rows = symbolLookup.all(span) as { id: string }[];
-
-          if (rows.length === 1) {
-            const edgeId = makeId(docId, rows[0].id, 'references');
-            referencesEdges.push({
-              id: edgeId,
-              sourceId: docId,
-              targetId: rows[0].id,
-              relation: 'REFERENCES',
-              confidence: 'INFERRED',
-              // Literal 0.8 — intentionally higher than CONFIDENCE_SCORE.INFERRED (0.5)
-              // because inline code span matches are reasonably strong documentation signals.
-              confidenceScore: 0.8,
-            });
-          }
-        }
-      }
-    }
-
-    if (ctx.db) {
-      insertNodes(ctx.db, documentNodes);
-      insertEdges(ctx.db, referencesEdges);
-    }
-
-    return { documentNodes, referencesEdges };
-  },
-};
-
-function extractCodeSpans(source: string): string[] {
-  const spans: string[] = [];
-  let match: RegExpExecArray | null;
-  const re = new RegExp(INLINE_CODE_RE.source, 'g');
-  while ((match = re.exec(source)) !== null) {
-    spans.push(match[1].trim());
-  }
-  return spans;
-}
-
-/** Accept only simple identifiers — letters, digits, underscores, hyphens, dots (for namespaced names). */
-function isIdentifier(span: string): boolean {
-  return IDENTIFIER_RE.test(span);
-}