@monoes/monograph 1.5.6 → 1.5.8

package/src/pipeline/phases/docs-parse.ts

@@ -1,307 +0,0 @@
-import { readFileSync, statSync } from 'fs';
-import { extname, basename, join } from 'path';
-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 { StructureOutput } from './structure.js';
-
-const DOC_EXTENSIONS = new Set(['.md', '.mdx', '.txt', '.rst']);
-
-interface HeadingEntry {
-  level: number;
-  title: string;
-  startLine: number;
-  endLine: number;
-  content: string;
-}
-
-interface LinkRef {
-  target: string;
-  isWiki: boolean;
-}
-
-export interface DocsParseOutput {
-  sectionNodes: MonographNode[];
-  docFiles: number;
-}
-
-// ── Frontmatter ───────────────────────────────────────────────────────────────
-
-function parseFrontmatter(text: string): { meta: Record<string, unknown>; body: string; lineOffset: number } {
-  const fmMatch = text.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n/);
-  if (!fmMatch) return { meta: {}, body: text, lineOffset: 0 };
-
-  const yaml = fmMatch[1];
-  const meta: Record<string, unknown> = {};
-  let currentKey: string | null = null;
-
-  for (const line of yaml.split('\n')) {
-    const keyOnlyMatch = line.match(/^(\w[\w-]*)\s*:\s*$/);
-    if (keyOnlyMatch) {
-      currentKey = keyOnlyMatch[1];
-      meta[currentKey] = [];
-      continue;
-    }
-    const itemMatch = line.match(/^\s+-\s+(.+)$/);
-    if (itemMatch && currentKey && Array.isArray(meta[currentKey])) {
-      (meta[currentKey] as string[]).push(itemMatch[1].trim().replace(/^["']|["']$/g, ''));
-      continue;
-    }
-    if (line && !line.match(/^\s/)) currentKey = null;
-    const kvMatch = line.match(/^(\w[\w-]*)\s*:\s*(.+)$/);
-    if (!kvMatch) continue;
-    const key = kvMatch[1];
-    const val = kvMatch[2].trim();
-    if (val.startsWith('[')) {
-      meta[key] = val.slice(1, -1).split(',').map(s => s.trim().replace(/^["']|["']$/g, ''));
-    } else {
-      meta[key] = val.replace(/^["']|["']$/g, '');
-    }
-  }
-
-  const lineOffset = fmMatch[0].split('\n').length - 1;
-  return { meta, body: text.slice(fmMatch[0].length), lineOffset };
-}
-
-// ── Heading extraction ────────────────────────────────────────────────────────
-
-function extractHeadings(body: string, lineOffset: number): HeadingEntry[] {
-  const lines = body.split('\n');
-  const positions: Array<{ level: number; title: string; idx: number }> = [];
-
-  for (let i = 0; i < lines.length; i++) {
-    const m = lines[i].match(/^(#{1,6})\s+(.+?)(?:\s+#+)?$/);
-    if (m) positions.push({ level: m[1].length, title: m[2].trim(), idx: i });
-  }
-
-  return positions.map((h, i) => {
-    const nextIdx = positions[i + 1]?.idx ?? lines.length;
-    return {
-      level: h.level,
-      title: h.title,
-      startLine: lineOffset + h.idx + 1,
-      endLine: lineOffset + nextIdx,
-      content: lines.slice(h.idx + 1, nextIdx).join('\n').trim(),
-    };
-  });
-}
-
-// ── Link extraction ───────────────────────────────────────────────────────────
-
-function extractLinks(text: string): LinkRef[] {
-  const links: LinkRef[] = [];
-  for (const m of text.matchAll(/\[\[([^\]|#]+)(?:[|#][^\]]+)?\]\]/g)) {
-    links.push({ target: m[1].trim(), isWiki: true });
-  }
-  for (const m of text.matchAll(/\[[^\]]+\]\(([^)]+\.mdx?(?:#[^)]*)?)\)/g)) {
-    const href = m[1].split('#')[0].trim();
-    if (!href.startsWith('http')) links.push({ target: href, isWiki: false });
-  }
-  return links;
-}
-
-// ── Tag extraction ────────────────────────────────────────────────────────────
-
-function extractTags(text: string, meta: Record<string, unknown>): string[] {
-  const tags = new Set<string>();
-  for (const key of ['tags', 'tag', 'categories', 'category']) {
-    const v = meta[key];
-    if (Array.isArray(v)) v.forEach(t => typeof t === 'string' && tags.add(t.toLowerCase()));
-    else if (typeof v === 'string') tags.add(v.toLowerCase());
-  }
-  for (const m of text.matchAll(/(?<![a-z0-9])#([a-z][a-z0-9_-]+)/gi)) {
-    tags.add(m[1].toLowerCase());
-  }
-  return [...tags];
-}
-
-// ── Phase ─────────────────────────────────────────────────────────────────────
-
-export const docsParsePhase: PipelinePhase<DocsParseOutput> = {
-  name: 'docs-parse',
-  deps: ['structure'],
-
-  async execute(ctx, deps) {
-    // Respect codeOnly flag
-    if (ctx.options.codeOnly) return { sectionNodes: [], docFiles: 0 };
-
-    const { fileNodes } = deps.get('structure') as StructureOutput;
-    const docFiles = fileNodes.filter(n => n.filePath && DOC_EXTENSIONS.has(extname(n.filePath).toLowerCase()));
-    if (docFiles.length === 0) return { sectionNodes: [], docFiles: 0 };
-
-    const fileByRel = new Map<string, MonographNode>(docFiles.map(n => [n.filePath!, n]));
-    const fileByName = new Map<string, MonographNode>(
-      docFiles.map(n => [basename(n.filePath!).replace(/\.mdx?$/, '').toLowerCase(), n])
-    );
-
-    const sectionNodes: MonographNode[] = [];
-    // Key: `${fileId}::${normTitle}` to avoid cross-file title collisions
-    const sectionByKey = new Map<string, MonographNode>();
-    const conceptNodes = new Map<string, MonographNode>();
-    const allEdges: MonographEdge[] = [];
-    const deferredRefs: Array<{ sourceId: string; fileId: string; target: string; isWiki: boolean }> = [];
-
-    for (const fileNode of docFiles) {
-      const absPath = join(ctx.repoPath, fileNode.filePath!);
-      let text: string;
-      try {
-        const st = statSync(absPath);
-        if (st.size > ctx.options.maxFileSizeBytes) continue;
-        text = readFileSync(absPath, 'utf-8');
-      } catch { continue; }
-
-      const { meta, body, lineOffset } = parseFrontmatter(text);
-      const headings = extractHeadings(body, lineOffset);
-      const fileTags = extractTags('', meta);
-
-      // No headings → single Section node for the whole file
-      if (headings.length === 0) {
-        const title = (meta['title'] as string | undefined) ?? basename(fileNode.filePath!).replace(/\.[^.]+$/, '');
-        const sectionId = makeId('section', fileNode.id, 'root');
-        const node: MonographNode = {
-          id: sectionId, label: 'Section',
-          name: title, normLabel: toNormLabel(title),
-          filePath: fileNode.filePath, startLine: 1, endLine: text.split('\n').length,
-          isExported: false,
-          properties: { ...meta, level: 0, content: body.slice(0, 2000) },
-        };
-        sectionNodes.push(node);
-        sectionByKey.set(`${fileNode.id}::${toNormLabel(title)}`, node);
-
-        allEdges.push({
-          id: makeId(fileNode.id, sectionId, 'defines'),
-          sourceId: fileNode.id, targetId: sectionId,
-          relation: 'DEFINES', confidence: 'EXTRACTED', confidenceScore: CONFIDENCE_SCORE.EXTRACTED,
-        });
-
-        wireTagEdges(sectionId, fileTags, conceptNodes, allEdges);
-        for (const lnk of extractLinks(body)) deferredRefs.push({ sourceId: sectionId, fileId: fileNode.id, ...lnk });
-        continue;
-      }
-
-      // Preamble content: text before the first heading
-      const firstHeadingStart = headings[0].startLine - lineOffset - 1;
-      const preamble = body.split('\n').slice(0, firstHeadingStart).join('\n').trim();
-
-      // Build section nodes with parent hierarchy
-      const stack: Array<{ level: number; id: string }> = [];
-      let firstSectionId: string | null = null;
-
-      for (const h of headings) {
-        const sectionId = makeId('section', fileNode.id, toNormLabel(h.title), String(h.startLine));
-        if (!firstSectionId) firstSectionId = sectionId;
-
-        const node: MonographNode = {
-          id: sectionId, label: 'Section',
-          name: h.title, normLabel: toNormLabel(h.title),
-          filePath: fileNode.filePath, startLine: h.startLine, endLine: h.endLine,
-          isExported: false,
-          properties: { ...meta, level: h.level, content: h.content.slice(0, 2000) },
-        };
-        sectionNodes.push(node);
-        // Scoped key: fileId::normTitle — prevents cross-file title collisions
-        sectionByKey.set(`${fileNode.id}::${toNormLabel(h.title)}`, node);
-
-        // File → Section (DEFINES)
-        allEdges.push({
-          id: makeId(fileNode.id, sectionId, 'defines'),
-          sourceId: fileNode.id, targetId: sectionId,
-          relation: 'DEFINES', confidence: 'EXTRACTED', confidenceScore: CONFIDENCE_SCORE.EXTRACTED,
-        });
-
-        // Parent section → this section (PARENT_SECTION)
-        while (stack.length > 0 && stack[stack.length - 1].level >= h.level) stack.pop();
-        if (stack.length > 0) {
-          const parentId = stack[stack.length - 1].id;
-          allEdges.push({
-            id: makeId(parentId, sectionId, 'parent_section'),
-            sourceId: parentId, targetId: sectionId,
-            relation: 'PARENT_SECTION', confidence: 'EXTRACTED', confidenceScore: CONFIDENCE_SCORE.EXTRACTED,
-          });
-        }
-        stack.push({ level: h.level, id: sectionId });
-
-        wireTagEdges(sectionId, extractTags(h.content, {}), conceptNodes, allEdges);
-        for (const lnk of extractLinks(h.content)) deferredRefs.push({ sourceId: sectionId, fileId: fileNode.id, ...lnk });
-      }
-
-      // Preamble links/tags → attach to first section
-      if (preamble && firstSectionId) {
-        wireTagEdges(firstSectionId, extractTags(preamble, {}), conceptNodes, allEdges);
-        for (const lnk of extractLinks(preamble)) deferredRefs.push({ sourceId: firstSectionId, fileId: fileNode.id, ...lnk });
-      }
-
-      // Frontmatter tags → first section
-      if (fileTags.length > 0 && firstSectionId) {
-        wireTagEdges(firstSectionId, fileTags, conceptNodes, allEdges);
-      }
-    }
-
-    // Resolve deferred REFERENCES edges
-    // Wiki links resolve within the same file first, then fall back to cross-file
-    const seenRefs = new Set<string>();
-    for (const ref of deferredRefs as Array<{ sourceId: string; fileId: string; target: string; isWiki: boolean }>) {
-      let target: MonographNode | undefined;
-
-      if (ref.isWiki) {
-        // Same-file resolution first (avoids cross-file title collisions)
-        const normTarget = toNormLabel(ref.target);
-        target = sectionByKey.get(`${ref.fileId}::${normTarget}`);
-        if (!target) {
-          // Cross-file: search all files for matching title
-          for (const [key, node] of sectionByKey) {
-            if (key.endsWith(`::${normTarget}`)) { target = node; break; }
-          }
-        }
-        if (!target) target = fileByName.get(normTarget);
-      } else {
-        target = fileByRel.get(ref.target.replace(/^\.\//, ''))
-          ?? fileByName.get(basename(ref.target).replace(/\.mdx?$/, '').toLowerCase());
-      }
-
-      if (target) {
-        const edgeId = makeId(ref.sourceId, target.id, 'references');
-        if (!seenRefs.has(edgeId)) {
-          seenRefs.add(edgeId);
-          allEdges.push({
-            id: edgeId, sourceId: ref.sourceId, targetId: target.id,
-            relation: 'REFERENCES', confidence: 'EXTRACTED', confidenceScore: CONFIDENCE_SCORE.EXTRACTED,
-          });
-        }
-      }
-    }
-
-    // File nodes are never persisted by structure/parse phases — insert them here
-    // so DEFINES/REFERENCES edges can satisfy FK constraints.
-    insertNodes(ctx.db, docFiles);
-    if (sectionNodes.length > 0) insertNodes(ctx.db, sectionNodes);
-    if (conceptNodes.size > 0) insertNodes(ctx.db, [...conceptNodes.values()]);
-    if (allEdges.length > 0) insertEdges(ctx.db, allEdges);
-
-    ctx.onProgress?.({ phase: 'docs-parse', message: `Parsed ${docFiles.length} doc files → ${sectionNodes.length} sections` });
-    return { sectionNodes, docFiles: docFiles.length };
-  },
-};
-
-function wireTagEdges(
-  sourceId: string,
-  tags: string[],
-  conceptNodes: Map<string, MonographNode>,
-  edges: MonographEdge[],
-): void {
-  for (const tag of tags) {
-    const conceptId = makeId('concept', tag.replace(/[^a-z0-9]/g, '_'));
-    if (!conceptNodes.has(conceptId)) {
-      conceptNodes.set(conceptId, {
-        id: conceptId, label: 'Concept', name: tag, normLabel: toNormLabel(tag), isExported: false,
-      });
-    }
-    edges.push({
-      id: makeId(sourceId, conceptId, 'tagged_as'),
-      sourceId, targetId: conceptId,
-      relation: 'TAGGED_AS', confidence: 'EXTRACTED', confidenceScore: CONFIDENCE_SCORE.EXTRACTED,
-    });
-  }
-}

package/src/pipeline/phases/evidence.ts

@@ -1,9 +0,0 @@
-import type { EvidenceEntry } from '../../types.js';
-
-export function makeEvidence(kind: string, weight: number, note?: string): EvidenceEntry {
-  return { kind, weight: Math.max(0, Math.min(1, weight)), note };
-}
-
-export function mergeEvidence(existing: EvidenceEntry[] | undefined, entry: EvidenceEntry): EvidenceEntry[] {
-  return [...(existing ?? []), entry];
-}

package/src/pipeline/phases/field-access.ts

@@ -1,49 +0,0 @@
-export type AccessReason = 'read' | 'write';
-
-export interface FieldAccess {
-  varName: string;
-  field: string;
-  reason: AccessReason;
-  line: number;
-}
-
-function escapeRegexChars(s: string): string {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-
-export function extractFieldAccesses(source: string, varName: string, filePath: string): FieldAccess[] {
-  const results: FieldAccess[] = [];
-  const lines = source.split('\n');
-  const escapedName = escapeRegexChars(varName);
-
-  // Hoist regex construction outside the loop — both patterns are fixed for the
-  // entire call, so creating them once avoids O(lines) RegExp allocations.
-  // Write: varName.field = or varName.field +=/-=/*=
-  const writeRe = new RegExp(`\\b${escapedName}\\.(\\w+)\\s*(?:\\+|-|\\*|\\/|%)?=(?!=)`, 'g');
-  // Read: varName.field NOT followed by assignment operator
-  const readRe = new RegExp(`\\b${escapedName}\\.(\\w+)`, 'g');
-
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-
-    // Reset stateful lastIndex before each line (required for reused /g regexes).
-    writeRe.lastIndex = 0;
-    readRe.lastIndex = 0;
-
-    const writeFields = new Set<string>();
-    let m: RegExpExecArray | null;
-
-    while ((m = writeRe.exec(line)) !== null) {
-      writeFields.add(m[1]);
-      results.push({ varName, field: m[1], reason: 'write', line: i + 1 });
-    }
-
-    while ((m = readRe.exec(line)) !== null) {
-      if (!writeFields.has(m[1])) {
-        results.push({ varName, field: m[1], reason: 'read', line: i + 1 });
-      }
-    }
-  }
-
-  return results;
-}

package/src/pipeline/phases/framework-detect.ts

@@ -1,109 +0,0 @@
-import { existsSync, readFileSync } from 'fs';
-import { join } from 'path';
-import type { PipelinePhase, PipelineContext } from '../types.js';
-
-export type SupportedFramework =
-  | 'react' | 'vue' | 'angular' | 'svelte'
-  | 'express' | 'fastify' | 'nestjs' | 'koa'
-  | 'django' | 'flask' | 'fastapi'
-  | 'spring' | 'rails' | 'laravel';
-
-export type PrimaryLanguage = 'javascript' | 'python' | 'java' | 'ruby' | 'php' | null;
-
-export interface FrameworkDetectOutput {
-  frameworks: SupportedFramework[];
-  primaryLanguage: PrimaryLanguage;
-  confidence: Record<SupportedFramework, number>;
-}
-
-const NPM_FRAMEWORK_MAP: Record<string, SupportedFramework> = {
-  'react': 'react', 'react-dom': 'react',
-  'vue': 'vue', '@vue/core': 'vue',
-  '@angular/core': 'angular',
-  'svelte': 'svelte',
-  'express': 'express',
-  'fastify': 'fastify',
-  '@nestjs/core': 'nestjs',
-  'koa': 'koa',
-};
-
-const PYTHON_FRAMEWORK_MAP: Record<string, SupportedFramework> = {
-  'Django': 'django', 'django': 'django',
-  'Flask': 'flask', 'flask': 'flask',
-  'fastapi': 'fastapi', 'FastAPI': 'fastapi',
-};
-
-export function detectFrameworks(repoPath: string): FrameworkDetectOutput {
-  const detected = new Map<SupportedFramework, number>();
-  let primaryLanguage: PrimaryLanguage = null;
-
-  const pkgPath = join(repoPath, 'package.json');
-  if (existsSync(pkgPath)) {
-    try {
-      const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
-      const allDeps = { ...pkg.dependencies, ...pkg.devDependencies, ...pkg.peerDependencies };
-      for (const dep of Object.keys(allDeps)) {
-        const fw = NPM_FRAMEWORK_MAP[dep];
-        if (fw) {
-          detected.set(fw, Math.max(detected.get(fw) ?? 0, 0.9));
-          primaryLanguage = 'javascript';
-        }
-      }
-    } catch { /* malformed JSON */ }
-  }
-
-  const reqPath = join(repoPath, 'requirements.txt');
-  if (existsSync(reqPath)) {
-    const lines = readFileSync(reqPath, 'utf8').split('\n');
-    for (const line of lines) {
-      const pkg = line.split(/[=><!]/)[0]?.trim() ?? '';
-      const fw = PYTHON_FRAMEWORK_MAP[pkg];
-      if (fw) {
-        detected.set(fw, Math.max(detected.get(fw) ?? 0, 0.9));
-        primaryLanguage = 'python';
-      }
-    }
-  }
-
-  const pomPath = join(repoPath, 'pom.xml');
-  if (existsSync(pomPath)) {
-    const pom = readFileSync(pomPath, 'utf8');
-    if (pom.includes('spring-boot') || pom.includes('spring-web')) {
-      detected.set('spring', Math.max(detected.get('spring') ?? 0, 0.85));
-      primaryLanguage = 'java';
-    }
-  }
-
-  const gemfilePath = join(repoPath, 'Gemfile');
-  if (existsSync(gemfilePath)) {
-    const gemfile = readFileSync(gemfilePath, 'utf8');
-    if (gemfile.includes("gem 'rails'") || gemfile.includes('gem "rails"')) {
-      detected.set('rails', Math.max(detected.get('rails') ?? 0, 0.9));
-      primaryLanguage = 'ruby';
-    }
-  }
-
-  const composerPath = join(repoPath, 'composer.json');
-  if (existsSync(composerPath)) {
-    try {
-      const composer = JSON.parse(readFileSync(composerPath, 'utf8'));
-      const reqs = { ...composer.require, ...composer['require-dev'] };
-      if (reqs['laravel/framework']) {
-        detected.set('laravel', Math.max(detected.get('laravel') ?? 0, 0.9));
-        primaryLanguage = 'php';
-      }
-    } catch { /* malformed JSON */ }
-  }
-
-  const frameworks = [...detected.keys()];
-  const confidence = Object.fromEntries(detected) as Record<SupportedFramework, number>;
-  return { frameworks, primaryLanguage, confidence };
-}
-
-export const frameworkDetectPhase: PipelinePhase<FrameworkDetectOutput> = {
-  name: 'framework-detect',
-  deps: ['scan'],
-  async execute(ctx: PipelineContext): Promise<FrameworkDetectOutput> {
-    return detectFrameworks(ctx.repoPath);
-  },
-};

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');
-}