@optave/codegraph 3.5.0 → 3.6.0

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);
+}

package/src/extractors/c.ts

@@ -0,0 +1,212 @@
+import type {
+  Call,
+  ExtractorOutput,
+  SubDeclaration,
+  TreeSitterNode,
+  TreeSitterTree,
+} from '../types.js';
+import { findChild, nodeEndLine } from './helpers.js';
+
+/**
+ * Extract symbols from C files.
+ */
+export function extractCSymbols(tree: TreeSitterTree, _filePath: string): ExtractorOutput {
+  const ctx: ExtractorOutput = {
+    definitions: [],
+    calls: [],
+    imports: [],
+    classes: [],
+    exports: [],
+    typeMap: new Map(),
+  };
+
+  walkCNode(tree.rootNode, ctx);
+  return ctx;
+}
+
+function walkCNode(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  switch (node.type) {
+    case 'function_definition':
+      handleCFunctionDef(node, ctx);
+      break;
+    case 'struct_specifier':
+      handleCStructSpecifier(node, ctx);
+      break;
+    case 'enum_specifier':
+      handleCEnumSpecifier(node, ctx);
+      break;
+    case 'type_definition':
+      handleCTypedef(node, ctx);
+      break;
+    case 'preproc_include':
+      handleCInclude(node, ctx);
+      break;
+    case 'call_expression':
+      handleCCallExpression(node, ctx);
+      break;
+  }
+
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) walkCNode(child, ctx);
+  }
+}
+
+// ── Walk-path per-node-type handlers ────────────────────────────────────────
+
+function handleCFunctionDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  // declarator > function_declarator > declarator(identifier)
+  const declarator = node.childForFieldName('declarator');
+  if (!declarator) return;
+  const funcDeclarator =
+    declarator.type === 'function_declarator'
+      ? declarator
+      : findChild(declarator, 'function_declarator');
+  if (!funcDeclarator) return;
+  const nameNode = funcDeclarator.childForFieldName('declarator');
+  if (!nameNode) return;
+  const name = nameNode.type === 'identifier' ? nameNode.text : nameNode.text;
+
+  const params = extractCParameters(funcDeclarator.childForFieldName('parameters'));
+  ctx.definitions.push({
+    name,
+    kind: 'function',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+    children: params.length > 0 ? params : undefined,
+  });
+}
+
+function handleCStructSpecifier(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const nameNode = node.childForFieldName('name');
+  if (!nameNode) return;
+  const children = extractStructFields(node);
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'struct',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+    children: children.length > 0 ? children : undefined,
+  });
+}
+
+function handleCEnumSpecifier(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const nameNode = node.childForFieldName('name');
+  if (!nameNode) return;
+  const children = extractEnumEntries(node);
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'enum',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+    children: children.length > 0 ? children : undefined,
+  });
+}
+
+function handleCTypedef(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  // The typedef name is the last type_identifier, identifier, or primitive_type child
+  let name: string | undefined;
+  for (let i = node.childCount - 1; i >= 0; i--) {
+    const child = node.child(i);
+    if (
+      child &&
+      (child.type === 'type_identifier' ||
+        child.type === 'identifier' ||
+        child.type === 'primitive_type')
+    ) {
+      name = child.text;
+      break;
+    }
+  }
+  if (!name) return;
+  ctx.definitions.push({
+    name,
+    kind: 'type',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+}
+
+function handleCInclude(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const pathNode = node.childForFieldName('path');
+  if (!pathNode) return;
+  // Strip quotes or angle brackets
+  const raw = pathNode.text;
+  const source = raw.replace(/^["<]|[">]$/g, '');
+  const lastName = source.split('/').pop() ?? source;
+  ctx.imports.push({
+    source,
+    names: [lastName],
+    line: node.startPosition.row + 1,
+    cInclude: true,
+  });
+}
+
+function handleCCallExpression(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const funcNode = node.childForFieldName('function');
+  if (!funcNode) return;
+  const call: Call = { name: '', line: node.startPosition.row + 1 };
+  if (funcNode.type === 'field_expression') {
+    const field = funcNode.childForFieldName('field');
+    const argument = funcNode.childForFieldName('argument');
+    if (field) call.name = field.text;
+    if (argument) call.receiver = argument.text;
+  } else {
+    call.name = funcNode.text;
+  }
+  if (call.name) ctx.calls.push(call);
+}
+
+// ── Child extraction helpers ────────────────────────────────────────────────
+
+function extractCParameters(paramListNode: TreeSitterNode | null): SubDeclaration[] {
+  const params: SubDeclaration[] = [];
+  if (!paramListNode) return params;
+  for (let i = 0; i < paramListNode.childCount; i++) {
+    const param = paramListNode.child(i);
+    if (!param || param.type !== 'parameter_declaration') continue;
+    const nameNode = param.childForFieldName('declarator');
+    if (nameNode) {
+      const name =
+        nameNode.type === 'identifier'
+          ? nameNode.text
+          : (findChild(nameNode, 'identifier')?.text ?? nameNode.text);
+      params.push({ name, kind: 'parameter', line: param.startPosition.row + 1 });
+    }
+  }
+  return params;
+}
+
+function extractStructFields(structNode: TreeSitterNode): SubDeclaration[] {
+  const fields: SubDeclaration[] = [];
+  const body = findChild(structNode, 'field_declaration_list');
+  if (!body) return fields;
+  for (let i = 0; i < body.childCount; i++) {
+    const member = body.child(i);
+    if (!member || member.type !== 'field_declaration') continue;
+    const nameNode = member.childForFieldName('declarator');
+    if (nameNode) {
+      const name =
+        nameNode.type === 'identifier'
+          ? nameNode.text
+          : (findChild(nameNode, 'identifier')?.text ?? nameNode.text);
+      fields.push({ name, kind: 'property', line: member.startPosition.row + 1 });
+    }
+  }
+  return fields;
+}
+
+function extractEnumEntries(enumNode: TreeSitterNode): SubDeclaration[] {
+  const entries: SubDeclaration[] = [];
+  const body = findChild(enumNode, 'enumerator_list');
+  if (!body) return entries;
+  for (let i = 0; i < body.childCount; i++) {
+    const member = body.child(i);
+    if (!member || member.type !== 'enumerator') continue;
+    const nameNode = member.childForFieldName('name');
+    if (nameNode) {
+      entries.push({ name: nameNode.text, kind: 'constant', line: member.startPosition.row + 1 });
+    }
+  }
+  return entries;
+}