@mishasinitcyn/betterrank 0.2.5 → 0.2.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mishasinitcyn/betterrank",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "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/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);
   }
@@ -84,24 +84,79 @@ function expandMode(lines, defs, filePath, expandSymbols, pad) {
   return output.join('\n').trimEnd();
 }
 
+// Detect a contiguous block of import statements at the top of the file.
+// Returns { start, end, lineCount } (1-indexed) or null if block is < 3 lines.
+// Blank lines and leading non-import lines (e.g. "use client") are skipped over.
+function detectImportBlock(lines) {
+  let braceDepth = 0;
+  let inImport = false;
+  let firstImportLine = -1; // 0-indexed
+  let lastImportLine = -1;  // 0-indexed
+
+  for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    if (trimmed === '') continue;
+
+    if (!inImport) {
+      if (trimmed.startsWith('import ') || trimmed === 'import') {
+        if (firstImportLine === -1) firstImportLine = i;
+        braceDepth = 0;
+        for (const ch of lines[i]) {
+          if (ch === '{') braceDepth++;
+          else if (ch === '}') braceDepth--;
+        }
+        if (braceDepth > 0) {
+          inImport = true;
+        } else {
+          lastImportLine = i;
+        }
+      } else if (firstImportLine !== -1) {
+        // First non-blank, non-import line after imports began
+        break;
+      }
+      // else: pre-import line ("use client", comments) — keep scanning
+    } else {
+      for (const ch of lines[i]) {
+        if (ch === '{') braceDepth++;
+        else if (ch === '}') braceDepth--;
+      }
+      if (braceDepth <= 0) {
+        inImport = false;
+        lastImportLine = i;
+      }
+    }
+  }
+
+  if (firstImportLine === -1 || lastImportLine === -1) return null;
+  const lineCount = lastImportLine - firstImportLine + 1;
+  if (lineCount < 3) return null;
+  return { start: firstImportLine + 1, end: lastImportLine + 1, lineCount, name: null };
+}
+
 function outlineMode(lines, defs, pad, callerCounts) {
-  // Detect containers: definitions that have child definitions inside them
-  const containers = new Set();
+  // Mark definitions that are nested inside another definition.
+  // Only top-level defs get their own collapse range — nested ones are swallowed
+  // by the parent's collapse, preventing dozens of inline-callback markers.
+  const nested = new Set();
   for (const def of defs) {
     for (const other of defs) {
       if (other === def) continue;
-      if (other.lineStart > def.lineStart && other.lineEnd <= def.lineEnd) {
-        containers.add(def);
+      if (def.lineStart > other.lineStart && def.lineEnd <= other.lineEnd) {
+        nested.add(def);
         break;
       }
     }
   }
 
-  // Build collapse ranges for leaf definitions with sufficient body size
-  // Track which definition each collapse range belongs to (for annotations)
   const collapseRanges = [];
+
+  // Collapse the import block first (covers the lucide/shadcn import wall in TSX)
+  const importCollapse = detectImportBlock(lines);
+  if (importCollapse) collapseRanges.push(importCollapse);
+
+  // Collapse all top-level definitions (functions, classes, interfaces, components)
   for (const def of defs) {
-    if (containers.has(def)) continue;
+    if (nested.has(def)) continue;
     if (!def.bodyStartLine) continue;
     if (def.bodyStartLine > def.lineEnd) continue;
 
@@ -131,7 +186,7 @@ function outlineMode(lines, defs, pad, callerCounts) {
       let marker = `${' '.repeat(pad)}│ ${indent}... (${range.lineCount} lines)`;
 
       // Append caller annotation if available
-      if (callerCounts && callerCounts.has(range.name)) {
+      if (callerCounts && range.name && callerCounts.has(range.name)) {
         const count = callerCounts.get(range.name);
         const annotation = count === 1 ? '← 1 caller' : `← ${count} callers`;
         // Right-pad to align annotations

package/src/parser.js

@@ -244,8 +244,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 +348,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';
 }
@@ -397,7 +526,7 @@ function extractSignature(node, langName) {
  * Parse a single source file and extract definitions + references.
  * 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);
@@ -422,39 +551,17 @@ 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 {