@monoes/monograph 1.5.6 → 1.5.8

package/src/pipeline/phases/re-export-propagation.ts

@@ -1,160 +0,0 @@
-import type { PipelinePhase, PipelineContext } from '../types.js';
-import { makeId, CONFIDENCE_SCORE } from '../../types.js';
-import { insertEdges } from '../../storage/edge-store.js';
-import type Database from 'better-sqlite3';
-
-export interface ReExportPropagationOutput {
-  propagated: number;
-}
-
-/**
- * Fixed-point re-export chain propagation.
- *
- * After the graph is built, barrel files (index.ts that re-export from sub-modules)
- * create RE_EXPORTS edges pointing to the files they re-export from. A file is
- * "reachable" if:
- *   (a) it has a direct IMPORTS edge targeting one of its symbols or its File node, OR
- *   (b) it is re-exported by a barrel file that is itself reachable (transitively).
- *
- * This prevents false "unreachable" reports for exports behind barrel files.
- *
- * Algorithm: iterative BFS until no new propagations (fixed-point).
- */
-export function propagateReExports(db: Database.Database): ReExportPropagationOutput {
-  // Collect all RE_EXPORTS edges (barrel file → re-exported file), keyed by File node IDs
-  const reExportEdges = db.prepare(
-    `SELECT source_id, target_id FROM edges WHERE relation = 'RE_EXPORTS'`,
-  ).all() as { source_id: string; target_id: string }[];
-
-  if (reExportEdges.length === 0) return { propagated: 0 };
-
-  // Build map: barrelFileId → Set<reExportedFileId>
-  const barrelExports = new Map<string, Set<string>>();
-  for (const e of reExportEdges) {
-    if (!barrelExports.has(e.source_id)) barrelExports.set(e.source_id, new Set());
-    barrelExports.get(e.source_id)!.add(e.target_id);
-  }
-
-  // Determine which File nodes are "reached" — either directly imported (via their File node ID)
-  // or their symbols are imported (join through nodes.file_path).
-  // We build a set of reached file paths to handle both IMPORTS→symbol and IMPORTS→File cases.
-  const reachedFilePaths = new Set<string>(
-    (db.prepare(`
-      SELECT DISTINCT n.file_path
-      FROM edges e
-      JOIN nodes n ON n.id = e.target_id
-      WHERE e.relation = 'IMPORTS'
-        AND n.file_path IS NOT NULL
-    `).all() as { file_path: string }[]).map(r => r.file_path),
-  );
-
-  // Also map File node ID → file_path for barrel lookup
-  const fileIdToPath = new Map<string, string>(
-    (db.prepare(`SELECT id, file_path FROM nodes WHERE label = 'File' AND file_path IS NOT NULL`).all() as
-      { id: string; file_path: string }[]).map(r => [r.id, r.file_path]),
-  );
-
-  // Map file_path → File node ID for inserting synthetic IMPORTS edges
-  const filePathToId = new Map<string, string>();
-  for (const [id, path] of fileIdToPath) filePathToId.set(path, id);
-
-  // Prepare insert for synthetic IMPORTS edge: importer_file → re-exported_file (File node)
-  const insertEdge = db.prepare(`
-    INSERT OR IGNORE INTO edges (id, source_id, target_id, relation, confidence, confidence_score, weight)
-    VALUES (?, ?, ?, 'IMPORTS', 'INFERRED', ?, 1.0)
-  `);
-
-  const addPropagated = db.transaction(
-    (toAdd: Array<{ importerFileId: string; targetFileId: string; targetFilePath: string }>) => {
-      for (const { importerFileId, targetFileId, targetFilePath } of toAdd) {
-        const edgeId = makeId(importerFileId, targetFileId, 'reexport_propagated');
-        insertEdge.run(edgeId, importerFileId, targetFileId, CONFIDENCE_SCORE.INFERRED);
-        reachedFilePaths.add(targetFilePath);
-      }
-    },
-  );
-
-  // ── Preload: avoid per-iteration DB queries inside the BFS while-loop ─────────
-
-  // nodeId → file_path for all nodes (used to resolve importer file paths)
-  const nodeIdToFilePath = new Map<string, string>(
-    (db.prepare(`SELECT id, file_path FROM nodes WHERE file_path IS NOT NULL`)
-      .all() as { id: string; file_path: string }[]).map(r => [r.id, r.file_path]),
-  );
-
-  // barrelFilePath → Set<importerNodeId>: who IMPORTS any node from each barrel file
-  // Load all IMPORTS edges once and group by target file_path
-  const allImportEdges = db.prepare(`
-    SELECT e.source_id, n.file_path AS target_file_path
-    FROM edges e
-    JOIN nodes n ON n.id = e.target_id
-    WHERE e.relation = 'IMPORTS'
-      AND n.file_path IS NOT NULL
-  `).all() as { source_id: string; target_file_path: string }[];
-
-  const barrelImporters = new Map<string, Set<string>>();
-  for (const row of allImportEdges) {
-    let s = barrelImporters.get(row.target_file_path);
-    if (!s) {
-      s = new Set();
-      barrelImporters.set(row.target_file_path, s);
-    }
-    s.add(row.source_id);
-  }
-
-  // ── BFS fixed-point (all lookups now O(1) from preloaded maps) ────────────────
-
-  let totalPropagated = 0;
-  let changed = true;
-
-  while (changed) {
-    changed = false;
-    const toAdd: Array<{ importerFileId: string; targetFileId: string; targetFilePath: string }> = [];
-
-    for (const [barrelFileId, exportedFileIds] of barrelExports) {
-      const barrelFilePath = fileIdToPath.get(barrelFileId);
-      if (!barrelFilePath || !reachedFilePaths.has(barrelFilePath)) continue;
-
-      // O(1) lookup instead of per-barrel DB query
-      const importerNodeIds = barrelImporters.get(barrelFilePath);
-      if (!importerNodeIds) continue;
-
-      for (const importerNodeId of importerNodeIds) {
-        // O(1) lookup instead of per-importer DB query
-        const importerFilePath = nodeIdToFilePath.get(importerNodeId);
-        if (!importerFilePath) continue;
-
-        const importerFileId = filePathToId.get(importerFilePath);
-        if (!importerFileId) continue;
-
-        for (const targetFileId of exportedFileIds) {
-          const targetFilePath = fileIdToPath.get(targetFileId);
-          if (!targetFilePath) continue;
-
-          if (!reachedFilePaths.has(targetFilePath)) {
-            toAdd.push({ importerFileId, targetFileId, targetFilePath });
-          }
-        }
-      }
-    }
-
-    if (toAdd.length > 0) {
-      addPropagated(toAdd);
-      totalPropagated += toAdd.length;
-      changed = true;
-    }
-  }
-
-  return { propagated: totalPropagated };
-}
-
-export const reExportPropagationPhase: PipelinePhase<ReExportPropagationOutput> = {
-  name: 're-export-propagation',
-  deps: ['cross-file'],
-  async execute(ctx): Promise<ReExportPropagationOutput> {
-    if (!ctx.db) return { propagated: 0 };
-    const result = propagateReExports(ctx.db);
-    ctx.onProgress?.({ phase: 're-export-propagation', message: `Propagated ${result.propagated} re-export edges` });
-    return result;
-  },
-};

