@monoes/monograph 1.5.6 → 1.5.8

package/src/pipeline/phases/bridge-adapters/electron-ipc.ts

@@ -1,91 +0,0 @@
-import { statSync, readFileSync } from 'fs';
-import { join, extname } from 'path';
-import type { PipelineContext } from '../../types.js';
-import type { BridgeAdapter, BridgeEndpoint } from './types.js';
-
-const JS_TS_EXT = new Set(['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs']);
-
-const IPC_MAIN_RE = /\bipcMain\.(?:handle|on)\(\s*['"]([^'"]+)['"]/g;
-const IPC_RENDERER_RE = /\bipcRenderer\.(?:invoke|send)\(\s*['"]([^'"]+)['"]/g;
-
-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 extractChannels(re: RegExp, source: string): string[] {
-  re.lastIndex = 0;
-  const names: string[] = [];
-  let m: RegExpExecArray | null;
-  while ((m = re.exec(source)) !== null) names.push(m[1]!);
-  return names;
-}
-
-/**
- * Electron IPC (main process JS <-> renderer/preload JS): both sides are the
- * same language, so nothing in the existing same-file import resolution
- * connects them — the only link is the shared channel-name string literal
- * passed to `ipcMain.handle/on` (definition) and `ipcRenderer.invoke/send`
- * (call site). Neither side has call-expression-level node granularity from
- * a plain regex scan, so both attach to their containing File node.
- */
-export const electronIpcAdapter: BridgeAdapter = {
-  name: 'electron-ipc',
-
-  detect(ctx, filePaths) {
-    let hasMain = false;
-    let hasRenderer = false;
-    for (const relPath of filePaths) {
-      if (!JS_TS_EXT.has(extname(relPath))) continue;
-      const source = safeReadSource(join(ctx.repoPath, relPath), ctx.options.maxFileSizeBytes);
-      if (!source) continue;
-      if (!hasMain && /\bipcMain\.(?:handle|on)\(/.test(source)) hasMain = true;
-      if (!hasRenderer && /\bipcRenderer\.(?:invoke|send)\(/.test(source)) hasRenderer = true;
-      if (hasMain && hasRenderer) return true;
-    }
-    return false;
-  },
-
-  findDefinitions(ctx, filePaths) {
-    const endpoints: BridgeEndpoint[] = [];
-    for (const relPath of filePaths) {
-      if (!JS_TS_EXT.has(extname(relPath))) continue;
-      const source = safeReadSource(join(ctx.repoPath, relPath), ctx.options.maxFileSizeBytes);
-      if (!source) continue;
-      const channels = extractChannels(IPC_MAIN_RE, source);
-      if (channels.length === 0) continue;
-
-      const fileRow = ctx.db
-        .prepare(`SELECT id FROM nodes WHERE label = 'File' AND file_path = ?`)
-        .get(relPath) as { id: string } | undefined;
-      if (!fileRow) continue;
-
-      for (const channel of channels) endpoints.push({ key: channel, nodeId: fileRow.id, language: 'javascript' });
-    }
-    return endpoints;
-  },
-
-  findCallSites(ctx, filePaths) {
-    const endpoints: BridgeEndpoint[] = [];
-    for (const relPath of filePaths) {
-      if (!JS_TS_EXT.has(extname(relPath))) continue;
-      const source = safeReadSource(join(ctx.repoPath, relPath), ctx.options.maxFileSizeBytes);
-      if (!source) continue;
-      const channels = extractChannels(IPC_RENDERER_RE, source);
-      if (channels.length === 0) continue;
-
-      const fileRow = ctx.db
-        .prepare(`SELECT id FROM nodes WHERE label = 'File' AND file_path = ?`)
-        .get(relPath) as { id: string } | undefined;
-      if (!fileRow) continue;
-
-      for (const channel of channels) endpoints.push({ key: channel, nodeId: fileRow.id, language: 'javascript' });
-    }
-    return endpoints;
-  },
-};

package/src/pipeline/phases/bridge-adapters/registry.ts

@@ -1,14 +0,0 @@
-import type { BridgeAdapter } from './types.js';
-import { wailsAdapter } from './wails.js';
-import { tauriAdapter } from './tauri.js';
-import { electronIpcAdapter } from './electron-ipc.js';
-
-// Every adapter here has an unambiguous detect() signal (a generated binding
-// path, or a framework-specific call shape that only appears when its
-// framework is actually in use) — so all run unconditionally; detect() is
-// what keeps the no-op cost near zero for repos that don't use any of them.
-export const BUILTIN_BRIDGE_ADAPTERS: BridgeAdapter[] = [
-  wailsAdapter,
-  tauriAdapter,
-  electronIpcAdapter,
-];

package/src/pipeline/phases/bridge-adapters/tauri.ts

@@ -1,103 +0,0 @@
-import { statSync, readFileSync } from 'fs';
-import { join, extname } from 'path';
-import type { PipelineContext } from '../../types.js';
-import type { BridgeAdapter, BridgeEndpoint } from './types.js';
-
-const RUST_EXT = new Set(['.rs']);
-const JS_TS_EXT = new Set(['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs']);
-
-/** `#[tauri::command]` (with or without args) directly above an fn declaration. */
-const TAURI_COMMAND_RE = /#\[tauri::command(?:\([^)]*\))?\]\s*(?:pub(?:\([^)]*\))?\s+)?(?:async\s+)?fn\s+(\w+)/g;
-
-/**
- * Tauri's `invoke(...)` call from the JS/TS side, e.g.
- * `import { invoke } from '@tauri-apps/api/core'; invoke('my_command', {...})`.
- * We don't verify the import — matching the call shape is enough signal here,
- * same tradeoff extractor.ts already makes for plain call-site regexes.
- */
-const TAURI_INVOKE_RE = /\binvoke\(\s*['"]([^'"]+)['"]/g;
-
-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;
-  }
-}
-
-/**
- * Tauri (Rust <-> JS/TS): a `#[tauri::command]`-annotated Rust fn is invoked
- * from the frontend by name via `invoke("name", ...)` — a string-literal
- * match, not a generated file. The Rust side already has a real Function
- * node (from the Rust extractor); the JS/TS call site does not, so it's
- * attached to its containing File node.
- */
-export const tauriAdapter: BridgeAdapter = {
-  name: 'tauri',
-
-  // A bare .rs file isn't a Tauri signal by itself (a repo can have unrelated
-  // Rust code alongside a JS/TS frontend) — require an actual
-  // #[tauri::command] annotation before this adapter runs at all.
-  detect(ctx, filePaths) {
-    for (const relPath of filePaths) {
-      if (!RUST_EXT.has(extname(relPath))) continue;
-      const source = safeReadSource(join(ctx.repoPath, relPath), ctx.options.maxFileSizeBytes);
-      if (!source) continue;
-      TAURI_COMMAND_RE.lastIndex = 0;
-      if (TAURI_COMMAND_RE.test(source)) return true;
-    }
-    return false;
-  },
-
-  findDefinitions(ctx, filePaths) {
-    const endpoints: BridgeEndpoint[] = [];
-    for (const relPath of filePaths) {
-      if (!RUST_EXT.has(extname(relPath))) continue;
-      const source = safeReadSource(join(ctx.repoPath, relPath), ctx.options.maxFileSizeBytes);
-      if (!source) continue;
-
-      TAURI_COMMAND_RE.lastIndex = 0;
-      let m: RegExpExecArray | null;
-      const names: string[] = [];
-      while ((m = TAURI_COMMAND_RE.exec(source)) !== null) names.push(m[1]!);
-      if (names.length === 0) continue;
-
-      const rows = ctx.db
-        .prepare(`SELECT id, name FROM nodes WHERE label = 'Function' AND language = 'rust' AND file_path = ?`)
-        .all(relPath) as { id: string; name: string }[];
-      const byName = new Map(rows.map((r) => [r.name, r.id]));
-      for (const name of names) {
-        const nodeId = byName.get(name);
-        if (nodeId) endpoints.push({ key: name, nodeId, language: 'rust' });
-      }
-    }
-    return endpoints;
-  },
-
-  findCallSites(ctx, filePaths) {
-    const endpoints: BridgeEndpoint[] = [];
-    for (const relPath of filePaths) {
-      if (!JS_TS_EXT.has(extname(relPath))) continue;
-      const source = safeReadSource(join(ctx.repoPath, relPath), ctx.options.maxFileSizeBytes);
-      if (!source) continue;
-
-      TAURI_INVOKE_RE.lastIndex = 0;
-      let m: RegExpExecArray | null;
-      const commandNames: string[] = [];
-      while ((m = TAURI_INVOKE_RE.exec(source)) !== null) commandNames.push(m[1]!);
-      if (commandNames.length === 0) continue;
-
-      const fileRow = ctx.db
-        .prepare(`SELECT id FROM nodes WHERE label = 'File' AND file_path = ?`)
-        .get(relPath) as { id: string } | undefined;
-      if (!fileRow) continue;
-
-      for (const name of commandNames) {
-        endpoints.push({ key: name, nodeId: fileRow.id, language: 'javascript' });
-      }
-    }
-    return endpoints;
-  },
-};

package/src/pipeline/phases/bridge-adapters/types.ts

@@ -1,31 +0,0 @@
-import type { PipelineContext } from '../../types.js';
-
-/**
- * One side of a cross-language bridge boundary — a definition (the thing being
- * exposed across the boundary) or a call site (the thing invoking across it).
- * `key` is the string both sides are matched on: an exact symbol name for
- * codegen-based bridges (Wails, wasm-bindgen), or a string-literal channel/
- * command name for registration-based bridges (Tauri, Electron IPC).
- */
-export interface BridgeEndpoint {
-  key: string;
-  nodeId: string;
-  language: string;
-}
-
-/**
- * A cross-language bridge adapter. Each adapter independently extracts
- * (key, nodeId) pairs from both sides of one specific FFI/IPC/RPC boundary;
- * the bridge-resolver phase matches them by key and emits CALLS edges.
- *
- * `detect` must be cheap — it runs for every adapter on every build, so an
- * adapter whose framework isn't present in the repo should bail out fast
- * (e.g. checking file paths already collected by the scan phase) rather than
- * re-reading the filesystem.
- */
-export interface BridgeAdapter {
-  name: string;
-  detect(ctx: PipelineContext, filePaths: string[]): boolean;
-  findDefinitions(ctx: PipelineContext, filePaths: string[]): BridgeEndpoint[];
-  findCallSites(ctx: PipelineContext, filePaths: string[]): BridgeEndpoint[];
-}

package/src/pipeline/phases/bridge-adapters/wails.ts

@@ -1,33 +0,0 @@
-import type { PipelineContext } from '../../types.js';
-import type { BridgeAdapter, BridgeEndpoint } from './types.js';
-
-const WAILS_BINDING_RE = /wailsjs\/go\//i;
-
-/**
- * Wails (Go <-> JS/TS): `wails` generates a JS/TS binding file per bound Go
- * struct at `frontend/**\/wailsjs/go/<package>/<Struct>.js`, exporting one
- * function per Go method with the exact same name. Both sides are already
- * parsed into real Function/Method nodes by the Go and TS/JS extractors —
- * this adapter just links them by name across the language boundary.
- */
-export const wailsAdapter: BridgeAdapter = {
-  name: 'wails',
-
-  detect(_ctx, filePaths) {
-    return filePaths.some((p) => WAILS_BINDING_RE.test(p));
-  },
-
-  findDefinitions(ctx) {
-    const rows = ctx.db
-      .prepare(`SELECT id, name, language FROM nodes WHERE label = 'Method' AND language = 'go' AND file_path IS NOT NULL`)
-      .all() as { id: string; name: string; language: string }[];
-    return rows.map((r): BridgeEndpoint => ({ key: r.name, nodeId: r.id, language: r.language }));
-  },
-
-  findCallSites(ctx) {
-    const rows = ctx.db
-      .prepare(`SELECT id, name, language, file_path FROM nodes WHERE label = 'Function' AND file_path LIKE '%wailsjs/go/%'`)
-      .all() as { id: string; name: string; language: string; file_path: string }[];
-    return rows.map((r): BridgeEndpoint => ({ key: r.name, nodeId: r.id, language: r.language ?? 'javascript' }));
-  },
-};

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

@@ -1,77 +0,0 @@
-import type { PipelinePhase } from '../types.js';
-import type { MonographEdge } from '../../types.js';
-import { makeId, CONFIDENCE_SCORE } from '../../types.js';
-import { insertEdges } from '../../storage/edge-store.js';
-import type { ScanOutput } from './scan.js';
-import { BUILTIN_BRIDGE_ADAPTERS } from './bridge-adapters/registry.js';
-import type { BridgeEndpoint } from './bridge-adapters/types.js';
-
-export interface BridgeResolverOutput {
-  edgesCreated: number;
-}
-
-/**
- * Cross-language bridge resolution — links calls across an FFI/IPC boundary
- * that no single language's own import/call resolution can see (Wails'
- * generated Go<->JS bindings, Tauri's invoke() commands, Electron's IPC
- * channels, ...). Each adapter in bridge-adapters/ extracts (key, nodeId)
- * pairs from both sides; here they're matched by key and turned into CALLS
- * edges — reusing the existing relation so every existing consumer
- * (monograph_impact, monograph_neighbors, community detection) picks them up
- * with no changes on their end.
- *
- * Confidence is always INFERRED: a bridge edge is a name/key match, not an
- * AST-verified call. A key with more than one matching definition is
- * dropped rather than guessed at — the call site can't know which one was
- * meant, and a wrong edge is worse than a missing one. Multiple call sites
- * sharing one definition (the common case: several UI files calling the
- * same bound method) is normal and always kept.
- */
-export const bridgeResolverPhase: PipelinePhase<BridgeResolverOutput> = {
-  name: 'bridge-resolver',
-  deps: ['scan', 'structure', 'parse'],
-  async execute(ctx, deps) {
-    if (ctx.allFilesCached) return { edgesCreated: 0 };
-
-    const { filePaths } = deps.get('scan') as ScanOutput;
-    const edges: MonographEdge[] = [];
-
-    for (const adapter of BUILTIN_BRIDGE_ADAPTERS) {
-      if (!adapter.detect(ctx, filePaths)) continue;
-
-      const definitions = adapter.findDefinitions(ctx, filePaths);
-      const callSites = adapter.findCallSites(ctx, filePaths);
-      if (definitions.length === 0 || callSites.length === 0) continue;
-
-      const definitionsByKey = new Map<string, BridgeEndpoint[]>();
-      for (const def of definitions) {
-        const arr = definitionsByKey.get(def.key);
-        if (arr) arr.push(def);
-        else definitionsByKey.set(def.key, [def]);
-      }
-
-      for (const callSite of callSites) {
-        const matches = definitionsByKey.get(callSite.key);
-        if (!matches || matches.length !== 1) continue; // 0 or ambiguous — drop, don't guess
-        const target = matches[0]!;
-        if (target.nodeId === callSite.nodeId) continue; // same node on both sides — nothing to link
-
-        const id = makeId('bridge', adapter.name, callSite.nodeId, target.nodeId);
-        const languagePair = `${callSite.language} -> ${target.language}`;
-        edges.push({
-          id,
-          sourceId: callSite.nodeId,
-          targetId: target.nodeId,
-          relation: 'CALLS',
-          confidence: 'INFERRED',
-          confidenceScore: CONFIDENCE_SCORE.INFERRED,
-          reason: `${adapter.name} bridge (${languagePair}): "${callSite.key}"`,
-          evidence: [{ kind: 'bridge', weight: CONFIDENCE_SCORE.INFERRED, note: `${adapter.name}: ${languagePair}` }],
-        });
-      }
-    }
-
-    if (edges.length > 0) insertEdges(ctx.db, edges);
-    return { edgesCreated: edges.length };
-  },
-};

package/src/pipeline/phases/call-site-extractors.ts

@@ -1,177 +0,0 @@
-// ── Call site extraction by language ──────────────────────────────────────────
-
-export interface CallSite {
-  callerFileNodeId: string;
-  callerFilePath: string;
-  calleeRaw: string;
-  form: 'method' | 'direct' | 'dynamic';
-  receiverName?: string;
-  methodName?: string;
-  /**
-   * Byte offset of the match in the source, used by scope resolution to find
-   * the function enclosing this call. Without it every CALLS edge is
-   * attributed to the containing File, which makes a function look "used" by
-   * its own file just for being declared there — see the dead-code masking
-   * described in graph/dead-code.ts.
-   */
-  offset?: number;
-}
-
-// ── Language keyword sets ────────────────────────────────────────────────────
-
-const JS_KEYWORDS = new Set([
-  'if', 'for', 'while', 'switch', 'return', 'function', 'class', 'new', 'typeof',
-  'await', 'catch', 'throw', 'delete', 'void', 'instanceof', 'in', 'of',
-  'import', 'export', 'yield', 'async', 'super', 'this', 'const', 'let', 'var',
-  'try', 'finally', 'break', 'continue', 'debugger', 'with', 'do',
-]);
-
-const PY_KEYWORDS = new Set([
-  'if', 'for', 'while', 'with', 'return', 'def', 'class', 'import', 'from',
-  'raise', 'yield', 'lambda', 'await', 'async', 'del', 'pass', 'assert',
-  'except', 'elif', 'else', 'not', 'and', 'or', 'in', 'is', 'print',
-]);
-
-const GO_KEYWORDS = new Set([
-  'if', 'for', 'range', 'return', 'func', 'type', 'var', 'const', 'import', 'package',
-  'go', 'defer', 'select', 'case', 'default', 'break', 'continue', 'goto', 'fallthrough',
-  'chan', 'map', 'struct', 'interface', 'make', 'new', 'len', 'cap', 'append', 'delete',
-  'panic', 'recover', 'close', 'switch', 'else',
-]);
-
-const JAVA_KEYWORDS = new Set([
-  'if', 'for', 'while', 'do', 'switch', 'case', 'return', 'class', 'interface', 'enum',
-  'new', 'extends', 'implements', 'import', 'package', 'throw', 'throws', 'catch', 'try',
-  'finally', 'static', 'final', 'abstract', 'public', 'private', 'protected', 'void',
-  'break', 'continue', 'default', 'else', 'instanceof', 'this', 'super',
-]);
-
-const RUST_KEYWORDS = new Set([
-  'if', 'let', 'for', 'while', 'loop', 'match', 'return', 'fn', 'struct', 'enum', 'trait',
-  'impl', 'use', 'mod', 'pub', 'super', 'self', 'type', 'where', 'in', 'as', 'mut',
-  'ref', 'move', 'async', 'await', 'dyn', 'extern', 'crate', 'static', 'const', 'unsafe',
-  'break', 'continue', 'else',
-]);
-
-// ── Extension sets ───────────────────────────────────────────────────────────
-
-export const TS_JS_EXTS = new Set(['.ts', '.tsx', '.js', '.jsx']);
-export const CJS_MJS_EXTS = new Set(['.cjs', '.mjs']);
-const PY_EXTS = new Set(['.py']);
-const GO_EXTS = new Set(['.go']);
-const JAVA_EXTS = new Set(['.java']);
-const RUST_EXTS = new Set(['.rs']);
-
-export function isSupportedExt(ext: string): boolean {
-  return TS_JS_EXTS.has(ext) || CJS_MJS_EXTS.has(ext) || PY_EXTS.has(ext) || GO_EXTS.has(ext) || JAVA_EXTS.has(ext) || RUST_EXTS.has(ext);
-}
-
-// ── Generic extractor for languages with method.call and direct() patterns ──
-
-function extractSimpleCallSites(
-  source: string,
-  filePath: string,
-  fileNodeId: string,
-  keywords: Set<string>,
-  directCharClass = '[A-Za-z_][\\w]*',
-): CallSite[] {
-  const sites: CallSite[] = [];
-  const methodPattern = /(\w+)\.(\w+)\s*\(/g;
-  let m: RegExpExecArray | null;
-  while ((m = methodPattern.exec(source)) !== null) {
-    sites.push({ offset: m.index, callerFileNodeId: fileNodeId, callerFilePath: filePath, calleeRaw: `${m[1]}.${m[2]}`, form: 'method', receiverName: m[1], methodName: m[2] });
-  }
-  const directPattern = new RegExp(`(?<![.[\\w])(${directCharClass})\\s*\\(`, 'g');
-  while ((m = directPattern.exec(source)) !== null) {
-    const name = m[1]!;
-    if (keywords.has(name)) continue;
-    sites.push({ offset: m.index, callerFileNodeId: fileNodeId, callerFilePath: filePath, calleeRaw: name, form: 'direct' });
-  }
-  return sites;
-}
-
-export function extractGoCallSites(source: string, filePath: string, fileNodeId: string): CallSite[] {
-  return extractSimpleCallSites(source, filePath, fileNodeId, GO_KEYWORDS);
-}
-
-export function extractJavaCallSites(source: string, filePath: string, fileNodeId: string): CallSite[] {
-  return extractSimpleCallSites(source, filePath, fileNodeId, JAVA_KEYWORDS, '[A-Za-z_$][\\w$]*');
-}
-
-export function extractRustCallSites(source: string, filePath: string, fileNodeId: string): CallSite[] {
-  return extractSimpleCallSites(source, filePath, fileNodeId, RUST_KEYWORDS);
-}
-
-// ── Main extractor: dispatches by file extension ─────────────────────────────
-
-export function extractCallSites(
-  source: string,
-  filePath: string,
-  fileNodeId: string,
-  ext: string,
-): CallSite[] {
-  if (GO_EXTS.has(ext)) return extractGoCallSites(source, filePath, fileNodeId);
-  if (JAVA_EXTS.has(ext)) return extractJavaCallSites(source, filePath, fileNodeId);
-  if (RUST_EXTS.has(ext)) return extractRustCallSites(source, filePath, fileNodeId);
-
-  const sites: CallSite[] = [];
-
-  if (TS_JS_EXTS.has(ext) || CJS_MJS_EXTS.has(ext)) {
-    const methodPattern = /(\w+)\.(\w+)\s*(?:<[^>]*>\s*)?\(/g;
-    let m: RegExpExecArray | null;
-    while ((m = methodPattern.exec(source)) !== null) {
-      sites.push({ offset: m.index, callerFileNodeId: fileNodeId, callerFilePath: filePath, calleeRaw: `${m[1]}.${m[2]}`, form: 'method', receiverName: m[1], methodName: m[2] });
-    }
-
-    const chainedPattern = /[)\]]\s*\.(\w+)\s*(?:<[^>]*>\s*)?\(/g;
-    while ((m = chainedPattern.exec(source)) !== null) {
-      const name = m[1];
-      if (JS_KEYWORDS.has(name)) continue;
-      sites.push({ offset: m.index, callerFileNodeId: fileNodeId, callerFilePath: filePath, calleeRaw: `?.${name}`, form: 'method', methodName: name });
-    }
-
-    const directPattern = /(?<![.[\w])([A-Za-z_$][\w$]*)\s*(?:<[^>]*>\s*)?\(/g;
-    while ((m = directPattern.exec(source)) !== null) {
-      const name = m[1];
-      if (JS_KEYWORDS.has(name)) continue;
-      sites.push({ offset: m.index, callerFileNodeId: fileNodeId, callerFilePath: filePath, calleeRaw: name, form: 'direct', methodName: name });
-    }
-
-    const newPattern = /\bnew\s+([A-Z][\w$]*)\s*(?:<[^>]*>\s*)?\(/g;
-    while ((m = newPattern.exec(source)) !== null) {
-      sites.push({ offset: m.index, callerFileNodeId: fileNodeId, callerFilePath: filePath, calleeRaw: `new ${m[1]}`, form: 'direct', methodName: m[1] });
-    }
-
-    const dynamicPattern = /\w+\s*\[[\w'"` ]+\]\s*\(/g;
-    while ((m = dynamicPattern.exec(source)) !== null) {
-      sites.push({ offset: m.index, callerFileNodeId: fileNodeId, callerFilePath: filePath, calleeRaw: m[0], form: 'dynamic' });
-    }
-  } else if (PY_EXTS.has(ext)) {
-    const methodPattern = /(\w+)\.(\w+)\s*\(/g;
-    let m: RegExpExecArray | null;
-    while ((m = methodPattern.exec(source)) !== null) {
-      sites.push({ offset: m.index, callerFileNodeId: fileNodeId, callerFilePath: filePath, calleeRaw: `${m[1]}.${m[2]}`, form: 'method', receiverName: m[1], methodName: m[2] });
-    }
-
-    const directPattern = /(?<![.[\w])([A-Za-z_][\w]*)\s*\(/g;
-    while ((m = directPattern.exec(source)) !== null) {
-      const name = m[1];
-      if (PY_KEYWORDS.has(name)) continue;
-      sites.push({ offset: m.index, callerFileNodeId: fileNodeId, callerFilePath: filePath, calleeRaw: name, form: 'direct', methodName: name });
-    }
-  }
-
-  return sites;
-}
-
-// ── Constructor assignment tracking ──────────────────────────────────────────
-
-export function extractConstructorAssignments(source: string): Map<string, string> {
-  const result = new Map<string, string>();
-  const pattern = /(?:const|let|var)\s+(\w+)\s*=\s*new\s+([A-Z][\w$]*)\s*(?:<[^>]*>\s*)?\(/g;
-  let m: RegExpExecArray | null;
-  while ((m = pattern.exec(source)) !== null) {
-    result.set(m[1], m[2]);
-  }
-  return result;
-}