@optave/codegraph 3.7.0 → 3.8.1

package/src/domain/search/search/hybrid.ts

@@ -25,45 +25,51 @@ export interface HybridSearchResult {
   results: HybridResult[];
 }
 
-export async function hybridSearchData(
-  query: string,
-  customDbPath: string | undefined,
-  opts: SemanticSearchOpts = {},
-): Promise<HybridSearchResult | null> {
-  const config = opts.config || loadConfig();
-  const searchCfg = config.search || ({} as CodegraphConfig['search']);
-  const limit = opts.limit ?? searchCfg.topK ?? 15;
-  const k = opts.rrfK ?? searchCfg.rrfK ?? 60;
-  const topK = (opts.limit ?? searchCfg.topK ?? 15) * 5;
-
-  const queries =
-    typeof query === 'string'
-      ? query
-          .split(';')
-          .map((q) => q.trim())
-          .filter((q) => q.length > 0)
-      : [query];
+interface RankedItem {
+  key: string;
+  rank: number;
+  source: 'bm25' | 'semantic';
+  name: string;
+  kind: string;
+  file: string;
+  line: number;
+  endLine?: number | null;
+  role?: string | null;
+  fileHash?: string | null;
+  bm25Score?: number;
+  similarity?: number;
+}
 
-  const checkDb = openReadonlyOrFail(customDbPath) as BetterSqlite3Database;
-  const ftsAvailable = hasFtsIndex(checkDb);
-  checkDb.close();
-  if (!ftsAvailable) return null;
+interface FusionEntry {
+  name: string;
+  kind: string;
+  file: string;
+  line: number;
+  endLine: number | null;
+  role: string | null;
+  fileHash: string | null;
+  rrfScore: number;
+  bm25Score: number | null;
+  bm25Rank: number | null;
+  similarity: number | null;
+  semanticRank: number | null;
+}
 
-  interface RankedItem {
-    key: string;
-    rank: number;
-    source: 'bm25' | 'semantic';
-    name: string;
-    kind: string;
-    file: string;
-    line: number;
-    endLine?: number | null;
-    role?: string | null;
-    fileHash?: string | null;
-    bm25Score?: number;
-    similarity?: number;
-  }
+/** Parse a semicolon-delimited query string into individual queries. */
+function parseQueries(query: string): string[] {
+  return query
+    .split(';')
+    .map((q) => q.trim())
+    .filter((q) => q.length > 0);
+}
 
+/** Collect BM25 and semantic ranked lists for each query. */
+async function collectRankedLists(
+  queries: string[],
+  customDbPath: string | undefined,
+  opts: SemanticSearchOpts,
+  topK: number,
+): Promise<RankedItem[][]> {
   const rankedLists: RankedItem[][] = [];
 
   for (const q of queries) {
@@ -96,22 +102,13 @@ export async function hybridSearchData(
     }
   }
 
-  interface FusionEntry {
-    name: string;
-    kind: string;
-    file: string;
-    line: number;
-    endLine: number | null;
-    role: string | null;
-    fileHash: string | null;
-    rrfScore: number;
-    bm25Score: number | null;
-    bm25Rank: number | null;
-    similarity: number | null;
-    semanticRank: number | null;
-  }
+  return rankedLists;
+}
 
+/** Reciprocal Rank Fusion: merge ranked lists into a single scored result set. */
+function fuseResults(rankedLists: RankedItem[][], k: number, limit: number): HybridResult[] {
   const fusionMap = new Map<string, FusionEntry>();
+
   for (const list of rankedLists) {
     for (const item of list) {
       if (!fusionMap.has(item.key)) {
@@ -146,7 +143,7 @@ export async function hybridSearchData(
     }
   }
 
-  const results: HybridResult[] = [...fusionMap.values()]
+  return [...fusionMap.values()]
     .sort((a, b) => b.rrfScore - a.rrfScore)
     .slice(0, limit)
     .map((e) => ({
@@ -163,6 +160,27 @@ export async function hybridSearchData(
       similarity: e.similarity,
       semanticRank: e.semanticRank,
     }));
+}
+
+export async function hybridSearchData(
+  query: string,
+  customDbPath: string | undefined,
+  opts: SemanticSearchOpts = {},
+): Promise<HybridSearchResult | null> {
+  const config = opts.config || loadConfig();
+  const searchCfg = config.search || ({} as CodegraphConfig['search']);
+  const limit = opts.limit ?? searchCfg.topK ?? 15;
+  const k = opts.rrfK ?? searchCfg.rrfK ?? 60;
+  const topK = (opts.limit ?? searchCfg.topK ?? 15) * 5;
+
+  const checkDb = openReadonlyOrFail(customDbPath) as BetterSqlite3Database;
+  const ftsAvailable = hasFtsIndex(checkDb);
+  checkDb.close();
+  if (!ftsAvailable) return null;
+
+  const queries = parseQueries(query);
+  const rankedLists = await collectRankedLists(queries, customDbPath, opts, topK);
+  const results = fuseResults(rankedLists, k, limit);
 
   return { results };
 }

package/src/extractors/clojure.ts

@@ -0,0 +1,273 @@
+import type { ExtractorOutput, SubDeclaration, TreeSitterNode, TreeSitterTree } from '../types.js';
+import { nodeEndLine } from './helpers.js';
+
+/**
+ * Extract symbols from Clojure files.
+ *
+ * Clojure tree-sitter grammar (sogaiu/tree-sitter-clojure) notes:
+ * - The grammar is minimal: everything is a list/vector/map/symbol
+ * - We detect definitions by the first symbol in a list: defn, def, defprotocol, etc.
+ * - Namespace: (ns name ...)
+ * - Imports: (:require ...) inside ns, or (require ...)
+ */
+export function extractClojureSymbols(tree: TreeSitterTree, _filePath: string): ExtractorOutput {
+  const ctx: ExtractorOutput = {
+    definitions: [],
+    calls: [],
+    imports: [],
+    classes: [],
+    exports: [],
+    typeMap: new Map(),
+  };
+
+  walkClojureNode(tree.rootNode, ctx, null);
+  return ctx;
+}
+
+function walkClojureNode(
+  node: TreeSitterNode,
+  ctx: ExtractorOutput,
+  currentNs: string | null,
+): void {
+  let nextNs = currentNs;
+
+  if (node.type === 'list_lit') {
+    nextNs = handleListForm(node, ctx, currentNs) ?? currentNs;
+  }
+
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) walkClojureNode(child, ctx, nextNs);
+  }
+}
+
+/** Returns new namespace name if this is an `ns` form, otherwise null. */
+function handleListForm(
+  node: TreeSitterNode,
+  ctx: ExtractorOutput,
+  currentNs: string | null,
+): string | null {
+  const firstSym = findFirstSymbol(node);
+  if (!firstSym) return null;
+
+  const name = firstSym.text;
+
+  switch (name) {
+    case 'ns':
+      return handleNsForm(node, ctx);
+    case 'def':
+    case 'defonce':
+      handleDefForm(node, ctx, currentNs, 'variable');
+      return null;
+    case 'defn':
+    case 'defn-':
+      handleDefnForm(node, ctx, currentNs, name === 'defn-' ? 'private' : 'public');
+      return null;
+    case 'defmacro':
+      handleDefnForm(node, ctx, currentNs, 'public');
+      return null;
+    case 'defprotocol':
+      handleDefprotocol(node, ctx);
+      return null;
+    case 'defrecord':
+    case 'deftype':
+      handleDefrecord(node, ctx, name);
+      return null;
+    case 'defmulti':
+      handleDefForm(node, ctx, currentNs, 'function');
+      return null;
+    case 'defmethod':
+      handleDefnForm(node, ctx, currentNs, 'public');
+      return null;
+    case 'require':
+    case 'use':
+    case 'import':
+      handleImportForm(node, ctx, name);
+      return null;
+    default: {
+      // Regular function call
+      if (!name.startsWith(':') && !name.startsWith('(')) {
+        ctx.calls.push({ name, line: node.startPosition.row + 1 });
+      }
+      return null;
+    }
+  }
+}
+
+function findFirstSymbol(listNode: TreeSitterNode): TreeSitterNode | null {
+  for (let i = 0; i < listNode.childCount; i++) {
+    const child = listNode.child(i);
+    if (!child) continue;
+    // Skip delimiters and metadata
+    if ('()[]{}#'.includes(child.type) || child.type === 'meta_lit') continue;
+    if (child.type === 'sym_lit' || child.type === 'kwd_lit') return child;
+    break;
+  }
+  return null;
+}
+
+function findSecondSymbol(listNode: TreeSitterNode): TreeSitterNode | null {
+  let count = 0;
+  for (let i = 0; i < listNode.childCount; i++) {
+    const child = listNode.child(i);
+    if (!child) continue;
+    if ('()[]{}#'.includes(child.type) || child.type === 'meta_lit') continue;
+    if (child.type === 'sym_lit' || child.type === 'kwd_lit') {
+      count++;
+      if (count === 2) return child;
+    }
+  }
+  return null;
+}
+
+function handleNsForm(node: TreeSitterNode, ctx: ExtractorOutput): string | null {
+  const nameNode = findSecondSymbol(node);
+  if (!nameNode) return null;
+
+  const nsName = nameNode.text;
+  ctx.definitions.push({
+    name: nsName,
+    kind: 'module',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+
+  // Extract requires from ns form
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (child.type === 'list_lit') {
+      const kw = findFirstSymbol(child);
+      if (kw && (kw.text === ':require' || kw.text === ':import' || kw.text === ':use')) {
+        extractNsRequires(child, ctx);
+      }
+    }
+  }
+
+  return nsName;
+}
+
+function extractNsRequires(requireForm: TreeSitterNode, ctx: ExtractorOutput): void {
+  for (let i = 0; i < requireForm.childCount; i++) {
+    const child = requireForm.child(i);
+    if (!child) continue;
+    // Vector form: [some.ns :as alias]
+    if (child.type === 'vec_lit') {
+      const sym = findFirstSymbol(child);
+      if (sym) {
+        ctx.imports.push({
+          source: sym.text,
+          names: [sym.text.split('.').pop() || sym.text],
+          line: child.startPosition.row + 1,
+        });
+      }
+    }
+    // Symbol form: some.ns
+    if (child.type === 'sym_lit' && i > 0) {
+      const text = child.text;
+      if (!text.startsWith(':')) {
+        ctx.imports.push({
+          source: text,
+          names: [text.split('.').pop() || text],
+          line: child.startPosition.row + 1,
+        });
+      }
+    }
+  }
+}
+
+function handleDefForm(
+  node: TreeSitterNode,
+  ctx: ExtractorOutput,
+  currentNs: string | null,
+  kindOrFallback: 'variable' | 'function',
+): void {
+  const nameNode = findSecondSymbol(node);
+  if (!nameNode) return;
+
+  const rawName = nameNode.text;
+  const fullName = currentNs ? `${currentNs}/${rawName}` : rawName;
+
+  ctx.definitions.push({
+    name: fullName,
+    kind: kindOrFallback,
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+}
+
+function handleDefnForm(
+  node: TreeSitterNode,
+  ctx: ExtractorOutput,
+  currentNs: string | null,
+  visibility: 'public' | 'private',
+): void {
+  const nameNode = findSecondSymbol(node);
+  if (!nameNode) return;
+
+  const rawName = nameNode.text;
+  const fullName = currentNs ? `${currentNs}/${rawName}` : rawName;
+  const params = extractClojureParams(node);
+
+  ctx.definitions.push({
+    name: fullName,
+    kind: 'function',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+    visibility,
+    children: params.length > 0 ? params : undefined,
+  });
+}
+
+function extractClojureParams(defnNode: TreeSitterNode): SubDeclaration[] {
+  const params: SubDeclaration[] = [];
+  // Find the parameter vector [x y z]
+  for (let i = 0; i < defnNode.childCount; i++) {
+    const child = defnNode.child(i);
+    if (!child || child.type !== 'vec_lit') continue;
+    for (let j = 0; j < child.childCount; j++) {
+      const param = child.child(j);
+      if (!param) continue;
+      if (param.type === 'sym_lit') {
+        params.push({ name: param.text, kind: 'parameter', line: param.startPosition.row + 1 });
+      }
+    }
+    break; // Only first vector is params
+  }
+  return params;
+}
+
+function handleDefprotocol(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const nameNode = findSecondSymbol(node);
+  if (!nameNode) return;
+
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'interface',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+}
+
+function handleDefrecord(node: TreeSitterNode, ctx: ExtractorOutput, keyword: string): void {
+  const nameNode = findSecondSymbol(node);
+  if (!nameNode) return;
+
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: keyword === 'defrecord' ? 'record' : 'type',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+}
+
+function handleImportForm(node: TreeSitterNode, ctx: ExtractorOutput, keyword: string): void {
+  const nameNode = findSecondSymbol(node);
+  if (!nameNode) return;
+
+  ctx.imports.push({
+    source: nameNode.text,
+    names: [keyword],
+    line: node.startPosition.row + 1,
+  });
+}