@optave/codegraph 3.4.1 → 3.6.0

package/src/domain/parser.ts

@@ -16,26 +16,38 @@ import type {
 
 // Re-export all extractors for backward compatibility
 export {
+  extractBashSymbols,
+  extractCppSymbols,
   extractCSharpSymbols,
+  extractCSymbols,
   extractGoSymbols,
   extractHCLSymbols,
   extractJavaSymbols,
+  extractKotlinSymbols,
   extractPHPSymbols,
   extractPythonSymbols,
   extractRubySymbols,
   extractRustSymbols,
+  extractScalaSymbols,
+  extractSwiftSymbols,
   extractSymbols,
 } from '../extractors/index.js';
 
 import {
+  extractBashSymbols,
+  extractCppSymbols,
   extractCSharpSymbols,
+  extractCSymbols,
   extractGoSymbols,
   extractHCLSymbols,
   extractJavaSymbols,
+  extractKotlinSymbols,
   extractPHPSymbols,
   extractPythonSymbols,
   extractRubySymbols,
   extractRustSymbols,
+  extractScalaSymbols,
+  extractSwiftSymbols,
   extractSymbols,
 } from '../extractors/index.js';
 
@@ -85,6 +97,7 @@ const COMMON_QUERY_PATTERNS: string[] = [
   '(variable_declarator name: (identifier) @varfn_name value: (arrow_function) @varfn_value)',
   '(variable_declarator name: (identifier) @varfn_name value: (function_expression) @varfn_value)',
   '(method_definition name: (property_identifier) @meth_name) @meth_node',
+  '(method_definition name: (private_property_identifier) @meth_name) @meth_node',
   '(import_statement source: (string) @imp_source) @imp_node',
   '(export_statement) @exp_node',
   '(call_expression function: (identifier) @callfn_name) @callfn_node',
@@ -272,37 +285,38 @@ function resolveEngine(opts: ParseEngineOpts = {}): ResolvedEngine {
  *  - Backward compat for older native binaries missing js_name annotations
  *  - dataflow argFlows/mutations bindingType -> binding wrapper
  */
-function patchNativeResult(r: any): ExtractorOutput {
-  // lineCount: napi(js_name) emits "lineCount"; older binaries may emit "line_count"
-  r.lineCount = r.lineCount ?? r.line_count ?? null;
-  r._lineCount = r.lineCount;
-
-  // Backward compat for older binaries missing js_name annotations
-  if (r.definitions) {
-    for (const d of r.definitions) {
-      if (d.endLine === undefined && d.end_line !== undefined) {
-        d.endLine = d.end_line;
-      }
+/** Patch definition fields for backward compat with older native binaries. */
+function patchDefinitions(definitions: any[]): void {
+  for (const d of definitions) {
+    if (d.endLine === undefined && d.end_line !== undefined) {
+      d.endLine = d.end_line;
     }
   }
-  if (r.imports) {
-    for (const i of r.imports) {
-      if (i.typeOnly === undefined) i.typeOnly = i.type_only;
-      if (i.wildcardReexport === undefined) i.wildcardReexport = i.wildcard_reexport;
-      if (i.pythonImport === undefined) i.pythonImport = i.python_import;
-      if (i.goImport === undefined) i.goImport = i.go_import;
-      if (i.rustUse === undefined) i.rustUse = i.rust_use;
-      if (i.javaImport === undefined) i.javaImport = i.java_import;
-      if (i.csharpUsing === undefined) i.csharpUsing = i.csharp_using;
-      if (i.rubyRequire === undefined) i.rubyRequire = i.ruby_require;
-      if (i.phpUse === undefined) i.phpUse = i.php_use;
-      if (i.dynamicImport === undefined) i.dynamicImport = i.dynamic_import;
-    }
+}
+
+/** Patch import fields for backward compat with older native binaries. */
+function patchImports(imports: any[]): void {
+  for (const i of imports) {
+    if (i.typeOnly === undefined) i.typeOnly = i.type_only;
+    if (i.wildcardReexport === undefined) i.wildcardReexport = i.wildcard_reexport;
+    if (i.pythonImport === undefined) i.pythonImport = i.python_import;
+    if (i.goImport === undefined) i.goImport = i.go_import;
+    if (i.rustUse === undefined) i.rustUse = i.rust_use;
+    if (i.javaImport === undefined) i.javaImport = i.java_import;
+    if (i.csharpUsing === undefined) i.csharpUsing = i.csharp_using;
+    if (i.rubyRequire === undefined) i.rubyRequire = i.ruby_require;
+    if (i.phpUse === undefined) i.phpUse = i.php_use;
+    if (i.cInclude === undefined) i.cInclude = i.c_include;
+    if (i.kotlinImport === undefined) i.kotlinImport = i.kotlin_import;
+    if (i.swiftImport === undefined) i.swiftImport = i.swift_import;
+    if (i.scalaImport === undefined) i.scalaImport = i.scala_import;
+    if (i.bashSource === undefined) i.bashSource = i.bash_source;
+    if (i.dynamicImport === undefined) i.dynamicImport = i.dynamic_import;
   }
+}
 
-  // typeMap: native returns an array of {name, typeName}; normalize to Map.
-  // Non-TS languages may omit typeMap entirely — default to empty Map so
-  // callers can safely access .entries()/.size without null checks.
+/** Normalize native typeMap array to a Map instance. */
+function patchTypeMap(r: any): void {
   if (!r.typeMap) {
     r.typeMap = new Map();
   } else if (!(r.typeMap instanceof Map)) {
@@ -313,20 +327,31 @@ function patchNativeResult(r: any): ExtractorOutput {
       ]),
     );
   }
+}
 
-  // dataflow: wrap bindingType into binding object for argFlows and mutations
-  if (r.dataflow) {
-    if (r.dataflow.argFlows) {
-      for (const f of r.dataflow.argFlows) {
-        f.binding = f.bindingType ? { type: f.bindingType } : null;
-      }
+/** Wrap bindingType into binding object for dataflow argFlows and mutations. */
+function patchDataflow(dataflow: any): void {
+  if (dataflow.argFlows) {
+    for (const f of dataflow.argFlows) {
+      f.binding = f.bindingType ? { type: f.bindingType } : null;
     }
-    if (r.dataflow.mutations) {
-      for (const m of r.dataflow.mutations) {
-        m.binding = m.bindingType ? { type: m.bindingType } : null;
-      }
+  }
+  if (dataflow.mutations) {
+    for (const m of dataflow.mutations) {
+      m.binding = m.bindingType ? { type: m.bindingType } : null;
     }
   }
+}
+
+function patchNativeResult(r: any): ExtractorOutput {
+  // lineCount: napi(js_name) emits "lineCount"; older binaries may emit "line_count"
+  r.lineCount = r.lineCount ?? r.line_count ?? null;
+  r._lineCount = r.lineCount;
+
+  if (r.definitions) patchDefinitions(r.definitions);
+  if (r.imports) patchImports(r.imports);
+  patchTypeMap(r);
+  if (r.dataflow) patchDataflow(r.dataflow);
 
   return r;
 }
@@ -413,6 +438,48 @@ export const LANGUAGE_REGISTRY: LanguageRegistryEntry[] = [
     extractor: extractPHPSymbols,
     required: false,
   },
+  {
+    id: 'c',
+    extensions: ['.c', '.h'],
+    grammarFile: 'tree-sitter-c.wasm',
+    extractor: extractCSymbols,
+    required: false,
+  },
+  {
+    id: 'cpp',
+    extensions: ['.cpp', '.cc', '.cxx', '.hpp'],
+    grammarFile: 'tree-sitter-cpp.wasm',
+    extractor: extractCppSymbols,
+    required: false,
+  },
+  {
+    id: 'kotlin',
+    extensions: ['.kt', '.kts'],
+    grammarFile: 'tree-sitter-kotlin.wasm',
+    extractor: extractKotlinSymbols,
+    required: false,
+  },
+  {
+    id: 'swift',
+    extensions: ['.swift'],
+    grammarFile: 'tree-sitter-swift.wasm',
+    extractor: extractSwiftSymbols,
+    required: false,
+  },
+  {
+    id: 'scala',
+    extensions: ['.scala'],
+    grammarFile: 'tree-sitter-scala.wasm',
+    extractor: extractScalaSymbols,
+    required: false,
+  },
+  {
+    id: 'bash',
+    extensions: ['.sh', '.bash'],
+    grammarFile: 'tree-sitter-bash.wasm',
+    extractor: extractBashSymbols,
+    required: false,
+  },
 ];
 
 const _extToLang: Map<string, LanguageRegistryEntry> = new Map();
@@ -521,73 +588,48 @@ export async function parseFileAuto(
   return extracted ? extracted.symbols : null;
 }
 
-/**
- * Parse multiple files in bulk and return a Map<relPath, symbols>.
- */
-export async function parseFilesAuto(
-  filePaths: string[],
-  rootDir: string,
-  opts: ParseEngineOpts = {},
-): Promise<Map<string, ExtractorOutput>> {
-  const { native } = resolveEngine(opts);
-  const result = new Map<string, ExtractorOutput>();
+/** Backfill typeMap via WASM for files missing type-map data from native engine. */
+async function backfillTypeMapBatch(
+  needsTypeMap: { filePath: string; relPath: string }[],
+  result: Map<string, ExtractorOutput>,
+): Promise<void> {
+  const tsFiles = needsTypeMap.filter(({ filePath }) =>
+    TS_BACKFILL_EXTS.has(path.extname(filePath)),
+  );
+  if (tsFiles.length === 0) return;
 
-  if (native) {
-    const nativeResults = native.parseFiles(
-      filePaths,
-      rootDir,
-      !!opts.dataflow,
-      opts.ast !== false,
-    );
-    const needsTypeMap: { filePath: string; relPath: string }[] = [];
-    for (const r of nativeResults) {
-      if (!r) continue;
-      const patched = patchNativeResult(r);
-      const relPath = path.relative(rootDir, r.file).split(path.sep).join('/');
-      result.set(relPath, patched);
-      if (patched.typeMap.size === 0) {
-        needsTypeMap.push({ filePath: r.file, relPath });
+  const parsers = await createParsers();
+  for (const { filePath, relPath } of tsFiles) {
+    let extracted: WasmExtractResult | null | undefined;
+    try {
+      const code = fs.readFileSync(filePath, 'utf-8');
+      extracted = wasmExtractSymbols(parsers, filePath, code);
+      if (extracted?.symbols && extracted.symbols.typeMap.size > 0) {
+        const symbols = result.get(relPath);
+        if (!symbols) continue;
+        symbols.typeMap = extracted.symbols.typeMap;
+        symbols._typeMapBackfilled = true;
       }
-    }
-    // Backfill typeMap via WASM for native binaries that predate the type-map feature
-    if (needsTypeMap.length > 0) {
-      // Only backfill for languages where WASM extraction can produce typeMap
-      // (TS/TSX have type annotations; JS only has `new Expr()` which native already handles)
-      const tsFiles = needsTypeMap.filter(({ filePath }) =>
-        TS_BACKFILL_EXTS.has(path.extname(filePath)),
-      );
-      if (tsFiles.length > 0) {
-        const parsers = await createParsers();
-        for (const { filePath, relPath } of tsFiles) {
-          let extracted: WasmExtractResult | null | undefined;
-          try {
-            const code = fs.readFileSync(filePath, 'utf-8');
-            extracted = wasmExtractSymbols(parsers, filePath, code);
-            if (extracted?.symbols && extracted.symbols.typeMap.size > 0) {
-              const symbols = result.get(relPath);
-              if (!symbols) continue;
-              symbols.typeMap = extracted.symbols.typeMap;
-              symbols._typeMapBackfilled = true;
-            }
-          } catch (e) {
-            debug(`batchExtract: typeMap backfill failed: ${toErrorMessage(e)}`);
-          } finally {
-            // Free the WASM tree to prevent memory accumulation across repeated builds
-            if (extracted?.tree && typeof extracted.tree.delete === 'function') {
-              try {
-                extracted.tree.delete();
-              } catch (e) {
-                debug(`batchExtract: WASM tree cleanup failed: ${toErrorMessage(e)}`);
-              }
-            }
-          }
+    } catch (e) {
+      debug(`batchExtract: typeMap backfill failed: ${toErrorMessage(e)}`);
+    } finally {
+      if (extracted?.tree && typeof extracted.tree.delete === 'function') {
+        try {
+          extracted.tree.delete();
+        } catch (e) {
+          debug(`batchExtract: WASM tree cleanup failed: ${toErrorMessage(e)}`);
         }
       }
     }
-    return result;
   }
+}
 
-  // WASM path
+/** Parse files via WASM engine, returning a Map<relPath, symbols>. */
+async function parseFilesWasm(
+  filePaths: string[],
+  rootDir: string,
+): Promise<Map<string, ExtractorOutput>> {
+  const result = new Map<string, ExtractorOutput>();
   const parsers = await createParsers();
   for (const filePath of filePaths) {
     let code: string;
@@ -609,6 +651,36 @@ export async function parseFilesAuto(
   return result;
 }
 
+/**
+ * Parse multiple files in bulk and return a Map<relPath, symbols>.
+ */
+export async function parseFilesAuto(
+  filePaths: string[],
+  rootDir: string,
+  opts: ParseEngineOpts = {},
+): Promise<Map<string, ExtractorOutput>> {
+  const { native } = resolveEngine(opts);
+
+  if (!native) return parseFilesWasm(filePaths, rootDir);
+
+  const result = new Map<string, ExtractorOutput>();
+  const nativeResults = native.parseFiles(filePaths, rootDir, !!opts.dataflow, opts.ast !== false);
+  const needsTypeMap: { filePath: string; relPath: string }[] = [];
+  for (const r of nativeResults) {
+    if (!r) continue;
+    const patched = patchNativeResult(r);
+    const relPath = path.relative(rootDir, r.file).split(path.sep).join('/');
+    result.set(relPath, patched);
+    if (patched.typeMap.size === 0) {
+      needsTypeMap.push({ filePath: r.file, relPath });
+    }
+  }
+  if (needsTypeMap.length > 0) {
+    await backfillTypeMapBatch(needsTypeMap, result);
+  }
+  return result;
+}
+
 /**
  * Report which engine is active.
  */

package/src/domain/search/search/cli-formatter.ts

@@ -11,113 +11,98 @@ interface SearchOpts extends SemanticSearchOpts {
   offset?: number;
 }
 
-export async function search(
-  query: string,
-  customDbPath: string | undefined,
-  opts: SearchOpts = {},
-): Promise<void> {
-  const mode = opts.mode || 'hybrid';
+const kindIcon = (kind: string): string =>
+  kind === 'function' ? 'f' : kind === 'class' ? '*' : 'o';
 
-  const queries = query
-    .split(';')
-    .map((q) => q.trim())
-    .filter((q) => q.length > 0);
-
-  const kindIcon = (kind: string): string =>
-    kind === 'function' ? 'f' : kind === 'class' ? '*' : 'o';
-
-  // Keyword-only mode
-  if (mode === 'keyword') {
-    const singleQuery = queries.length === 1 ? queries[0]! : query;
-    const data = ftsSearchData(singleQuery, customDbPath, opts);
-    if (!data) {
-      console.log('No FTS5 index found. Run `codegraph embed` to build the keyword index.');
-      return;
-    }
-    if (opts.json) {
-      console.log(JSON.stringify(data, null, 2));
-      return;
-    }
-    console.log(`\nKeyword search: "${singleQuery}" (BM25)\n`);
-    if (data.results.length === 0) {
-      console.log('  No results found.');
-    } else {
-      for (const r of data.results) {
-        console.log(
-          `  BM25 ${r.bm25Score.toFixed(2)}  ${kindIcon(r.kind)} ${r.name} -- ${r.file}:${r.line}`,
-        );
-      }
-    }
-    console.log(`\n  ${data.results.length} results shown\n`);
+function formatKeywordResults(
+  singleQuery: string,
+  customDbPath: string | undefined,
+  opts: SearchOpts,
+): void {
+  const data = ftsSearchData(singleQuery, customDbPath, opts);
+  if (!data) {
+    console.log('No FTS5 index found. Run `codegraph embed` to build the keyword index.');
     return;
   }
-
-  // Semantic-only mode
-  if (mode === 'semantic') {
-    if (queries.length <= 1) {
-      const singleQuery = queries[0] || query;
-      const data = await searchData(singleQuery, customDbPath, opts);
-      if (!data) return;
-      if (opts.json) {
-        console.log(JSON.stringify(data, null, 2));
-        return;
-      }
-      console.log(`\nSemantic search: "${singleQuery}"\n`);
-      if (data.results.length === 0) {
-        console.log('  No results above threshold.');
-      } else {
-        for (const r of data.results) {
-          const bar = '#'.repeat(Math.round(r.similarity * 20));
-          console.log(`  ${(r.similarity * 100).toFixed(1)}% ${bar}`);
-          console.log(`    ${kindIcon(r.kind)} ${r.name} -- ${r.file}:${r.line}`);
-        }
-      }
-      console.log(`\n  ${data.results.length} results shown\n`);
-    } else {
-      const data = await multiSearchData(queries, customDbPath, opts);
-      if (!data) return;
-      if (opts.json) {
-        console.log(JSON.stringify(data, null, 2));
-        return;
-      }
-      console.log(`\nMulti-query semantic search (RRF, k=${opts.rrfK || 60}):`);
-      for (let i = 0; i < queries.length; i++) console.log(`  [${i + 1}] "${queries[i]}"`);
-      console.log();
-      if (data.results.length === 0) {
-        console.log('  No results above threshold.');
-      } else {
-        for (const r of data.results) {
-          console.log(
-            `  RRF ${r.rrf.toFixed(4)}  ${kindIcon(r.kind)} ${r.name} -- ${r.file}:${r.line}`,
-          );
-          for (const qs of r.queryScores) {
-            const bar = '#'.repeat(Math.round(qs.similarity * 20));
-            console.log(
-              `    [${queries.indexOf(qs.query) + 1}] ${(qs.similarity * 100).toFixed(1)}% ${bar} (rank ${qs.rank})`,
-            );
-          }
-        }
-      }
-      console.log(`\n  ${data.results.length} results shown\n`);
-    }
+  if (opts.json) {
+    console.log(JSON.stringify(data, null, 2));
     return;
   }
+  console.log(`\nKeyword search: "${singleQuery}" (BM25)\n`);
+  if (data.results.length === 0) {
+    console.log('  No results found.');
+  } else {
+    for (const r of data.results) {
+      console.log(
+        `  BM25 ${r.bm25Score.toFixed(2)}  ${kindIcon(r.kind)} ${r.name} -- ${r.file}:${r.line}`,
+      );
+    }
+  }
+  console.log(`\n  ${data.results.length} results shown\n`);
+}
 
-  // Hybrid mode (default)
-  const data = await hybridSearchData(query, customDbPath, opts);
-
-  if (!data) {
-    warn(
-      'FTS5 index not found — using semantic search only. Re-run `codegraph embed` to enable hybrid mode.',
-    );
-    return search(query, customDbPath, { ...opts, mode: 'semantic' });
+async function formatSemanticSingle(
+  singleQuery: string,
+  customDbPath: string | undefined,
+  opts: SearchOpts,
+): Promise<void> {
+  const data = await searchData(singleQuery, customDbPath, opts);
+  if (!data) return;
+  if (opts.json) {
+    console.log(JSON.stringify(data, null, 2));
+    return;
+  }
+  console.log(`\nSemantic search: "${singleQuery}"\n`);
+  if (data.results.length === 0) {
+    console.log('  No results above threshold.');
+  } else {
+    for (const r of data.results) {
+      const bar = '#'.repeat(Math.round(r.similarity * 20));
+      console.log(`  ${(r.similarity * 100).toFixed(1)}% ${bar}`);
+      console.log(`    ${kindIcon(r.kind)} ${r.name} -- ${r.file}:${r.line}`);
+    }
   }
+  console.log(`\n  ${data.results.length} results shown\n`);
+}
 
+async function formatSemanticMulti(
+  queries: string[],
+  customDbPath: string | undefined,
+  opts: SearchOpts,
+): Promise<void> {
+  const data = await multiSearchData(queries, customDbPath, opts);
+  if (!data) return;
   if (opts.json) {
     console.log(JSON.stringify(data, null, 2));
     return;
   }
+  console.log(`\nMulti-query semantic search (RRF, k=${opts.rrfK || 60}):`);
+  for (let i = 0; i < queries.length; i++) console.log(`  [${i + 1}] "${queries[i]}"`);
+  console.log();
+  if (data.results.length === 0) {
+    console.log('  No results above threshold.');
+  } else {
+    for (const r of data.results) {
+      console.log(
+        `  RRF ${r.rrf.toFixed(4)}  ${kindIcon(r.kind)} ${r.name} -- ${r.file}:${r.line}`,
+      );
+      for (const qs of r.queryScores) {
+        const bar = '#'.repeat(Math.round(qs.similarity * 20));
+        console.log(
+          `    [${queries.indexOf(qs.query) + 1}] ${(qs.similarity * 100).toFixed(1)}% ${bar} (rank ${qs.rank})`,
+        );
+      }
+    }
+  }
+  console.log(`\n  ${data.results.length} results shown\n`);
+}
 
+function formatHybridResults(
+  queries: string[],
+  query: string,
+  data: { results: any[] },
+  opts: SearchOpts,
+): void {
   const rrfK = opts.rrfK || 60;
   if (queries.length <= 1) {
     const singleQuery = queries[0] || query;
@@ -150,3 +135,45 @@ export async function search(
 
   console.log(`\n  ${data.results.length} results shown\n`);
 }
+
+export async function search(
+  query: string,
+  customDbPath: string | undefined,
+  opts: SearchOpts = {},
+): Promise<void> {
+  const mode = opts.mode || 'hybrid';
+
+  const queries = query
+    .split(';')
+    .map((q) => q.trim())
+    .filter((q) => q.length > 0);
+
+  if (mode === 'keyword') {
+    const singleQuery = queries.length === 1 ? queries[0]! : query;
+    return formatKeywordResults(singleQuery, customDbPath, opts);
+  }
+
+  if (mode === 'semantic') {
+    if (queries.length <= 1) {
+      return formatSemanticSingle(queries[0] || query, customDbPath, opts);
+    }
+    return formatSemanticMulti(queries, customDbPath, opts);
+  }
+
+  // Hybrid mode (default)
+  const data = await hybridSearchData(query, customDbPath, opts);
+
+  if (!data) {
+    warn(
+      'FTS5 index not found — using semantic search only. Re-run `codegraph embed` to enable hybrid mode.',
+    );
+    return search(query, customDbPath, { ...opts, mode: 'semantic' });
+  }
+
+  if (opts.json) {
+    console.log(JSON.stringify(data, null, 2));
+    return;
+  }
+
+  formatHybridResults(queries, query, data, opts);
+}

package/src/extractors/bash.ts

@@ -0,0 +1,97 @@
+import type { Call, ExtractorOutput, TreeSitterNode, TreeSitterTree } from '../types.js';
+import { nodeEndLine } from './helpers.js';
+
+/**
+ * Extract symbols from Bash/Shell files.
+ */
+export function extractBashSymbols(tree: TreeSitterTree, _filePath: string): ExtractorOutput {
+  const ctx: ExtractorOutput = {
+    definitions: [],
+    calls: [],
+    imports: [],
+    classes: [],
+    exports: [],
+    typeMap: new Map(),
+  };
+
+  walkBashNode(tree.rootNode, ctx);
+  return ctx;
+}
+
+function walkBashNode(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  switch (node.type) {
+    case 'function_definition':
+      handleBashFunctionDef(node, ctx);
+      break;
+    case 'command':
+      handleBashCommand(node, ctx);
+      break;
+  }
+
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) walkBashNode(child, ctx);
+  }
+}
+
+// ── Walk-path per-node-type handlers ────────────────────────────────────────
+
+function handleBashFunctionDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const nameNode = node.childForFieldName('name');
+  if (!nameNode) return;
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'function',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+}
+
+function handleBashCommand(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  // First child is command_name
+  let commandNameNode: TreeSitterNode | null = null;
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child && child.type === 'command_name') {
+      commandNameNode = child;
+      break;
+    }
+  }
+  if (!commandNameNode) return;
+
+  const cmdText = commandNameNode.text;
+
+  // "source" or "." commands are imports
+  if (cmdText === 'source' || cmdText === '.') {
+    // Second argument is the source path
+    let argNode: TreeSitterNode | null = null;
+    let foundCmd = false;
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (!child) continue;
+      if (child.type === 'command_name') {
+        foundCmd = true;
+        continue;
+      }
+      if (foundCmd && child.type !== 'command_name') {
+        argNode = child;
+        break;
+      }
+    }
+    if (argNode) {
+      const source = argNode.text;
+      const lastName = source.split('/').pop() ?? source;
+      ctx.imports.push({
+        source,
+        names: [lastName],
+        line: node.startPosition.row + 1,
+        bashSource: true,
+      });
+    }
+    return;
+  }
+
+  // Regular command call
+  const call: Call = { name: cmdText, line: node.startPosition.row + 1 };
+  ctx.calls.push(call);
+}