@mishasinitcyn/betterrank 0.2.8 → 0.2.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mishasinitcyn/betterrank",
-  "version": "0.2.8",
+  "version": "0.2.10",
   "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/cli.js

@@ -51,6 +51,10 @@ function/class signatures with bodies replaced by "... (N lines)".
 With symbol names (comma-separated): shows the full source of those
 specific functions/classes with line numbers.
 
+Also works well for indexed JS/TS object members like router procedures:
+use \`outline file.ts getTeamStatistics\` instead of expanding a whole giant
+\`createTRPCRouter({ ... })\` blob.
+
 Options:
   --root <path>     Resolve file path relative to this directory
   --annotate        Show caller counts next to each function (requires --root)
@@ -67,7 +71,8 @@ Examples:
 Aider-style repo map: the most structurally important definitions ranked by PageRank.
 
 Options:
-  --focus <files>   Comma-separated files to bias ranking toward
+  --focus <files>   Comma-separated files to strongly bias ranking toward the
+                    local import neighborhood of those files
   --count           Return total symbol count only
   --offset N        Skip first N symbols
   --limit N         Max symbols to return (default: ${DEFAULT_LIMIT})
@@ -83,7 +88,7 @@ Substring search on symbol names + full signatures (param names, types, defaults
 Results ranked by PageRank (most structurally important first).
 
 Options:
-  --kind <type>    Filter: function, class, type, variable, namespace, import
+  --kind <type>    Filter: function, class, type, variable, property, namespace, import
   --count          Return match count only
   --offset N       Skip first N results
   --limit N        Max results (default: ${DEFAULT_LIMIT})
@@ -92,6 +97,7 @@ Tips:
   Use short substrings (3-5 chars) — PageRank ranking handles noise.
   "imp" finds encrypt_imp_payload, increment_impression, etc.
   Searches match against both symbol names AND full signatures (param names, types).
+  JS/TS router procedures and other indexed object members appear as [property].
 
 Examples:
   betterrank search resolve --root ./backend
@@ -115,19 +121,23 @@ Results ranked by PageRank (most structurally important first).
 
 Options:
   --file <path>    Filter to a specific file (relative to --root)
-  --kind <type>    Filter: function, class, type, variable, namespace, import
+  --kind <type>    Filter: function, class, type, variable, property, namespace, import
   --count          Return count only
   --offset N       Skip first N results
   --limit N        Max results (default: ${DEFAULT_LIMIT})
 
 Examples:
   betterrank symbols --file src/auth/handlers.ts --root ./backend
-  betterrank symbols --kind class --root . --limit 20`,
+  betterrank symbols --kind class --root . --limit 20
+  betterrank symbols --file src/server/api/routers/project.ts --kind property --root .`,
 
   callers: `betterrank callers <symbol> [--file path] [--context [N]] [--root <path>]
 
 Find all files that reference a symbol. Ranked by file-level PageRank.
 
+For React/TS apps this includes JSX render sites like <Providers /> and
+property access sites like api.project.getTeamStatistics.useQuery().
+
 Options:
   --file <path>    Disambiguate when multiple symbols share a name
   --context [N]    Show N lines of context around each call site (default: 2)
@@ -142,7 +152,7 @@ Examples:
 
   context: `betterrank context <symbol> [--file path] [--root <path>]
 
-Everything you need to understand a function in one shot.
+Everything you need to understand a function or indexed property in one shot.
 
 Shows: the function's source, signatures of all functions/types it references,
 expanded type definitions from the signature, and a callers summary.
@@ -155,7 +165,8 @@ Options:
 
 Examples:
   betterrank context calculate_bid --root .
-  betterrank context Router --file src/llm.py --root .`,
+  betterrank context Router --file src/llm.py --root .
+  betterrank context getTeamStatistics --file src/server/api/routers/project.ts --root .`,
 
   history: `betterrank history <symbol> [--file path] [--patch] [--limit N] [--root <path>]
 
@@ -212,6 +223,8 @@ Examples:
 
 What this file imports / depends on. Ranked by PageRank.
 