package/src/pipeline/phases/reachability.ts

@@ -1,156 +0,0 @@
-import type Database from 'better-sqlite3';
-
-export type ReachabilityRole = 'runtime' | 'test' | 'support' | 'unreachable';
-
-/**
- * Classify every File node's reachability role.
- *
- * Entry point detection:
- * - Test entry points: files matching test patterns (*.test.*, *.spec.*, __tests__/*)
- * - Runtime entry points: files with no incoming IMPORTS edges (potential roots)
- * - Support files: *.config.*, scripts/*, tools/* etc.
- *
- * BFS propagation (forward — follows what files import):
- * - From test entry points: mark reachable files as 'test'
- * - From runtime entry points: mark reachable files as 'runtime'
- * - Files reachable from both: 'runtime' wins over 'test'
- * - Nodes reachable from neither: marked 'unreachable'
- * - Config/support files (*.config.*, scripts/*): marked 'support'
- */
-export function classifyReachability(
-  db: Database.Database,
-  _projectDir: string,
-): { runtime: number; test: number; support: number; unreachable: number } {
-  const TEST_PATTERNS = [
-    /\.test\.[tj]sx?$/,
-    /\.spec\.[tj]sx?$/,
-    /__tests__\//,
-    /\/test\//,
-    /\/tests\//,
-  ];
-  const SUPPORT_PATTERNS = [
-    /\.config\.[tj]sx?$/,
-    /\/scripts\//,
-    /\/tools\//,
-    /jest\.config/,
-    /vitest\.config/,
-    /webpack\.config/,
-    /vite\.config/,
-  ];
-
-  const allFileNodes = db.prepare(
-    `SELECT id, file_path, properties FROM nodes WHERE label = 'File' AND file_path IS NOT NULL`,
-  ).all() as { id: string; file_path: string; properties: string | null }[];
-
-  const roleMap = new Map<string, ReachabilityRole>();
-  const testEntryIds = new Set<string>();
-  const runtimeEntryIds = new Set<string>();
-
-  // Initial classification by path pattern
-  for (const node of allFileNodes) {
-    const fp = node.file_path;
-    if (TEST_PATTERNS.some(p => p.test(fp))) {
-      testEntryIds.add(node.id);
-      roleMap.set(node.id, 'test');
-    } else if (SUPPORT_PATTERNS.some(p => p.test(fp))) {
-      roleMap.set(node.id, 'support');
-    }
-  }
-
-  // Files with no incoming IMPORTS edges are potential runtime roots
-  const noIncoming = db.prepare(`
-    SELECT n.id FROM nodes n
-    WHERE n.label = 'File'
-    AND NOT EXISTS (
-      SELECT 1 FROM edges e WHERE e.target_id = n.id AND e.relation = 'IMPORTS'
-    )
-  `).all() as { id: string }[];
-
-  for (const { id } of noIncoming) {
-    if (!roleMap.has(id)) {
-      runtimeEntryIds.add(id);
-      roleMap.set(id, 'runtime');
-    }
-  }
-
-  // ── Preload forward adjacency map for BFS (one query vs N per BFS node) ────────
-  const forwardEdges = new Map<string, string[]>();
-  const fwdRows = db.prepare(
-    `SELECT source_id, target_id FROM edges WHERE relation IN ('IMPORTS', 'RE_EXPORTS')`,
-  ).all() as { source_id: string; target_id: string }[];
-  for (const row of fwdRows) {
-    let targets = forwardEdges.get(row.source_id);
-    if (!targets) {
-      targets = [];
-      forwardEdges.set(row.source_id, targets);
-    }
-    targets.push(row.target_id);
-  }
-
-  // ── BFS from entry points — uses preloaded adjacency (no per-node DB query) ──
-  const bfs = (startIds: Set<string>, role: ReachabilityRole) => {
-    const queue = Array.from(startIds);
-    const visited = new Set(startIds);
-    while (queue.length > 0) {
-      const nodeId = queue.shift()!;
-      // O(1) adjacency lookup instead of per-node DB query
-      const targets = forwardEdges.get(nodeId);
-      if (!targets) continue;
-      for (const target_id of targets) {
-        if (!visited.has(target_id)) {
-          visited.add(target_id);
-          // Set role only if not already set to a higher-priority role
-          // Priority: runtime > test > support > unreachable
-          const existing = roleMap.get(target_id);
-          if (!existing || existing === 'unreachable' || (role === 'runtime' && existing === 'test')) {
-            roleMap.set(target_id, role);
-          }
-          queue.push(target_id);
-        }
-      }
-    }
-  };
-
-  // Test BFS first, then runtime (runtime wins on overlap)
-  bfs(testEntryIds, 'test');
-  bfs(runtimeEntryIds, 'runtime');
-
-  // ── Persist roles and count — batch UPDATE in transaction ────────────────────
-  const updateStmt = db.prepare(`UPDATE nodes SET properties = ? WHERE id = ?`);
-  const persistAll = db.transaction(() => {
-    let runtime = 0, test = 0, support = 0, unreachable = 0;
-    for (const node of allFileNodes) {
-      const role = roleMap.get(node.id) ?? 'unreachable';
-      let props: Record<string, unknown> = {};
-      try {
-        if (node.properties) props = JSON.parse(node.properties);
-      } catch { /* ignore parse errors */ }
-      props.reachabilityRole = role;
-      updateStmt.run(JSON.stringify(props), node.id);
-      if (role === 'runtime') runtime++;
-      else if (role === 'test') test++;
-      else if (role === 'support') support++;
-      else unreachable++;
-    }
-    return { runtime, test, support, unreachable };
-  });
-  return persistAll();
-}
-
-/**
- * Get File nodes filtered by reachability role.
- */
-export function getNodesByReachabilityRole(
-  db: Database.Database,
-  role: ReachabilityRole,
-  limit = 100,
-): Array<{ id: string; name: string; filePath: string | null }> {
-  const rows = db.prepare(`
-    SELECT id, name, file_path
-    FROM nodes
-    WHERE label = 'File'
-    AND json_extract(properties, '$.reachabilityRole') = ?
-    LIMIT ?
-  `).all(role, limit) as { id: string; name: string; file_path: string | null }[];
-  return rows.map(r => ({ id: r.id, name: r.name, filePath: r.file_path }));
-}

