@monoes/monograph 1.1.0 → 1.2.0

package/src/pipeline/phases/mro.ts

@@ -9,13 +9,17 @@ export interface MroOutput {
 
 export const mroPhase: PipelinePhase<MroOutput> = {
   name: 'mro',
-  deps: ['cross-file'],
+  deps: ['parse'],
   async execute(_ctx, deps) {
     const { allEdges, symbolNodes } = deps.get('parse') as ParseOutput;
 
+    // Method nodes — used to filter CONTAINS edges (the relation actually emitted by the extractor)
+    const methodIds = new Set(symbolNodes.filter(n => n.label === 'Method').map(n => n.id));
+
     const classMethodsIndex = new Map<string, string[]>();
     for (const edge of allEdges) {
-      if (edge.relation === 'HAS_METHOD') {
+      // Extractor emits CONTAINS for method-in-class; HAS_METHOD is never produced
+      if (edge.relation === 'CONTAINS' && methodIds.has(edge.targetId)) {
         const methods = classMethodsIndex.get(edge.sourceId) ?? [];
         methods.push(edge.targetId);
         classMethodsIndex.set(edge.sourceId, methods);

package/src/pipeline/phases/orm.ts

@@ -0,0 +1,503 @@
+import { readFileSync, statSync } from 'fs';
+import { extname, basename } 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';
+
+// ── Output types ──────────────────────────────────────────────────────────────
+
+export interface FieldDef {
+  name: string;
+  type: string;
+  fieldNodeId: string;
+}
+
+export interface EntityDef {
+  name: string;
+  filePath: string;
+  fields: FieldDef[];
+  entityNodeId: string;
+}
+
+export interface OrmOutput {
+  entities: EntityDef[];
+}
+
+// ── Supported code extensions ─────────────────────────────────────────────────
+
+const TS_JS_EXTENSIONS = new Set(['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs']);
+
+// ── Regex patterns ────────────────────────────────────────────────────────────
+
+/** TypeORM: @Entity() decorator before a class */
+const TYPEORM_ENTITY_RE = /@Entity\s*\([^)]*\)\s*(?:export\s+)?(?:abstract\s+)?class\s+(\w+)/g;
+
+/** TypeORM/MikroORM column decorator (matches the decorator line only) */
+const TYPEORM_COLUMN_DECORATOR_RE = /@(?:Primary(?:Generated)?Column|Column|CreateDateColumn|UpdateDateColumn|DeleteDateColumn|Property|PrimaryKey|ManyToOne|OneToMany|ManyToMany|OneToOne)\s*\([^)]*\)/g;
+
+/** Property declaration after a TypeORM column decorator */
+const TYPEORM_PROP_RE = /(\w+)\s*[!?]?\s*:\s*(\w+)/;
+
+/** Prisma model block: model Name { ... } */
+const PRISMA_MODEL_RE = /^model\s+(\w+)\s*\{([^}]+)\}/gm;
+
+/** Prisma field line inside a model block */
+const PRISMA_FIELD_RE = /^\s+(\w+)\s+(\w+)/gm;
+
+/** Mongoose: const XxxSchema = new Schema({ */
+const MONGOOSE_SCHEMA_RE = /(?:const|let|var)\s+(\w*[Ss]chema)\s*=\s*new\s+(?:\w+\.)?Schema\s*\(\s*\{/g;
+
+/** Mongoose field inside a Schema object: fieldName: { type: SomeType } or fieldName: SomeType */
+const MONGOOSE_FIELD_RE = /(\w+)\s*:\s*(?:\{[^}]*type\s*:\s*(\w+)|(\w+))/g;
+
+/** Sequelize: class Foo extends Model (or extends Model.Model) */
+const SEQUELIZE_CLASS_RE = /class\s+(\w+)\s+extends\s+(?:\w+\.)?Model\b/g;
+
+/** Sequelize Model.init({ field: ... }, { sequelize }) — capture the first arg block */
+const SEQUELIZE_INIT_RE = /(\w+)\.init\s*\(\s*\{/g;
+
+/** Sequelize sequelize.define('ModelName', { ... }) */
+const SEQUELIZE_DEFINE_RE = /\.define\s*\(\s*['"](\w+)['"]\s*,\s*\{/g;
+
+/** Sequelize field inside init/define block: fieldName: DataTypes.X or fieldName: { type: DataTypes.X } */
+const SEQUELIZE_FIELD_RE = /(\w+)\s*:\s*(?:\{[^}]*type\s*:\s*(?:DataTypes\.)?(\w+)|(?:DataTypes\.)?(\w+))/g;
+
+/** SQLAlchemy: class Foo(Base) or class Foo(db.Model) etc. */
+const SQLALCHEMY_CLASS_RE = /class\s+(\w+)\s*\([^)]*Base[^)]*\)/g;
+
+/** SQLAlchemy column: fieldName = Column( */
+const SQLALCHEMY_COLUMN_RE = /(\w+)\s*(?::\s*[\w\[\]]+)?\s*=\s*Column\s*\(/g;
+
+// ── Phase ─────────────────────────────────────────────────────────────────────
+
+export const ormPhase: PipelinePhase<OrmOutput> = {
+  name: 'orm',
+  deps: ['parse', 'structure'],
+  async execute(ctx, deps) {
+    const { fileNodes } = deps.get('structure') as StructureOutput;
+    const entities: EntityDef[] = [];
+    const entityNodes: MonographNode[] = [];
+    const fieldNodes: MonographNode[] = [];
+    const hasFieldEdges: MonographEdge[] = [];
+
+    for (const fileNode of fileNodes) {
+      const relPath = fileNode.filePath ?? '';
+      const ext = extname(relPath).toLowerCase();
+      const fileName = basename(relPath);
+
+      const isPrisma = fileName.endsWith('.prisma');
+      const isPython = ext === '.py';
+      const isTsJs = TS_JS_EXTENSIONS.has(ext);
+
+      if (!isPrisma && !isPython && !isTsJs) continue;
+
+      const source = safeReadSource(`${ctx.repoPath}/${relPath}`, ctx.options.maxFileSizeBytes);
+      if (!source) continue;
+
+      const language = isPrisma ? 'prisma' : isPython ? 'python' : langFromExt(ext);
+
+      if (isPrisma) {
+        detectPrismaEntities(source, relPath, language, entities, entityNodes, fieldNodes, hasFieldEdges);
+      } else if (isPython) {
+        detectSQLAlchemyEntities(source, relPath, language, entities, entityNodes, fieldNodes, hasFieldEdges);
+      } else {
+        // TypeORM/MikroORM and Mongoose and Sequelize for TS/JS files
+        detectTypeOrmEntities(source, relPath, language, entities, entityNodes, fieldNodes, hasFieldEdges);
+        detectMongooseEntities(source, relPath, language, entities, entityNodes, fieldNodes, hasFieldEdges);
+        detectSequelizeEntities(source, relPath, language, entities, entityNodes, fieldNodes, hasFieldEdges);
+      }
+    }
+
+    if (ctx.db) {
+      insertNodes(ctx.db, entityNodes);
+      insertNodes(ctx.db, fieldNodes);
+      insertEdges(ctx.db, hasFieldEdges);
+    }
+
+    return { entities };
+  },
+};
+
+// ── Detectors ─────────────────────────────────────────────────────────────────
+
+function detectTypeOrmEntities(
+  source: string,
+  filePath: string,
+  language: string,
+  entities: EntityDef[],
+  entityNodes: MonographNode[],
+  fieldNodes: MonographNode[],
+  edges: MonographEdge[],
+): void {
+  const entityRe = new RegExp(TYPEORM_ENTITY_RE.source, 'g');
+  let m: RegExpExecArray | null;
+
+  while ((m = entityRe.exec(source)) !== null) {
+    const entityName = m[1];
+    const entityNodeId = makeId('entity', entityName + filePath);
+
+    const entityNode: MonographNode = {
+      id: entityNodeId,
+      label: 'Entity',
+      name: entityName,
+      normLabel: toNormLabel(entityName),
+      filePath,
+      startLine: 0,
+      endLine: 0,
+      isExported: true,
+      language,
+    };
+    entityNodes.push(entityNode);
+
+    const fields: FieldDef[] = [];
+    // Use a per-call local regex to avoid shared lastIndex state on the module-level global
+    const colDecRe = new RegExp(TYPEORM_COLUMN_DECORATOR_RE.source, 'g');
+    const lines = source.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (colDecRe.test(line)) {
+        colDecRe.lastIndex = 0; // reset after test
+        // Look at the next non-empty line for the property declaration
+        for (let j = i + 1; j < Math.min(i + 4, lines.length); j++) {
+          const propLine = lines[j].trim();
+          if (!propLine || propLine.startsWith('@') || propLine.startsWith('//')) continue;
+          const pm = TYPEORM_PROP_RE.exec(propLine);
+          if (pm) {
+            addField(entityName, pm[1], pm[2], filePath, language, entityNodeId, fields, fieldNodes, edges);
+          }
+          break;
+        }
+      }
+      colDecRe.lastIndex = 0; // always reset
+    }
+
+    entities.push({ name: entityName, filePath, fields, entityNodeId });
+  }
+}
+
+function detectPrismaEntities(
+  source: string,
+  filePath: string,
+  language: string,
+  entities: EntityDef[],
+  entityNodes: MonographNode[],
+  fieldNodes: MonographNode[],
+  edges: MonographEdge[],
+): void {
+  const modelRe = new RegExp(PRISMA_MODEL_RE.source, 'gm');
+  let m: RegExpExecArray | null;
+
+  while ((m = modelRe.exec(source)) !== null) {
+    const entityName = m[1];
+    const body = m[2];
+    const entityNodeId = makeId('entity', entityName + filePath);
+
+    const entityNode: MonographNode = {
+      id: entityNodeId,
+      label: 'Entity',
+      name: entityName,
+      normLabel: toNormLabel(entityName),
+      filePath,
+      startLine: 0,
+      endLine: 0,
+      isExported: true,
+      language,
+    };
+    entityNodes.push(entityNode);
+
+    const fields: FieldDef[] = [];
+    const fieldRe = new RegExp(PRISMA_FIELD_RE.source, 'gm');
+    let fm: RegExpExecArray | null;
+
+    while ((fm = fieldRe.exec(body)) !== null) {
+      const fieldName = fm[1];
+      const fieldType = fm[2];
+      // Skip Prisma keywords
+      if (['model', 'enum', 'type', 'datasource', 'generator'].includes(fieldName)) continue;
+      addField(entityName, fieldName, fieldType, filePath, language, entityNodeId, fields, fieldNodes, edges);
+    }
+
+    entities.push({ name: entityName, filePath, fields, entityNodeId });
+  }
+}
+
+function detectMongooseEntities(
+  source: string,
+  filePath: string,
+  language: string,
+  entities: EntityDef[],
+  entityNodes: MonographNode[],
+  fieldNodes: MonographNode[],
+  edges: MonographEdge[],
+): void {
+  const schemaRe = new RegExp(MONGOOSE_SCHEMA_RE.source, 'g');
+  let m: RegExpExecArray | null;
+
+  while ((m = schemaRe.exec(source)) !== null) {
+    const schemaVarName = m[1];
+    // Remove 'Schema' suffix to get entity name
+    const entityName = schemaVarName.replace(/[Ss]chema$/, '') || schemaVarName;
+    const entityNodeId = makeId('entity', entityName + filePath);
+
+    const entityNode: MonographNode = {
+      id: entityNodeId,
+      label: 'Entity',
+      name: entityName,
+      normLabel: toNormLabel(entityName),
+      filePath,
+      startLine: 0,
+      endLine: 0,
+      isExported: true,
+      language,
+    };
+    entityNodes.push(entityNode);
+
+    // Extract a block after the Schema({ starting point
+    const blockStart = m.index + m[0].length;
+    const block = extractBraceBlock(source, blockStart - 1, 4000);
+
+    const fields: FieldDef[] = [];
+    if (block) {
+      const fieldRe = new RegExp(MONGOOSE_FIELD_RE.source, 'g');
+      let fm: RegExpExecArray | null;
+      const seen = new Set<string>();
+      while ((fm = fieldRe.exec(block)) !== null) {
+        const fieldName = fm[1];
+        const fieldType = fm[2] ?? fm[3] ?? 'Mixed';
+        if (seen.has(fieldName)) continue;
+        // Skip obvious non-field keys
+        if (['type', 'required', 'default', 'ref', 'index', 'unique', 'enum'].includes(fieldName)) continue;
+        seen.add(fieldName);
+        addField(entityName, fieldName, fieldType, filePath, language, entityNodeId, fields, fieldNodes, edges);
+      }
+    }
+
+    entities.push({ name: entityName, filePath, fields, entityNodeId });
+  }
+}
+
+function detectSequelizeEntities(
+  source: string,
+  filePath: string,
+  language: string,
+  entities: EntityDef[],
+  entityNodes: MonographNode[],
+  fieldNodes: MonographNode[],
+  edges: MonographEdge[],
+): void {
+  // Track entity names we've already registered to avoid duplicates.
+  const registeredNames = new Set<string>();
+
+  function registerEntity(entityName: string): string {
+    const entityNodeId = makeId('entity', entityName + filePath);
+    if (registeredNames.has(entityName)) return entityNodeId;
+    registeredNames.add(entityName);
+
+    const entityNode: MonographNode = {
+      id: entityNodeId,
+      label: 'Entity',
+      name: entityName,
+      normLabel: toNormLabel(entityName),
+      filePath,
+      startLine: 0,
+      endLine: 0,
+      isExported: true,
+      language,
+    };
+    entityNodes.push(entityNode);
+    return entityNodeId;
+  }
+
+  // Collect class names that extend Model so we can match them in .init() calls.
+  const modelClasses = new Set<string>();
+  const classRe = new RegExp(SEQUELIZE_CLASS_RE.source, 'g');
+  let cm: RegExpExecArray | null;
+  while ((cm = classRe.exec(source)) !== null) {
+    modelClasses.add(cm[1]);
+  }
+
+  // Handle: ClassName.init({ ... }, { sequelize })
+  const initRe = new RegExp(SEQUELIZE_INIT_RE.source, 'g');
+  let im: RegExpExecArray | null;
+  while ((im = initRe.exec(source)) !== null) {
+    const candidateName = im[1];
+    // Only treat as Sequelize if it's a known Model subclass OR if DataTypes appears in the block.
+    const blockStart = im.index + im[0].length - 1; // position of the opening '{'
+    const block = extractBraceBlock(source, blockStart, 4000);
+    if (!block) continue;
+    if (!modelClasses.has(candidateName) && !block.includes('DataTypes')) continue;
+
+    const entityNodeId = registerEntity(candidateName);
+    const fields: FieldDef[] = [];
+    const fieldRe = new RegExp(SEQUELIZE_FIELD_RE.source, 'g');
+    let fm: RegExpExecArray | null;
+    const seen = new Set<string>();
+    while ((fm = fieldRe.exec(block)) !== null) {
+      const fieldName = fm[1];
+      const fieldType = fm[2] ?? fm[3] ?? 'DataType';
+      if (seen.has(fieldName)) continue;
+      if (['type', 'allowNull', 'defaultValue', 'primaryKey', 'unique', 'references'].includes(fieldName)) continue;
+      seen.add(fieldName);
+      addField(candidateName, fieldName, fieldType, filePath, language, entityNodeId, fields, fieldNodes, edges);
+    }
+    entities.push({ name: candidateName, filePath, fields, entityNodeId });
+  }
+
+  // Handle: sequelize.define('ModelName', { ... })
+  const defineRe = new RegExp(SEQUELIZE_DEFINE_RE.source, 'g');
+  let dm: RegExpExecArray | null;
+  while ((dm = defineRe.exec(source)) !== null) {
+    const entityName = dm[1];
+    const blockStart = dm.index + dm[0].length - 1;
+    const block = extractBraceBlock(source, blockStart, 4000);
+
+    const entityNodeId = registerEntity(entityName);
+    const fields: FieldDef[] = [];
+    if (block) {
+      const fieldRe = new RegExp(SEQUELIZE_FIELD_RE.source, 'g');
+      let fm: RegExpExecArray | null;
+      const seen = new Set<string>();
+      while ((fm = fieldRe.exec(block)) !== null) {
+        const fieldName = fm[1];
+        const fieldType = fm[2] ?? fm[3] ?? 'DataType';
+        if (seen.has(fieldName)) continue;
+        if (['type', 'allowNull', 'defaultValue', 'primaryKey', 'unique', 'references'].includes(fieldName)) continue;
+        seen.add(fieldName);
+        addField(entityName, fieldName, fieldType, filePath, language, entityNodeId, fields, fieldNodes, edges);
+      }
+    }
+    entities.push({ name: entityName, filePath, fields, entityNodeId });
+  }
+}
+
+function detectSQLAlchemyEntities(
+  source: string,
+  filePath: string,
+  language: string,
+  entities: EntityDef[],
+  entityNodes: MonographNode[],
+  fieldNodes: MonographNode[],
+  edges: MonographEdge[],
+): void {
+  const classRe = new RegExp(SQLALCHEMY_CLASS_RE.source, 'g');
+  let m: RegExpExecArray | null;
+
+  while ((m = classRe.exec(source)) !== null) {
+    const entityName = m[1];
+    const entityNodeId = makeId('entity', entityName + filePath);
+
+    const entityNode: MonographNode = {
+      id: entityNodeId,
+      label: 'Entity',
+      name: entityName,
+      normLabel: toNormLabel(entityName),
+      filePath,
+      startLine: 0,
+      endLine: 0,
+      isExported: true,
+      language,
+    };
+    entityNodes.push(entityNode);
+
+    const fields: FieldDef[] = [];
+    // Scope column scan to this class's body — slice from the match end to the next
+    // unindented `class ` keyword or end-of-string to avoid assigning columns from
+    // other classes to this entity.
+    const classBodyStart = m.index + m[0].length;
+    const nextClassIdx = source.indexOf('\nclass ', classBodyStart);
+    const classBody = nextClassIdx >= 0 ? source.slice(classBodyStart, nextClassIdx) : source.slice(classBodyStart);
+    const columnRe = new RegExp(SQLALCHEMY_COLUMN_RE.source, 'g');
+    let cm: RegExpExecArray | null;
+    while ((cm = columnRe.exec(classBody)) !== null) {
+      const fieldName = cm[1];
+      addField(entityName, fieldName, 'Column', filePath, language, entityNodeId, fields, fieldNodes, edges);
+    }
+
+    entities.push({ name: entityName, filePath, fields, entityNodeId });
+  }
+}
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+function addField(
+  entityName: string,
+  fieldName: string,
+  fieldType: string,
+  filePath: string,
+  language: string,
+  entityNodeId: string,
+  fields: FieldDef[],
+  fieldNodes: MonographNode[],
+  edges: MonographEdge[],
+): void {
+  const fieldNodeId = makeId('field', entityName + fieldName + filePath);
+
+  const fieldNode: MonographNode = {
+    id: fieldNodeId,
+    label: 'Field',
+    name: fieldName,
+    normLabel: toNormLabel(fieldName),
+    filePath,
+    startLine: 0,
+    endLine: 0,
+    isExported: false,
+    language,
+    properties: { declaredType: fieldType },
+  };
+  fieldNodes.push(fieldNode);
+
+  const edgeId = makeId(entityNodeId, fieldNodeId, 'has_field');
+  edges.push({
+    id: edgeId,
+    sourceId: entityNodeId,
+    targetId: fieldNodeId,
+    relation: 'HAS_FIELD',
+    confidence: 'EXTRACTED',
+    confidenceScore: 0.9,
+  });
+
+  fields.push({ name: fieldName, type: fieldType, fieldNodeId });
+}
+
+/**
+ * Extracts a balanced brace block from source starting at the position of the
+ * opening `{`. Returns the content between the braces (not including the braces).
+ */
+function extractBraceBlock(source: string, openPos: number, maxLen: number): string | undefined {
+  // Find the opening brace at or after openPos
+  let start = source.indexOf('{', openPos);
+  if (start === -1) return undefined;
+
+  let depth = 0;
+  let i = start;
+  const end = Math.min(start + maxLen, source.length);
+
+  for (; i < end; i++) {
+    if (source[i] === '{') depth++;
+    else if (source[i] === '}') {
+      depth--;
+      if (depth === 0) return source.slice(start + 1, i);
+    }
+  }
+  // Return partial block if not closed within maxLen
+  return source.slice(start + 1, i);
+}
+
+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';
+}

package/src/pipeline/phases/parse.ts

@@ -6,11 +6,13 @@ import { parseFile } from '../../parsers/loader.js';
 import { insertNodes } from '../../storage/node-store.js';
 import { insertEdges } from '../../storage/edge-store.js';
 import type { StructureOutput } from './structure.js';
+import { extractVariables, variableToNode } from './variables.js';
 
 export interface ParseOutput {
   symbolNodes: MonographNode[];
   allEdges: MonographEdge[];
   parseErrors: string[];
+  fileContents: Map<string, string>;
 }
 
 export const parsePhase: PipelinePhase<ParseOutput> = {
@@ -21,6 +23,7 @@ export const parsePhase: PipelinePhase<ParseOutput> = {
     const symbolNodes: MonographNode[] = [];
     const allEdges: MonographEdge[] = [];
     const parseErrors: string[] = [];
+    const fileContents = new Map<string, string>();
     let processed = 0;
 
     for (const fileNode of fileNodes) {
@@ -34,12 +37,49 @@ export const parsePhase: PipelinePhase<ParseOutput> = {
           continue;
         }
         source = readFileSync(absPath, 'utf-8');
+        fileContents.set(fileNode.filePath ?? absPath, source);
       } catch { continue; }
 
       const result = await parseFile(absPath, source, fileNode.filePath ?? '');
       symbolNodes.push(...result.nodes);
       allEdges.push(...result.edges);
       parseErrors.push(...result.parseErrors);
+
+      // Extract C# namespace declarations
+      if (ext === '.cs') {
+        const csNamespaces = extractCsharpNamespaces(source, fileNode.filePath ?? '');
+        for (const ns of csNamespaces) {
+          symbolNodes.push({
+            id: `${ns.filePath}::namespace::${ns.name}`,
+            name: ns.name,
+            label: 'Namespace',
+            normLabel: 'namespace',
+            filePath: ns.filePath,
+            line: ns.line,
+            isExported: true,
+          } as import('../../types.js').MonographNode);
+        }
+      }
+
+      // Extract top-level variable declarations for TS/JS files
+      if (['.ts', '.tsx', '.js', '.jsx'].includes(ext)) {
+        const varInfos = extractVariables(source, fileNode.filePath ?? '');
+        symbolNodes.push(...varInfos.map(v => variableToNode(v)));
+
+        // Extract named arrow functions
+        const arrowFns = extractArrowFunctions(source, fileNode.filePath ?? '');
+        for (const fn of arrowFns) {
+          symbolNodes.push({
+            id: `${fn.filePath}::fn::${fn.name}`,
+            name: fn.name,
+            label: 'Function',
+            normLabel: 'function',
+            filePath: fn.filePath,
+            line: fn.line,
+            isExported: fn.isExported,
+          } as import('../../types.js').MonographNode);
+        }
+      }
       processed++;
 
       if (processed % 50 === 0) {
@@ -57,6 +97,45 @@ export const parsePhase: PipelinePhase<ParseOutput> = {
       insertEdges(ctx.db, resolvableEdges);
     }
 
-    return { symbolNodes, allEdges, parseErrors };
+    return { symbolNodes, allEdges, parseErrors, fileContents };
   },
 };
+
+export function extractCsharpNamespaces(
+  source: string,
+  filePath: string,
+): Array<{ name: string; label: 'Namespace'; filePath: string; line: number }> {
+  const results: Array<{ name: string; label: 'Namespace'; filePath: string; line: number }> = [];
+  const re = /^[ \t]*namespace\s+([\w.]+)\s*[\{;]/gm;
+  let m: RegExpExecArray | null;
+  while ((m = re.exec(source)) !== null) {
+    const charsBefore = source.slice(0, m.index);
+    const line = (charsBefore.match(/\n/g)?.length ?? 0) + 1;
+    results.push({ name: m[1]!, label: 'Namespace', filePath, line });
+  }
+  return results;
+}
+
+export function extractArrowFunctions(
+  source: string,
+  filePath: string,
+): Array<{ name: string; isExported: boolean; line: number; filePath: string }> {
+  const results: Array<{ name: string; isExported: boolean; line: number; filePath: string }> = [];
+  // Match: (export)? const/let NAME = (async)? (...) =>
+  const re = /^([ \t]*)(export\s+)?(?:const|let)\s+(\w+)\s*=\s*(?:async\s*)?\([^)]*\)\s*=>/gm;
+
+  let m: RegExpExecArray | null;
+  re.lastIndex = 0;
+  while ((m = re.exec(source)) !== null) {
+    const charsBefore = source.slice(0, m.index);
+    const lineNum = (charsBefore.match(/\n/g)?.length ?? 0) + 1;
+    results.push({
+      name: m[3]!,
+      isExported: !!(m[2]?.trim()),
+      line: lineNum,
+      filePath,
+    });
+  }
+
+  return results;
+}