+Resolves explicit import paths including TS/JS aliases and Python relative imports.
+
 Options:
   --count          Return count only
   --offset N       Skip first N results
@@ -224,6 +237,9 @@ Examples:
 
 What files import this file. Ranked by PageRank.
 
+Resolves explicit import paths including side-effect imports, TS/JS aliases,
+and Python relative imports.
+
 Options:
   --count          Return count only
   --offset N       Skip first N results

package/src/graph.js

@@ -25,6 +25,13 @@ const IMPORT_RESOLVE_EXTENSIONS = [
   '.py', '.rs', '.go', '.rb', '.java',
   '.c', '.h', '.cpp', '.hpp', '.cc', '.cs', '.php',
 ];
+const FOCUS_MAX_HOPS = 2;
+const FOCUS_DISTANCE_WEIGHTS = new Map([
+  [0, 250],
+  [1, 12],
+  [2, 2.5],
+]);
+const FOCUS_DEFAULT_WEIGHT = 0.15;
 
 /**
  * Disambiguate which targets a reference should wire to.
@@ -77,6 +84,37 @@ function buildFileLookup(graph) {
   return fileLookup;
 }
 
+function isPythonFile(filePath) {
+  return normalizeFilePath(filePath).endsWith('.py');
+}
+
+function resolvePythonImportBase(sourceFile, specifier) {
+  if (!isPythonFile(sourceFile)) return null;
+  if (!specifier) return null;
+
+  if (specifier.startsWith('.')) {
+    const match = specifier.match(/^(\.+)(.*)$/);
+    if (!match) return null;
+
+    const dots = match[1].length;
+    let baseDir = posix.dirname(sourceFile);
+    for (let i = 1; i < dots; i++) {
+      baseDir = posix.dirname(baseDir);
+    }
+
+    const remainder = match[2].replace(/^\./, '');
+    if (!remainder) return baseDir;
+
+    return posix.normalize(posix.join(baseDir, remainder.replace(/\./g, '/')));
+  }
+
+  if (/^[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)*$/.test(specifier)) {
+    return specifier.replace(/\./g, '/');
+  }
+
+  return null;
+}
+
 function resolveImportBase(sourceFile, specifier) {
   const normalizedSource = normalizeFilePath(sourceFile);
   const normalizedSpecifier = normalizeFilePath(specifier);
@@ -98,6 +136,9 @@ function resolveImportBase(sourceFile, specifier) {
     return posix.normalize(normalizedSpecifier);
   }
 
+  const pythonBase = resolvePythonImportBase(normalizedSource, normalizedSpecifier);
+  if (pythonBase) return pythonBase;
+
   return null;
 }
 
@@ -114,8 +155,11 @@ function resolveImportTargetFile(sourceFile, specifier, fileLookup) {
     for (const ext of IMPORT_RESOLVE_EXTENSIONS) {
       candidates.push(`${importBase}${ext}`);
     }
+    const packageEntryNames = isPythonFile(sourceFile) ? ['__init__'] : ['index'];
     for (const ext of IMPORT_RESOLVE_EXTENSIONS) {
-      candidates.push(posix.join(importBase, `index${ext}`));
+      for (const entryName of packageEntryNames) {
+        candidates.push(posix.join(importBase, `${entryName}${ext}`));
+      }
     }
   }
 
@@ -133,7 +177,14 @@ function wireSymbolReferences(records, graph, defIndex, addedRefs, addedImports)
       const targets = defIndex.get(ref.name);
       if (!targets) continue;
 
-      const resolvedTargets = disambiguateTargets(targets, file, graph);
+      const filteredTargets = ref.kind === 'property'
+        ? targets.filter(target => {
+          try { return graph.getNodeAttribute(target, 'kind') === 'property'; } catch { return false; }
+        })
+        : targets;
+      if (filteredTargets.length === 0) continue;
+
+      const resolvedTargets = disambiguateTargets(filteredTargets, file, graph);
 
       for (const target of resolvedTargets) {
         const targetFile = graph.getNodeAttribute(target, 'file');
@@ -222,6 +273,10 @@ function updateGraphFiles(graph, removedFiles, newSymbols) {
       continue;
     }
 
+    if (!graph.hasNode(filePath)) {
+      continue;
+    }
+
     const outgoingEdges = [];
     graph.forEachOutEdge(filePath, edge => {
       outgoingEdges.push(edge);
@@ -263,6 +318,56 @@ function removeFileNodes(graph, filePath) {
   }
 }
 
+function buildFocusDistanceMap(graph, focusFiles, maxHops = FOCUS_MAX_HOPS) {
+  const distances = new Map();
+  const queue = [];
+
+  for (const file of focusFiles) {
+    if (!graph.hasNode(file)) continue;
+    const attrs = graph.getNodeAttributes(file);
+    if (attrs.type !== 'file') continue;
+    distances.set(file, 0);
+    queue.push(file);
+  }
+
+  for (let i = 0; i < queue.length; i++) {
+    const current = queue[i];
+    const currentDistance = distances.get(current);
+    if (currentDistance >= maxHops) continue;
+
+    const visitNeighbor = neighbor => {
+      if (!graph.hasNode(neighbor)) return;
+      const neighborAttrs = graph.getNodeAttributes(neighbor);
+      if (neighborAttrs.type !== 'file') return;
+
+      const nextDistance = currentDistance + 1;
+      const existing = distances.get(neighbor);
+      if (existing !== undefined && existing <= nextDistance) return;
+      distances.set(neighbor, nextDistance);
+      queue.push(neighbor);
+    };
+
+    graph.forEachOutEdge(current, (_edge, attrs, _source, target) => {
+      if (attrs.type !== 'IMPORTS') return;
+      visitNeighbor(target);
+    });
+
+    graph.forEachInEdge(current, (_edge, attrs, source) => {
+      if (attrs.type !== 'IMPORTS') return;
+      visitNeighbor(source);
+    });
+  }
+
+  return distances;
+}
+
+function getFocusWeight(filePath, focusDistances) {
+  if (!focusDistances || focusDistances.size === 0) return 1.0;
+  const distance = focusDistances.get(filePath);
+  if (distance === undefined) return FOCUS_DEFAULT_WEIGHT;
+  return FOCUS_DISTANCE_WEIGHTS.get(distance) || FOCUS_DEFAULT_WEIGHT;
+}
+
 // Path-tier dampening: files outside core source directories get their
 // PageRank scores multiplied by a fraction. This prevents scripts, tests,
 // and temp files from dominating the map output over actual source code.
@@ -298,6 +403,7 @@ function rankedSymbols(graph, focusFiles = [], pathTiers = DEFAULT_PATH_TIERS) {
   if (graph.order === 0) return [];
 
   const g = graph.copy();
+  const focusDistances = focusFiles.length > 0 ? buildFocusDistanceMap(graph, focusFiles) : null;
 
   if (focusFiles.length > 0) {
     g.mergeNode('__focus__', { type: 'virtual' });
@@ -329,7 +435,7 @@ function rankedSymbols(graph, focusFiles = [], pathTiers = DEFAULT_PATH_TIERS) {
     .map(([key, score]) => {
       try {
         const file = graph.getNodeAttribute(key, 'file');
-        return [key, score * getPathWeight(file, pathTiers)];
+        return [key, score * getPathWeight(file, pathTiers) * getFocusWeight(file, focusDistances)];
       } catch {
         return [key, score];
       }

package/src/index.js

@@ -232,6 +232,26 @@ function paginate(arr, { offset = 0, limit } = {}) {
   return { items, total };
 }
 
+const CONTEXT_NOISE_NAMES = new Set([
+  'get', 'set', 'put', 'post', 'delete', 'head', 'patch',
+  'start', 'stop', 'run', 'main', 'init', 'setup', 'close',
+  'dict', 'list', 'str', 'int', 'bool', 'float', 'type',
+  'key', 'value', 'name', 'data', 'config', 'result', 'error',
+  'test', 'self', 'cls', 'app', 'log', 'logger',
+  'enabled', 'default', 'constructor', 'length', 'size',
+  'fetch', 'send', 'table', 'one', 'append', 'write', 'read',
+  'update', 'create', 'find', 'add', 'remove', 'index', 'map',
+  'filter', 'sort', 'join', 'split', 'trim', 'replace',
+  'push', 'pop', 'shift', 'reduce', 'keys', 'values', 'items',
+  'search', 'match', 'query', 'count', 'call', 'apply', 'bind',
+]);
+
+const CONTEXT_KIND_ORDER = { function: 0, class: 1, type: 2, property: 3, variable: 4 };
+
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
 class CodeIndex {
   constructor(projectRoot, opts = {}) {
     this.projectRoot = projectRoot;
@@ -579,6 +599,8 @@ class CodeIndex {
       const escaped = symbol.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
       const callPattern = new RegExp(`(?<![a-zA-Z0-9_])${escaped}\\s*\\(`);
       const jsxPattern = new RegExp(`<\\s*${escaped}(?=[\\s>/.]|$)`);
+      const memberPattern = new RegExp(`\\.\\s*${escaped}\\b`);
+      const bracketPattern = new RegExp(`\\[\\s*['"\`]${escaped}['"\`]\\s*\\]`);
       // Fallback: import/from lines that reference the symbol
       const importPattern = new RegExp(`(?:import|from)\\s.*\\b${escaped}\\b`);
 
@@ -605,7 +627,13 @@ class CodeIndex {
             if (inDef) continue;
 
             const line = lines[i];
-            if (!callPattern.test(line) && !jsxPattern.test(line) && !importPattern.test(line)) continue;
+            if (
+              !callPattern.test(line) &&
+              !jsxPattern.test(line) &&
+              !memberPattern.test(line) &&
+              !bracketPattern.test(line) &&
+              !importPattern.test(line)
+            ) continue;
 
             const start = Math.max(0, i - context);
             const end = Math.min(lines.length - 1, i + context);
@@ -1109,55 +1137,60 @@ class CodeIndex {
     const bodyLines = lines.slice(target.lineStart - 1, target.lineEnd);
     const bodyText = bodyLines.join('\n');
 
-    // Build a set of all symbol names in the graph (for matching)
-    const allSymbols = new Map(); // name -> [{ file, kind, signature, lineStart }]
+    // Build a set of all symbol names in the graph.
+    const allSymbols = new Map(); // name -> [{ file, kind, signature, lineStart, score }]
     graph.forEachNode((node, attrs) => {
       if (attrs.type !== 'symbol') return;
       if (attrs.file === target.file && attrs.name === target.name) return; // skip self
       if (!allSymbols.has(attrs.name)) allSymbols.set(attrs.name, []);
       allSymbols.get(attrs.name).push({
+        key: node,
         file: attrs.file,
         kind: attrs.kind,
         signature: attrs.signature,
         lineStart: attrs.lineStart,
         lineEnd: attrs.lineEnd,
+        score: scoreMap.get(node) || 0,
       });
     });
 
-    // Find symbols referenced in the body
-    // Use word-boundary matching for each known symbol name
-    // Skip very common names that cause false positives
-    const NOISE_NAMES = new Set([
-      'get', 'set', 'put', 'post', 'delete', 'head', 'patch',
-      'start', 'stop', 'run', 'main', 'init', 'setup', 'close',
-      'dict', 'list', 'str', 'int', 'bool', 'float', 'type',
-      'key', 'value', 'name', 'data', 'config', 'result', 'error',
-      'test', 'self', 'cls', 'app', 'log', 'logger',
-      'enabled', 'default', 'constructor', 'length', 'size',
-      'fetch', 'send', 'table', 'one', 'append', 'write', 'read',
-      'update', 'create', 'find', 'add', 'remove', 'index', 'map',
-      'filter', 'sort', 'join', 'split', 'trim', 'replace',
-      'push', 'pop', 'shift', 'reduce', 'keys', 'values', 'items',
-      'search', 'match', 'query', 'count', 'call', 'apply', 'bind',
-    ]);
-    const usedSymbols = [];
-    const seen = new Set();
-    for (const [name, defs] of allSymbols) {
-      if (name.length < 3) continue; // skip very short names
-      if (NOISE_NAMES.has(name)) continue;
-      if (seen.has(name)) continue;
-      const pattern = new RegExp(`(?<![a-zA-Z0-9_])${name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?![a-zA-Z0-9_])`);
-      if (pattern.test(bodyText)) {
-        seen.add(name);
-        // Pick the best definition (same-file first, then highest PageRank)
-        const sameFile = defs.find(d => d.file === target.file);
-        const best = sameFile || defs[0];
-        usedSymbols.push({ name, ...best });
+    for (const defs of allSymbols.values()) {
+      defs.sort((a, b) =>
+        Number(b.file === target.file) - Number(a.file === target.file)
+        || (b.score || 0) - (a.score || 0)
+        || a.file.localeCompare(b.file)
+        || a.lineStart - b.lineStart,
+      );
+    }
+
+    // Find symbols referenced in the body, preferring parser-scoped local refs.
+    const referenceNames = new Set();
+    for (const name of target.localRefs || []) {
+      if (!name || name.length < 3) continue;
+      if (CONTEXT_NOISE_NAMES.has(name)) continue;
+      if (!allSymbols.has(name)) continue;
+      referenceNames.add(name);
+    }
+
+    // Fallback for older caches or definitions without scoped refs.
+    if (referenceNames.size === 0) {
+      for (const name of allSymbols.keys()) {
+        if (name.length < 3) continue;
+        if (CONTEXT_NOISE_NAMES.has(name)) continue;
+        const pattern = new RegExp(`(?<![a-zA-Z0-9_])${escapeRegExp(name)}(?![a-zA-Z0-9_])`);
+        if (pattern.test(bodyText)) {
+          referenceNames.add(name);
+        }
       }
     }
-    // Sort: functions first, then types, then by name
-    const kindOrder = { function: 0, class: 1, type: 2, variable: 3 };
-    usedSymbols.sort((a, b) => (kindOrder[a.kind] ?? 9) - (kindOrder[b.kind] ?? 9) || a.name.localeCompare(b.name));
+
+    const usedSymbols = [];
+    for (const name of referenceNames) {
+      const defs = allSymbols.get(name);
+      if (!defs || defs.length === 0) continue;
+      usedSymbols.push({ name, ...defs[0] });
+    }
+    usedSymbols.sort((a, b) => (CONTEXT_KIND_ORDER[a.kind] ?? 9) - (CONTEXT_KIND_ORDER[b.kind] ?? 9) || a.name.localeCompare(b.name));
 
     // Resolve type annotations in the signature
     // Extract type-like tokens from the signature (capitalized words, common patterns)
@@ -1173,7 +1206,7 @@ class CodeIndex {
       const typeDefs = allSymbols.get(typeName);
       if (!typeDefs) continue;
       // Find the type definition and get its fields (expand its body)
-      const best = typeDefs.find(d => d.file === target.file) || typeDefs[0];
+      const best = typeDefs[0];
       if (best.kind === 'class' || best.kind === 'type') {
         let fields = null;
         try {

package/src/parser.js

@@ -188,6 +188,7 @@ const REF_QUERIES = {
     (call_expression function: (identifier) @ref)
     (import_specifier name: (identifier) @ref)
     (import_clause (identifier) @ref)
+    (member_expression property: (property_identifier) @prop_ref)
     (jsx_opening_element (identifier) @jsx_ref)
     (jsx_self_closing_element (identifier) @jsx_ref)
     (jsx_opening_element (member_expression (identifier) @jsx_ref))
@@ -198,6 +199,7 @@ const REF_QUERIES = {
     (call_expression function: (identifier) @ref)
     (import_specifier name: (identifier) @ref)
     (import_clause (identifier) @ref)
+    (member_expression property: (property_identifier) @prop_ref)
     (type_identifier) @ref
   `,
 
@@ -205,6 +207,7 @@ const REF_QUERIES = {
     (call_expression function: (identifier) @ref)
     (import_specifier name: (identifier) @ref)
     (import_clause (identifier) @ref)
+    (member_expression property: (property_identifier) @prop_ref)
     (type_identifier) @ref
     (jsx_opening_element (identifier) @jsx_ref)
     (jsx_self_closing_element (identifier) @jsx_ref)
@@ -287,8 +290,12 @@ const KIND_MAP = {
 };
 
 const OUTLINE_EXTRA_LANGUAGES = new Set(['javascript', 'typescript', 'tsx']);
+const INDEX_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']);
+const SEMANTIC_CONTAINER_NAME_RE = /(router|routes|handlers|actions|reducers|selectors|queries|mutations|registry|registries|map|maps|config|configs|options|endpoints|procedures)$/i;
+const NON_SEMANTIC_CONTAINER_NAME_RE = /(schema|shape|validator|payload|params?|props?|input|output|response|request|dto)$/i;
+const NON_SEMANTIC_CALLEE_NAME_RE = /^(object|array|enum|union|literal|record|tuple|pick|omit|extend|merge|intersection|partial|strictObject|looseObject)$/i;
 
 /**
  * Walk an AST subtree and count node types that reveal structural shape.
@@ -488,6 +495,111 @@ function hasMultilinePairChildren(node) {
   return false;
 }
 
+function isTopLevelVariableDeclarator(node) {
+  if (!node || node.type !== 'variable_declarator') return false;
+  const decl = node.parent;
+  if (!decl || decl.type !== 'lexical_declaration') return false;
+  const container = decl.parent;
+  return !!container && (container.type === 'program' || container.type === 'export_statement');
+}
+
+function extractDeclaratorName(node) {
+  const nameNode = node?.childForFieldName('name');
+  return nameNode?.type === 'identifier' ? nameNode.text : null;
+}
+
+function extractCalleeLeafName(node) {
+  if (!node) return null;
+
+  if (['identifier', 'property_identifier', 'private_property_identifier', 'type_identifier'].includes(node.type)) {
+    return node.text;
+  }
+
+  if (node.type === 'member_expression') {
+    const propertyNode = node.childForFieldName('property');
+    if (propertyNode) return extractCalleeLeafName(propertyNode);
+    return extractCalleeLeafName(node.namedChild(node.namedChildCount - 1));
+  }
+
+  return null;
+}
+
+function extractCallLikeCalleeName(node) {
+  if (!node || (node.type !== 'call_expression' && node.type !== 'new_expression')) return null;
+
+  const calleeNode = node.childForFieldName('function')
+    || node.childForFieldName('constructor')
+    || node.namedChild(0);
+  return extractCalleeLeafName(calleeNode);
+}
+
+function shouldIndexSemanticObjectMembers(node) {
+  if (!isTopLevelVariableDeclarator(node)) return false;
+
+  const variableName = extractDeclaratorName(node);
+  const valueNode = node.childForFieldName('value');
+  const calleeName = extractCallLikeCalleeName(valueNode);
+
+  const hasSemanticVariableName = !!variableName
+    && SEMANTIC_CONTAINER_NAME_RE.test(variableName)
+    && !NON_SEMANTIC_CONTAINER_NAME_RE.test(variableName);
+  const hasSemanticCalleeName = !!calleeName && !NON_SEMANTIC_CALLEE_NAME_RE.test(calleeName);
+
+  if (valueNode?.type === 'object') {
+    return hasSemanticVariableName;
+  }
+
+  if (valueNode?.type === 'call_expression' || valueNode?.type === 'new_expression') {
+    return hasSemanticVariableName || hasSemanticCalleeName;
+  }
+
+  return false;
+}
+
+function collectDirectPairDefinitions(node, filePath, langName) {
+  if (!node || node.type !== 'object') return [];
+
+  const definitions = [];
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const child = node.namedChild(i);
+    if (child.type !== 'pair') continue;
+
+    const name = extractPairName(child);
+    if (!name) continue;
+    if (child.endPosition.row <= child.startPosition.row) continue;
+
+    definitions.push(createDefinition(name, child, filePath, langName, {
+      bodyStartLine: child.startPosition.row + 2,
+      kind: 'property',
+    }));
+  }
+
+  return definitions;
+}
+
+function collectIndexDefinitions(rootNode, filePath, langName) {
+  if (!INDEX_EXTRA_LANGUAGES.has(langName)) return [];
+
+  const definitions = [];
+
+  function visit(node) {
+    if (node.type === 'variable_declarator' && shouldIndexSemanticObjectMembers(node)) {
+      const bodyNode = findBodyNode(node);
+      if (bodyNode && bodyNode.type === 'object') {
+        definitions.push(...collectDirectPairDefinitions(bodyNode, filePath, langName));
+      }
+      return;
+    }
+
+    for (let i = 0; i < node.namedChildCount; i++) {
+      visit(node.namedChild(i));
+    }
+  }
+
+  visit(rootNode);
+  return definitions;
+}
+
 function collectOutlineDefinitions(rootNode, filePath, langName) {
   if (!OUTLINE_EXTRA_LANGUAGES.has(langName)) return [];
 
@@ -581,6 +693,52 @@ function normalizeImportPathCapture(capture) {
   return text.replace(/^['"`]|['"`]$/g, '');
 }
 
+function createImportEntry(path, filePath, node) {
+  if (!path || !filePath || !node) return null;
+  return {
+    path,
+    file: filePath,
+    line: node.startPosition.row + 1,
+  };
+}
+
+function collectPythonImports(rootNode, filePath) {
+  const imports = [];
+
+  function push(path, node) {
+    const entry = createImportEntry(path, filePath, node);
+    if (entry) imports.push(entry);
+  }
+
+  function visit(node) {
+    if (node.type === 'import_statement') {
+      for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child.type === 'dotted_name') {
+          push(child.text, child);
+          continue;
+        }
+        if (child.type === 'aliased_import') {
+          const moduleNode = child.namedChild(0);
+          if (moduleNode?.type === 'dotted_name') {
+            push(moduleNode.text, moduleNode);
+          }
+        }
+      }
+    } else if (node.type === 'import_from_statement') {
+      const moduleNode = node.childForFieldName('module_name');
+      if (moduleNode) push(moduleNode.text, moduleNode);
+    }
+
+    for (let i = 0; i < node.namedChildCount; i++) {
+      visit(node.namedChild(i));
+    }
+  }
+
+  visit(rootNode);
+  return imports;
+}
+
 /**
  * Parse a single source file and extract definitions, references, and imports.
  * Returns null if the language is unsupported.
@@ -618,6 +776,8 @@ function parseFile(filePath, source, { includeOutlineDefinitions = false } = {})
     }
   }
 
+  definitions.push(...collectIndexDefinitions(tree.rootNode, filePath, langName));
+
   if (includeOutlineDefinitions) {
     definitions.push(...collectOutlineDefinitions(tree.rootNode, filePath, langName));
   }
@@ -628,11 +788,12 @@ function parseFile(filePath, source, { includeOutlineDefinitions = false } = {})
       const refQuery = new Parser.Query(lang, refQueryStr);
       for (const match of refQuery.matches(tree.rootNode)) {
         for (const capture of match.captures) {
-          if (capture.name !== 'ref' && capture.name !== 'jsx_ref') continue;
+          if (capture.name !== 'ref' && capture.name !== 'jsx_ref' && capture.name !== 'prop_ref') continue;
           const name = normalizeReferenceCapture(capture);
           if (!name) continue;
           references.push({
             name,
+            kind: capture.name === 'prop_ref' ? 'property' : 'symbol',
             file: filePath,
             line: capture.node.startPosition.row + 1,
           });
@@ -666,6 +827,10 @@ function parseFile(filePath, source, { includeOutlineDefinitions = false } = {})
     }
   }
 
+  if (langName === 'python') {
+    imports.push(...collectPythonImports(tree.rootNode, filePath));
+  }
+
   // Associate each reference with its enclosing definition (by line range).
   // This gives us per-function reference sets for similarity analysis.
   // Sort definitions by lineStart for binary search.