package/src/pipeline/phases/routes.ts

@@ -1,350 +0,0 @@
-import { readFileSync, statSync } from 'fs';
-import { extname } 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';
-
-// ── Constants ─────────────────────────────────────────────────────────────────
-
-const CODE_EXTENSIONS = new Set(['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs']);
-
-// Next.js pages dir (classic router)
-const PAGES_RE = /^(?:src\/)?pages\//;
-// Next.js app router route files — support both project root and src/ layout
-const APP_ROUTE_RE = /^(?:src\/)?app\/(.*\/)?route\.(ts|tsx|js|jsx)$/;
-
-// Express/Fastify route methods
-const EXPRESS_METHODS = ['get', 'post', 'put', 'delete', 'patch', 'use'] as const;
-type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'ANY';
-
-// ── Output types ──────────────────────────────────────────────────────────────
-
-export interface RouteEntry {
-  method: string;
-  path: string;
-  handlerNodeId?: string;
-  filePath: string;
-  routeNodeId: string;
-  middlewareChain: string[];
-}
-
-export interface RoutesOutput {
-  routeRegistry: RouteEntry[];
-}
-
-// ── Phase ─────────────────────────────────────────────────────────────────────
-
-export const routesPhase: PipelinePhase<RoutesOutput> = {
-  name: 'routes',
-  deps: ['parse', 'structure'],
-  async execute(ctx, deps) {
-    if (ctx.allFilesCached) return { routeRegistry: [], routeNodes: [], handlesEdges: [] };
-    const { fileNodes } = deps.get('structure') as StructureOutput;
-    const routeRegistry: RouteEntry[] = [];
-    const routeNodes: MonographNode[] = [];
-    const handlesEdges: MonographEdge[] = [];
-
-    // ── Preload handler index: name:filePath → nodeId (one DB query vs N per route) ──
-    // Keyed as `${name}\0${filePath}` for O(1) lookup during route extraction.
-    const handlerIndex = new Map<string, string>();
-    if (ctx.db) {
-      const handlerRows = ctx.db
-        .prepare(`SELECT id, name, file_path FROM nodes WHERE file_path IS NOT NULL`)
-        .all() as { id: string; name: string; file_path: string }[];
-      for (const row of handlerRows) {
-        handlerIndex.set(`${row.name}\0${row.file_path}`, row.id);
-      }
-    }
-
-    /** O(1) handler lookup using the preloaded index */
-    function lookupHandler(handlerName: string, filePath: string): string | undefined {
-      return handlerIndex.get(`${handlerName}\0${filePath}`);
-    }
-
-    for (const fileNode of fileNodes) {
-      const relPath = fileNode.filePath ?? '';
-      const ext = extname(relPath).toLowerCase();
-
-      if (!CODE_EXTENSIONS.has(ext)) continue;
-
-      // ── 1. Next.js file-based routing ──────────────────────────────────────
-      const isNextPages = PAGES_RE.test(relPath);
-      const isNextAppRoute = APP_ROUTE_RE.test(relPath);
-
-      if (isNextPages || isNextAppRoute) {
-        const routePath = isNextPages
-          ? pagesPathToRoute(relPath)
-          : appPathToRoute(relPath);
-        const method = 'ANY';
-        const routeNodeId = makeId('route', method, routePath, relPath);
-        const name = `${method} ${routePath}`;
-
-        const routeNode: MonographNode = {
-          id: routeNodeId,
-          label: 'Route',
-          name,
-          normLabel: toNormLabel(name),
-          filePath: relPath,
-          startLine: 0,
-          endLine: 0,
-          isExported: false,
-          language: langFromExt(ext),
-        };
-        routeNodes.push(routeNode);
-
-        const entry: RouteEntry = { method, path: routePath, filePath: relPath, routeNodeId, middlewareChain: [] };
-
-        if (ctx.db) {
-          const source = safeReadSource(`${ctx.repoPath}/${relPath}`, ctx.options.maxFileSizeBytes);
-          if (source) {
-            const handlerName = extractDefaultExportName(source);
-            if (handlerName) {
-              const targetId = lookupHandler(handlerName, relPath);
-              if (targetId) {
-                const edgeId = makeId(routeNodeId, targetId, 'handles_route');
-                handlesEdges.push({
-                  id: edgeId,
-                  sourceId: routeNodeId,
-                  targetId,
-                  relation: 'HANDLES_ROUTE',
-                  confidence: 'EXTRACTED',
-                  confidenceScore: 0.9,
-                });
-                entry.handlerNodeId = targetId;
-              }
-            }
-          }
-        }
-
-        routeRegistry.push(entry);
-        continue;
-      }
-
-      // ── 2. Express / Fastify app.METHOD() style ────────────────────────────
-      const source = safeReadSource(`${ctx.repoPath}/${relPath}`, ctx.options.maxFileSizeBytes);
-      if (!source) continue;
-
-      const expressEntries = extractExpressRoutes(source, relPath, ext);
-      for (const e of expressEntries) {
-        const routeNodeId = makeId('route', e.method, e.path, relPath);
-        const name = `${e.method} ${e.path}`;
-        const routeNode: MonographNode = {
-          id: routeNodeId,
-          label: 'Route',
-          name,
-          normLabel: toNormLabel(name),
-          filePath: relPath,
-          startLine: 0,
-          endLine: 0,
-          isExported: false,
-          language: langFromExt(ext),
-        };
-        routeNodes.push(routeNode);
-
-        const entry: RouteEntry = { method: e.method, path: e.path, filePath: relPath, routeNodeId, middlewareChain: [] };
-
-        if (ctx.db && e.handlerName) {
-          const targetId = lookupHandler(e.handlerName, relPath);
-          if (targetId) {
-            const edgeId = makeId(routeNodeId, targetId, 'handles_route');
-            handlesEdges.push({
-              id: edgeId,
-              sourceId: routeNodeId,
-              targetId,
-              relation: 'HANDLES_ROUTE',
-              confidence: 'EXTRACTED',
-              confidenceScore: 0.9,
-            });
-            entry.handlerNodeId = targetId;
-          }
-        }
-
-        routeRegistry.push(entry);
-      }
-
-      // ── 3. NestJS / TypeScript decorator routing ───────────────────────────
-      const nestEntries = extractNestRoutes(source, relPath, ext);
-      for (const e of nestEntries) {
-        const routeNodeId = makeId('route', e.method, e.path, relPath);
-        const name = `${e.method} ${e.path}`;
-        const routeNode: MonographNode = {
-          id: routeNodeId,
-          label: 'Route',
-          name,
-          normLabel: toNormLabel(name),
-          filePath: relPath,
-          startLine: 0,
-          endLine: 0,
-          isExported: false,
-          language: langFromExt(ext),
-        };
-        routeNodes.push(routeNode);
-
-        const entry: RouteEntry = { method: e.method, path: e.path, filePath: relPath, routeNodeId, middlewareChain: [] };
-
-        if (ctx.db && e.handlerName) {
-          const targetId = lookupHandler(e.handlerName, relPath);
-          if (targetId) {
-            const edgeId = makeId(routeNodeId, targetId, 'handles_route');
-            handlesEdges.push({
-              id: edgeId,
-              sourceId: routeNodeId,
-              targetId,
-              relation: 'HANDLES_ROUTE',
-              confidence: 'EXTRACTED',
-              confidenceScore: 0.9,
-            });
-            entry.handlerNodeId = targetId;
-          }
-        }
-
-        routeRegistry.push(entry);
-      }
-    }
-
-    if (ctx.db) {
-      insertNodes(ctx.db, routeNodes);
-      insertEdges(ctx.db, handlesEdges);
-    }
-
-    return { routeRegistry };
-  },
-};
-
-// ── Path conversion helpers ───────────────────────────────────────────────────
-
-/**
- * Convert a pages/... file path to an HTTP route path.
- * examples:
- *   pages/index.ts         → /
- *   pages/about.ts         → /about
- *   pages/api/users.ts     → /api/users
- *   pages/api/users/[id].ts → /api/users/:id
- *   pages/[[...slug]].ts   → *
- */
-export function pagesPathToRoute(relPath: string): string {
-  // strip leading 'pages/' and extension
-  let path = relPath.replace(/^pages\//, '').replace(/\.(tsx?|jsx?)$/, '');
-  // Remove trailing /index
-  path = path.replace(/(^|\/)index$/, '');
-  // catch-all: [[...param]] or [...param]
-  path = path.replace(/\[\[\.\.\.(\w+)\]\]/g, '*');
-  path = path.replace(/\[\.\.\.(\w+)\]/g, '*');
-  // dynamic segments: [param]
-  path = path.replace(/\[(\w+)\]/g, ':$1');
-  // strip trailing slash that might result from above
-  path = path.replace(/\/$/, '');
-  return path ? `/${path}` : '/';
-}
-
-/**
- * Convert an app/.../route.ts path to an HTTP route path.
- * examples:
- *   app/route.ts               → /
- *   app/users/route.ts         → /users
- *   app/users/[id]/route.ts    → /users/:id
- */
-export function appPathToRoute(relPath: string): string {
-  // strip leading 'app/' and trailing '/route.<ext>' or 'route.<ext>'
-  let path = relPath
-    .replace(/^app\//, '')
-    .replace(/\/route\.(tsx?|jsx?)$/, '')
-    .replace(/^route\.(tsx?|jsx?)$/, '');
-  // catch-all
-  path = path.replace(/\[\[\.\.\.(\w+)\]\]/g, '*');
-  path = path.replace(/\[\.\.\.(\w+)\]/g, '*');
-  // dynamic segments
-  path = path.replace(/\[(\w+)\]/g, ':$1');
-  path = path.replace(/\/$/, '');
-  return path ? `/${path}` : '/';
-}
-
-// ── Extract default export name ───────────────────────────────────────────────
-
-/** Returns the exported identifier from `export default function X` or `export default X` */
-export function extractDefaultExportName(source: string): string | undefined {
-  // export default function handler or export default async function handler
-  const fnMatch = source.match(/export\s+default\s+(?:async\s+)?function\s+(\w+)/);
-  if (fnMatch) return fnMatch[1];
-  // export default identifier (not an object literal or class expression)
-  const idMatch = source.match(/export\s+default\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*[;\n]/);
-  if (idMatch) return idMatch[1];
-  return undefined;
-}
-
-// ── Express route extraction ──────────────────────────────────────────────────
-
-interface DetectedRoute {
-  method: string;
-  path: string;
-  handlerName?: string;
-}
-
-const EXPRESS_ROUTE_RE =
-  /(?:app|router|server)\s*\.\s*(get|post|put|delete|patch|use)\s*\(\s*['"]([^'"]+)['"]\s*(?:,\s*([A-Za-z_$][A-Za-z0-9_$]*))?/gi;
-
-export function extractExpressRoutes(source: string, _filePath: string, _ext: string): DetectedRoute[] {
-  const results: DetectedRoute[] = [];
-  let match: RegExpExecArray | null;
-  const re = new RegExp(EXPRESS_ROUTE_RE.source, 'gi');
-  while ((match = re.exec(source)) !== null) {
-    const httpMethod = match[1].toUpperCase() as HttpMethod;
-    const routePath = match[2];
-    const handlerName = match[3];
-    results.push({ method: httpMethod, path: routePath, handlerName });
-  }
-  return results;
-}
-
-// ── NestJS decorator extraction ───────────────────────────────────────────────
-
-const CONTROLLER_RE = /@Controller\(\s*['"]([^'"]*)['"]\s*\)/g;
-// Method-level decorators and the following method name
-const NEST_METHOD_RE =
-  /@(Get|Post|Put|Delete|Patch)\s*\(\s*['"]([^'"]*)['"]\s*\)\s*(?:[\w\s,():?<>[\]|&.]+?\s+)?(\w+)\s*\(/gis;
-
-export function extractNestRoutes(source: string, _filePath: string, _ext: string): DetectedRoute[] {
-  // Find controller prefix (use first @Controller decorator found)
-  let controllerPrefix = '';
-  const ctrlMatch = CONTROLLER_RE.exec(source);
-  if (ctrlMatch) {
-    controllerPrefix = ctrlMatch[1].replace(/\/$/, '');
-  }
-  // Reset lastIndex
-  CONTROLLER_RE.lastIndex = 0;
-
-  const results: DetectedRoute[] = [];
-  let match: RegExpExecArray | null;
-  const re = new RegExp(NEST_METHOD_RE.source, 'gis');
-  while ((match = re.exec(source)) !== null) {
-    const httpMethod = match[1].toUpperCase();
-    const methodPath = match[2].replace(/^\//, '');
-    const handlerName = match[3];
-    const full = controllerPrefix
-      ? `/${controllerPrefix}/${methodPath}`.replace(/\/+/g, '/')
-      : `/${methodPath}`;
-    results.push({ method: httpMethod, path: full, handlerName });
-  }
-  return results;
-}
-
-// ── Utilities ─────────────────────────────────────────────────────────────────
-
-function safeReadSource(absPath: string, maxBytes: number): string | undefined {
-  try {
-    const stat = statSync(absPath);
-    if (stat.size > maxBytes) return undefined;
-    return readFileSync(absPath, 'utf-8');
-  } catch {
-    return undefined;
-  }
-}
-
-function langFromExt(ext: string): string {
-  if (ext === '.ts' || ext === '.tsx') return 'typescript';
-  if (ext === '.js' || ext === '.jsx' || ext === '.mjs' || ext === '.cjs') return 'javascript';
-  return 'unknown';
-}