@mishasinitcyn/betterrank 0.2.6 → 0.2.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mishasinitcyn/betterrank",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "description": "Structural code index with PageRank-ranked repo maps, symbol search, call-graph queries, and dependency analysis. Built on tree-sitter and graphology.",
   "type": "module",
   "main": "src/index.js",

package/src/cache.js

@@ -130,6 +130,7 @@ class CodeIndexCache {
     this.graph = null;
     this.mtimes = new Map();
     this.initialized = false;
+    this.skipCacheLoadOnce = false;
     this.extensions = opts.extensions || SUPPORTED_EXTENSIONS;
     this.ignorePatterns = [...IGNORE_PATTERNS, ...(opts.ignore || [])];
   }
@@ -142,11 +143,14 @@ class CodeIndexCache {
     if (!this.initialized) {
       await this._loadConfig();
 
-      const cached = await loadGraph(this.cachePath);
-      if (cached) {
-        this.graph = cached.graph;
-        this.mtimes = cached.mtimes;
+      if (!this.skipCacheLoadOnce) {
+        const cached = await loadGraph(this.cachePath);
+        if (cached) {
+          this.graph = cached.graph;
+          this.mtimes = cached.mtimes;
+        }
       }
+      this.skipCacheLoadOnce = false;
       this.initialized = true;
     }
 
@@ -179,7 +183,11 @@ class CodeIndexCache {
       updateGraphFiles(this.graph, allRemoved, newSymbols);
     }
 
-    await saveGraph(this.graph, this.mtimes, this.cachePath);
+    try {
+      await saveGraph(this.graph, this.mtimes, this.cachePath);
+    } catch {
+      // Cache persistence is best-effort. Keep the in-memory graph usable.
+    }
 
     if (isColdStart) {
       const elapsed = ((Date.now() - t0) / 1000).toFixed(1);
@@ -218,6 +226,7 @@ class CodeIndexCache {
     this.graph = null;
     this.mtimes = new Map();
     this.initialized = false;
+    this.skipCacheLoadOnce = true;
 
     // Delete the cache file
     try {

package/src/graph.js

@@ -3,7 +3,7 @@ const { MultiDirectedGraph } = graphology;
 import pagerankModule from 'graphology-metrics/centrality/pagerank.js';
 const pagerank = pagerankModule.default || pagerankModule;
 import { writeFile, readFile, mkdir } from 'fs/promises';
-import { dirname } from 'path';
+import { dirname, posix } from 'path';
 
 /**
  * Build a multi-directed graph from parsed symbol data.
@@ -20,6 +20,11 @@ import { dirname } from 'path';
 // Names with more definitions than this (main, run, get, close, etc.) are
 // too ambiguous to provide useful structural signal.
 const AMBIGUITY_CAP = 5;
+const IMPORT_RESOLVE_EXTENSIONS = [
+  '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
+  '.py', '.rs', '.go', '.rb', '.java',
+  '.c', '.h', '.cpp', '.hpp', '.cc', '.cs', '.php',
+];
 
 /**
  * Disambiguate which targets a reference should wire to.
@@ -45,50 +50,89 @@ function disambiguateTargets(targets, sourceFile, graph) {
   return targets;
 }
 
-function buildGraph(allSymbols) {
-  const graph = new MultiDirectedGraph({ allowSelfLoops: false });
+function normalizeFilePath(filePath) {
+  return filePath.replace(/\\/g, '/');
+}
 
-  for (const { file, definitions } of allSymbols) {
-    graph.mergeNode(file, { type: 'file', symbolCount: definitions.length });
+function buildDefinitionIndex(graph) {
+  const defIndex = new Map();
 
-    for (const def of definitions) {
-      const symbolKey = `${file}::${def.name}`;
-      graph.mergeNode(symbolKey, {
-        type: 'symbol',
-        kind: def.kind,
-        name: def.name,
-        file,
-        lineStart: def.lineStart,
-        lineEnd: def.lineEnd,
-        signature: def.signature,
-        astProfile: def.astProfile || null,
-        paramNames: def.paramNames || null,
-        localRefs: def.localRefs || null,
-      });
-      graph.addEdge(file, symbolKey, { type: 'DEFINES' });
-    }
+  graph.forEachNode((node, attrs) => {
+    if (attrs.type !== 'symbol') return;
+    if (!defIndex.has(attrs.name)) defIndex.set(attrs.name, []);
+    defIndex.get(attrs.name).push(node);
+  });
+
+  return defIndex;
+}
+
+function buildFileLookup(graph) {
+  const fileLookup = new Map();
+
+  graph.forEachNode((node, attrs) => {
+    if (attrs.type !== 'file') return;
+    fileLookup.set(normalizeFilePath(node), node);
+  });
+
+  return fileLookup;
+}
+
+function resolveImportBase(sourceFile, specifier) {
+  const normalizedSource = normalizeFilePath(sourceFile);
+  const normalizedSpecifier = normalizeFilePath(specifier);
+  if (!normalizedSpecifier || normalizedSpecifier.startsWith('node:')) return null;
+
+  if (normalizedSpecifier.startsWith('.')) {
+    return posix.normalize(posix.join(posix.dirname(normalizedSource), normalizedSpecifier));
   }
 
-  // Build a name→symbolKey index for wiring references
-  const defIndex = new Map();
-  for (const { file, definitions } of allSymbols) {
-    for (const def of definitions) {
-      const key = `${file}::${def.name}`;
-      if (!defIndex.has(def.name)) defIndex.set(def.name, []);
-      defIndex.get(def.name).push(key);
+  if (normalizedSpecifier.startsWith('~/') || normalizedSpecifier.startsWith('@/')) {
+    return posix.normalize(posix.join('src', normalizedSpecifier.slice(2)));
+  }
+
+  if (normalizedSpecifier.startsWith('/')) {
+    return posix.normalize(normalizedSpecifier.slice(1));
+  }
+
+  if (normalizedSpecifier.startsWith('src/')) {
+    return posix.normalize(normalizedSpecifier);
+  }
+
+  return null;
+}
+
+function hasExplicitImportExtension(filePath) {
+  return IMPORT_RESOLVE_EXTENSIONS.some(ext => filePath.endsWith(ext));
+}
+
+function resolveImportTargetFile(sourceFile, specifier, fileLookup) {
+  const importBase = resolveImportBase(sourceFile, specifier);
+  if (!importBase) return null;
+
+  const candidates = [importBase];
+  if (!hasExplicitImportExtension(importBase)) {
+    for (const ext of IMPORT_RESOLVE_EXTENSIONS) {
+      candidates.push(`${importBase}${ext}`);
+    }
+    for (const ext of IMPORT_RESOLVE_EXTENSIONS) {
+      candidates.push(posix.join(importBase, `index${ext}`));
     }
   }
 
-  // Dedup: one REFERENCES edge and one IMPORTS edge per unique (source, target) pair
-  const addedRefs = new Set();
-  const addedImports = new Set();
+  for (const candidate of candidates) {
+    const resolved = fileLookup.get(normalizeFilePath(candidate));
+    if (resolved) return resolved;
+  }
+
+  return null;
+}
 
-  for (const { file, references } of allSymbols) {
+function wireSymbolReferences(records, graph, defIndex, addedRefs, addedImports) {
+  for (const { file, references } of records) {
     for (const ref of references) {
       const targets = defIndex.get(ref.name);
       if (!targets) continue;
 
-      // Disambiguate: resolve which targets to actually wire
       const resolvedTargets = disambiguateTargets(targets, file, graph);
 
       for (const target of resolvedTargets) {
@@ -110,35 +154,25 @@ function buildGraph(allSymbols) {
       }
     }
   }
-
-  return graph;
 }
 
-/**
- * Incrementally update the graph: remove all nodes for the given files,
- * then re-add from fresh parse results.
- */
-function updateGraphFiles(graph, removedFiles, newSymbols) {
-  for (const filePath of removedFiles) {
-    removeFileNodes(graph, filePath);
-  }
+function wireExplicitImportEdges(records, graph, fileLookup, addedImports) {
+  for (const { file, imports = [] } of records) {
+    for (const entry of imports) {
+      const targetFile = resolveImportTargetFile(file, entry.path, fileLookup);
+      if (!targetFile || targetFile === file) continue;
 
-  // Re-add from newSymbols using the same logic as buildGraph,
-  // but operating on the existing graph.
-  const defIndex = new Map();
+      const impKey = `${file}\0${targetFile}`;
+      if (addedImports.has(impKey)) continue;
 
-  // Rebuild defIndex from the entire graph (existing + new)
-  graph.forEachNode((node, attrs) => {
-    if (attrs.type === 'symbol') {
-      if (!defIndex.has(attrs.name)) defIndex.set(attrs.name, []);
-      defIndex.get(attrs.name).push(node);
+      addedImports.add(impKey);
+      graph.addEdge(file, targetFile, { type: 'IMPORTS' });
     }
-  });
-
-  const addedRefs = new Set();
-  const addedImports = new Set();
+  }
+}
 
-  for (const { file, definitions, references } of newSymbols) {
+function mergeDefinitions(graph, records) {
+  for (const { file, definitions } of records) {
     graph.mergeNode(file, { type: 'file', symbolCount: definitions.length });
 
     for (const def of definitions) {
@@ -156,36 +190,65 @@ function updateGraphFiles(graph, removedFiles, newSymbols) {
         localRefs: def.localRefs || null,
       });
       graph.addEdge(file, symbolKey, { type: 'DEFINES' });
-
-      if (!defIndex.has(def.name)) defIndex.set(def.name, []);
-      defIndex.get(def.name).push(symbolKey);
     }
+  }
+}
 
-    for (const ref of references) {
-      const targets = defIndex.get(ref.name);
-      if (!targets) continue;
+function buildGraph(allSymbols) {
+  const graph = new MultiDirectedGraph({ allowSelfLoops: false });
+  mergeDefinitions(graph, allSymbols);
+  const defIndex = buildDefinitionIndex(graph);
 
-      const resolvedTargets = disambiguateTargets(targets, file, graph);
+  // Dedup: one REFERENCES edge and one IMPORTS edge per unique (source, target) pair
+  const addedRefs = new Set();
+  const addedImports = new Set();
+  wireSymbolReferences(allSymbols, graph, defIndex, addedRefs, addedImports);
+  wireExplicitImportEdges(allSymbols, graph, buildFileLookup(graph), addedImports);
 
-      for (const target of resolvedTargets) {
-        const targetFile = graph.getNodeAttribute(target, 'file');
+  return graph;
+}
 
-        const refKey = `${file}\0${target}`;
-        if (!addedRefs.has(refKey)) {
-          addedRefs.add(refKey);
-          graph.addEdge(file, target, { type: 'REFERENCES' });
-        }
+/**
+ * Incrementally update the graph: remove all nodes for the given files,
+ * then re-add from fresh parse results.
+ */
+function updateGraphFiles(graph, removedFiles, newSymbols) {
+  const changedFiles = new Map(newSymbols.map(record => [record.file, record]));
 
-        if (targetFile !== file) {
-          const impKey = `${file}\0${targetFile}`;
-          if (!addedImports.has(impKey)) {
-            addedImports.add(impKey);
-            graph.addEdge(file, targetFile, { type: 'IMPORTS' });
-          }
-        }
-      }
+  for (const filePath of removedFiles) {
+    const nextRecord = changedFiles.get(filePath);
+    if (!nextRecord) {
+      removeFileNodes(graph, filePath);
+      continue;
+    }
+
+    const outgoingEdges = [];
+    graph.forEachOutEdge(filePath, edge => {
+      outgoingEdges.push(edge);
+    });
+    for (const edge of outgoingEdges) {
+      graph.dropEdge(edge);
+    }
+
+    const nextNames = new Set(nextRecord.definitions.map(def => def.name));
+    const staleNodes = [];
+    graph.forEachNode((node, attrs) => {
+      if (attrs.type !== 'symbol' || attrs.file !== filePath) return;
+      if (!nextNames.has(attrs.name)) staleNodes.push(node);
+    });
+    for (const node of staleNodes) {
+      graph.dropNode(node);
     }
   }
+
+  mergeDefinitions(graph, newSymbols);
+
+  const defIndex = buildDefinitionIndex(graph);
+  const fileLookup = buildFileLookup(graph);
+  const addedRefs = new Set();
+  const addedImports = new Set();
+  wireSymbolReferences(newSymbols, graph, defIndex, addedRefs, addedImports);
+  wireExplicitImportEdges(newSymbols, graph, fileLookup, addedImports);
 }
 
 function removeFileNodes(graph, filePath) {

package/src/index.js

@@ -578,6 +578,7 @@ class CodeIndex {
       // Match call sites: symbol followed by ( — avoids string literals and definitions
       const escaped = symbol.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
       const callPattern = new RegExp(`(?<![a-zA-Z0-9_])${escaped}\\s*\\(`);
+      const jsxPattern = new RegExp(`<\\s*${escaped}(?=[\\s>/.]|$)`);
       // Fallback: import/from lines that reference the symbol
       const importPattern = new RegExp(`(?:import|from)\\s.*\\b${escaped}\\b`);
 
@@ -604,7 +605,7 @@ class CodeIndex {
             if (inDef) continue;
 
             const line = lines[i];
-            if (!callPattern.test(line) && !importPattern.test(line)) continue;
+            if (!callPattern.test(line) && !jsxPattern.test(line) && !importPattern.test(line)) continue;
 
             const start = Math.max(0, i - context);
             const end = Math.min(lines.length - 1, i + context);

package/src/outline.js

@@ -25,7 +25,7 @@ export function buildOutline(source, filePath, expandSymbols = [], { callerCount
     return rawView(lines, pad);
   }
 
-  const parsed = parseFile(filePath, source);
+  const parsed = parseFile(filePath, source, { includeOutlineDefinitions: true });
   if (!parsed || parsed.definitions.length === 0) {
     return rawView(lines, pad);
   }

package/src/parser.js

@@ -82,6 +82,11 @@ const DEF_QUERIES = {
     (export_statement declaration: (function_declaration name: (identifier) @name) @definition)
     (export_statement declaration: (class_declaration name: (identifier) @name) @definition)
     (export_statement declaration: (lexical_declaration (variable_declarator name: (identifier) @name value: (arrow_function) @_val)) @definition)
+    (export_statement declaration: (lexical_declaration (variable_declarator name: (identifier) @name value: (function_expression) @_val)) @definition)
+    (export_statement declaration: (lexical_declaration (variable_declarator name: (identifier) @name value: (call_expression) @_val)) @definition)
+    (export_statement declaration: (lexical_declaration (variable_declarator name: (identifier) @name value: (new_expression) @_val)) @definition)
+    (export_statement declaration: (lexical_declaration (variable_declarator name: (identifier) @name value: (object) @_val)) @definition)
+    (export_statement declaration: (lexical_declaration (variable_declarator name: (identifier) @name value: (array) @_val)) @definition)
   `,
 
   typescript: `
@@ -95,6 +100,11 @@ const DEF_QUERIES = {
     (export_statement declaration: (function_declaration name: (identifier) @name) @definition)
     (export_statement declaration: (class_declaration name: (type_identifier) @name) @definition)
     (export_statement declaration: (lexical_declaration (variable_declarator name: (identifier) @name value: (arrow_function) @_val)) @definition)
+    (export_statement declaration: (lexical_declaration (variable_declarator name: (identifier) @name value: (function_expression) @_val)) @definition)
+    (export_statement declaration: (lexical_declaration (variable_declarator name: (identifier) @name value: (call_expression) @_val)) @definition)
+    (export_statement declaration: (lexical_declaration (variable_declarator name: (identifier) @name value: (new_expression) @_val)) @definition)
+    (export_statement declaration: (lexical_declaration (variable_declarator name: (identifier) @name value: (object) @_val)) @definition)
+    (export_statement declaration: (lexical_declaration (variable_declarator name: (identifier) @name value: (array) @_val)) @definition)
     (export_statement declaration: (interface_declaration name: (type_identifier) @name) @definition)
     (export_statement declaration: (type_alias_declaration name: (type_identifier) @name) @definition)
     (export_statement declaration: (enum_declaration name: (identifier) @name) @definition)
@@ -178,6 +188,10 @@ const REF_QUERIES = {
     (call_expression function: (identifier) @ref)
     (import_specifier name: (identifier) @ref)
     (import_clause (identifier) @ref)
+    (jsx_opening_element (identifier) @jsx_ref)
+    (jsx_self_closing_element (identifier) @jsx_ref)
+    (jsx_opening_element (member_expression (identifier) @jsx_ref))
+    (jsx_self_closing_element (member_expression (identifier) @jsx_ref))
   `,
 
   typescript: `
@@ -187,6 +201,17 @@ const REF_QUERIES = {
     (type_identifier) @ref
   `,
 
+  tsx: `
+    (call_expression function: (identifier) @ref)
+    (import_specifier name: (identifier) @ref)
+    (import_clause (identifier) @ref)
+    (type_identifier) @ref
+    (jsx_opening_element (identifier) @jsx_ref)
+    (jsx_self_closing_element (identifier) @jsx_ref)
+    (jsx_opening_element (member_expression (identifier) @jsx_ref))
+    (jsx_self_closing_element (member_expression (identifier) @jsx_ref))
+  `,
+
   python: `
     (call function: (identifier) @ref)
     (decorator (identifier) @ref)
@@ -213,7 +238,21 @@ const REF_QUERIES = {
   `,
 };
 
-REF_QUERIES.tsx = REF_QUERIES.typescript;
+const IMPORT_QUERIES = {
+  javascript: `
+    (import_statement source: (string) @import_path)
+    (export_statement source: (string) @import_path)
+    (call_expression function: (identifier) @require_fn arguments: (arguments (string) @import_path))
+  `,
+
+  typescript: `
+    (import_statement source: (string) @import_path)
+    (export_statement source: (string) @import_path)
+    (call_expression function: (identifier) @require_fn arguments: (arguments (string) @import_path))
+  `,
+};
+
+IMPORT_QUERIES.tsx = IMPORT_QUERIES.typescript;
 
 const KIND_MAP = {
   function_declaration: 'function',
@@ -244,8 +283,13 @@ const KIND_MAP = {
   variable_declarator: 'variable',
   namespace_definition: 'namespace',
   decorated_definition: 'function',
+  pair: 'property',
 };
 
+const OUTLINE_EXTRA_LANGUAGES = new Set(['javascript', 'typescript', 'tsx']);
+const OUTLINE_BODY_TYPES = new Set(['statement_block', 'class_body', 'object', 'array']);
+const OUTLINE_CALL_TYPES = new Set(['call_expression', 'new_expression']);
+
 /**
  * Walk an AST subtree and count node types that reveal structural shape.
  * Returns a flat object like { if_statement: 3, for_statement: 1, call_expression: 7, ... }
@@ -343,22 +387,146 @@ function extractParamNames(node) {
  * Find the body/block node of a definition, drilling into wrappers like
  * lexical_declaration → variable_declarator → arrow_function → body.
  */
-function findBodyNode(node) {
-  let body = node.childForFieldName('body');
-  if (body) return body;
+function findCallArgumentBody(node, depth) {
+  if (!node) return null;
+  let fallback = null;
 
   for (let i = 0; i < node.namedChildCount; i++) {
     const child = node.namedChild(i);
-    body = child.childForFieldName('body');
-    if (body) return body;
-    for (let j = 0; j < child.namedChildCount; j++) {
-      body = child.namedChild(j).childForFieldName('body');
-      if (body) return body;
+    const body = findBodyNode(child, depth + 1);
+    if (!body) continue;
+    if (body.type === 'statement_block' || body.type === 'class_body') {
+      return body;
     }
+    if (!fallback) fallback = body;
+  }
+
+  return fallback;
+}
+
+function findBodyNode(node, depth = 0) {
+  if (!node || depth > 12) return null;
+  if (OUTLINE_BODY_TYPES.has(node.type)) return node;
+
+  const body = node.childForFieldName('body');
+  if (body) {
+    const nestedBody = findBodyNode(body, depth + 1);
+    return nestedBody || body;
+  }
+
+  if (OUTLINE_CALL_TYPES.has(node.type)) {
+    const argBody = findCallArgumentBody(node.childForFieldName('arguments'), depth);
+    if (argBody) return argBody;
   }
+
+  for (const fieldName of ['value', 'expression', 'argument']) {
+    const child = node.childForFieldName(fieldName);
+    if (!child) continue;
+    const nestedBody = findBodyNode(child, depth + 1);
+    if (nestedBody) return nestedBody;
+  }
+
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const nestedBody = findBodyNode(node.namedChild(i), depth + 1);
+    if (nestedBody) return nestedBody;
+  }
+
   return null;
 }
 
+function computeBodyStartLine(node, bodyNode) {
+  if (!bodyNode) return null;
+
+  const bodyRow = bodyNode.startPosition.row;
+  const defRow = node.startPosition.row;
+  return bodyRow === defRow ? bodyRow + 2 : bodyRow + 1;
+}
+
+function createDefinition(name, node, filePath, langName, { bodyStartLine = null, kind } = {}) {
+  const bodyNode = bodyStartLine == null ? findBodyNode(node) : null;
+  const resolvedBodyStartLine = bodyStartLine ?? computeBodyStartLine(node, bodyNode);
+  const profileNode = bodyNode || node;
+
+  return {
+    name,
+    kind: kind || nodeKind(node.type),
+    file: filePath,
+    lineStart: node.startPosition.row + 1,
+    lineEnd: node.endPosition.row + 1,
+    signature: extractSignature(node, langName),
+    bodyStartLine: resolvedBodyStartLine,
+    astProfile: buildAstProfile(profileNode),
+    paramNames: extractParamNames(node),
+  };
+}
+
+function extractPairName(node) {
+  const keyNode = node.childForFieldName('key') || node.namedChild(0);
+  if (!keyNode) return null;
+
+  if (['property_identifier', 'identifier', 'private_property_identifier', 'number'].includes(keyNode.type)) {
+    return keyNode.text;
+  }
+
+  if (keyNode.type === 'string') {
+    return keyNode.text.replace(/^['"`]|['"`]$/g, '');
+  }
+
+  return null;
+}
+
+function hasMultilinePairChildren(node) {
+  if (!node || node.type !== 'object') return false;
+
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const child = node.namedChild(i);
+    if (child.type !== 'pair') continue;
+    if (!extractPairName(child)) continue;
+    if (child.endPosition.row > child.startPosition.row) return true;
+  }
+
+  return false;
+}
+
+function collectOutlineDefinitions(rootNode, filePath, langName) {
+  if (!OUTLINE_EXTRA_LANGUAGES.has(langName)) return [];
+
+  const definitions = [];
+
+  function visit(node) {
+    if (node.type === 'pair') {
+      const name = extractPairName(node);
+      if (name && node.endPosition.row > node.startPosition.row) {
+        definitions.push(createDefinition(name, node, filePath, langName, {
+          bodyStartLine: node.startPosition.row + 2,
+          kind: 'property',
+        }));
+      }
+    } else if (node.type === 'variable_declarator') {
+      const nameNode = node.childForFieldName('name');
+      const bodyNode = findBodyNode(node);
+      if (
+        nameNode &&
+        nameNode.type === 'identifier' &&
+        node.endPosition.row > node.startPosition.row &&
+        !(bodyNode && bodyNode.type === 'object' && hasMultilinePairChildren(bodyNode))
+      ) {
+        definitions.push(createDefinition(nameNode.text, node, filePath, langName, {
+          bodyStartLine: node.startPosition.row + 2,
+          kind: 'variable',
+        }));
+      }
+    }
+
+    for (let i = 0; i < node.namedChildCount; i++) {
+      visit(node.namedChild(i));
+    }
+  }
+
+  visit(rootNode);
+  return definitions;
+}
+
 function nodeKind(nodeType) {
   return KIND_MAP[nodeType] || 'other';
 }
@@ -393,11 +561,31 @@ function extractSignature(node, langName) {
   return sig.length > 200 ? sig.substring(0, 200) + '...' : sig;
 }
 
+function normalizeReferenceCapture(capture) {
+  if (!capture) return null;
+  const text = capture.node.text;
+  if (!text) return null;
+
+  if (capture.name === 'jsx_ref') {
+    return /^[A-Z]/.test(text) ? text : null;
+  }
+
+  return text;
+}
+
+function normalizeImportPathCapture(capture) {
+  if (!capture) return null;
+  const text = capture.node.text;
+  if (!text) return null;
+
+  return text.replace(/^['"`]|['"`]$/g, '');
+}
+
 /**
- * Parse a single source file and extract definitions + references.
+ * Parse a single source file and extract definitions, references, and imports.
  * Returns null if the language is unsupported.
  */
-function parseFile(filePath, source) {
+function parseFile(filePath, source, { includeOutlineDefinitions = false } = {}) {
   const dotIdx = filePath.lastIndexOf('.');
   if (dotIdx === -1) return null;
   const ext = filePath.substring(dotIdx);
@@ -411,6 +599,7 @@ function parseFile(filePath, source) {
 
   const definitions = [];
   const references = [];
+  const imports = [];
 
   const defQueryStr = DEF_QUERIES[langName] || null;
   if (defQueryStr) {
@@ -422,50 +611,54 @@ function parseFile(filePath, source) {
         if (!nameCapture) continue;
         const defNode = defCapture || nameCapture;
 
-        // Compute where body content starts (for outline collapsing)
-        const bodyNode = findBodyNode(defNode.node);
-        let bodyStartLine = null;
-        if (bodyNode) {
-          const bodyRow = bodyNode.startPosition.row;    // 0-indexed
-          const defRow = defNode.node.startPosition.row; // 0-indexed
-          // If body opens on same line as def (JS: `function foo() {`),
-          // content starts on next line. Otherwise body IS the content.
-          bodyStartLine = bodyRow === defRow ? bodyRow + 2 : bodyRow + 1; // 1-indexed
-        }
-
-        // Build AST profile from function body (or whole node if no body)
-        const profileNode = bodyNode || defNode.node;
-        const astProfile = buildAstProfile(profileNode);
-        const paramNames = extractParamNames(defNode.node);
-
-        definitions.push({
-          name: nameCapture.node.text,
-          kind: nodeKind(defNode.node.type),
-          file: filePath,
-          lineStart: defNode.node.startPosition.row + 1,
-          lineEnd: defNode.node.endPosition.row + 1,
-          signature: extractSignature(defNode.node, langName),
-          bodyStartLine,
-          astProfile,
-          paramNames,
-        });
+        definitions.push(createDefinition(nameCapture.node.text, defNode.node, filePath, langName));
       }
     } catch (e) {
       // Query may fail on some grammar versions; degrade gracefully
     }
   }
 
+  if (includeOutlineDefinitions) {
+    definitions.push(...collectOutlineDefinitions(tree.rootNode, filePath, langName));
+  }
+
   const refQueryStr = REF_QUERIES[langName] || REF_QUERIES.default;
   if (refQueryStr) {
     try {
       const refQuery = new Parser.Query(lang, refQueryStr);
       for (const match of refQuery.matches(tree.rootNode)) {
-        const refCapture = match.captures.find(c => c.name === 'ref');
-        if (!refCapture) continue;
-        references.push({
-          name: refCapture.node.text,
+        for (const capture of match.captures) {
+          if (capture.name !== 'ref' && capture.name !== 'jsx_ref') continue;
+          const name = normalizeReferenceCapture(capture);
+          if (!name) continue;
+          references.push({
+            name,
+            file: filePath,
+            line: capture.node.startPosition.row + 1,
+          });
+        }
+      }
+    } catch (e) {
+      // Degrade gracefully
+    }
+  }
+
+  const importQueryStr = IMPORT_QUERIES[langName] || null;
+  if (importQueryStr) {
+    try {
+      const importQuery = new Parser.Query(lang, importQueryStr);
+      for (const match of importQuery.matches(tree.rootNode)) {
+        const requireCapture = match.captures.find(c => c.name === 'require_fn');
+        if (requireCapture && requireCapture.node.text !== 'require') continue;
+
+        const pathCapture = match.captures.find(c => c.name === 'import_path');
+        const path = normalizeImportPathCapture(pathCapture);
+        if (!path) continue;
+
+        imports.push({
+          path,
           file: filePath,
-          line: refCapture.node.startPosition.row + 1,
+          line: pathCapture.node.startPosition.row + 1,
         });
       }
     } catch (e) {
@@ -494,7 +687,7 @@ function parseFile(filePath, source) {
 
   // No tree.delete()/parser.delete() needed — native GC handles cleanup
 
-  return { file: filePath, definitions, references };
+  return { file: filePath, definitions, references, imports };
 }
 
 export { parseFile, buildAstProfile, extractParamNames, SUPPORTED_EXTENSIONS, LANG_MAP };