@optave/codegraph 3.10.0 → 3.11.0

package/src/domain/graph/watcher.ts

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { closeDb, getNodeId as getNodeIdQuery, initSchema, openDb } from '../../db/index.js';
-import { debug, info } from '../../infrastructure/logger.js';
+import { debug, info, warn } from '../../infrastructure/logger.js';
 import { isSupportedFile, normalizePath, shouldIgnore } from '../../shared/constants.js';
 import { DbError } from '../../shared/errors.js';
 import { createParseTreeCache, getActiveEngine } from '../parser.js';
@@ -16,12 +16,13 @@ function shouldIgnorePath(filePath: string): boolean {
 
 /** Prepare all SQL statements needed by the watcher's incremental rebuild. */
 function prepareWatcherStatements(db: ReturnType<typeof openDb>): IncrementalStmts {
-  const stmts = {
+  return {
     insertNode: db.prepare(
       'INSERT OR IGNORE INTO nodes (name, kind, file, line, end_line) VALUES (?, ?, ?, ?, ?)',
     ),
     getNodeId: {
-      get: (name: string, kind: string, file: string, line: number) => {
+      get: (...params: unknown[]) => {
+        const [name, kind, file, line] = params as [string, string, string, number];
         const id = getNodeIdQuery(db, name, kind, file, line);
         return id != null ? { id } : undefined;
       },
@@ -29,10 +30,7 @@ function prepareWatcherStatements(db: ReturnType<typeof openDb>): IncrementalStm
     insertEdge: db.prepare(
       'INSERT INTO edges (source_id, target_id, kind, confidence, dynamic) VALUES (?, ?, ?, ?, ?)',
     ),
-    deleteNodes: db.prepare('DELETE FROM nodes WHERE file = ?'),
-    deleteEdgesForFile: null as { run: (f: string) => void } | null,
     countNodes: db.prepare('SELECT COUNT(*) as c FROM nodes WHERE file = ?'),
-    countEdgesForFile: null as { get: (f: string) => { c: number } | undefined } | null,
     findNodeInFile: db.prepare(
       "SELECT id, file FROM nodes WHERE name = ? AND kind IN ('function', 'method', 'class', 'interface', 'type', 'struct', 'enum', 'trait', 'record', 'module', 'constant') AND file = ?",
     ),
@@ -41,19 +39,6 @@ function prepareWatcherStatements(db: ReturnType<typeof openDb>): IncrementalStm
     ),
     listSymbols: db.prepare("SELECT name, kind, line FROM nodes WHERE file = ? AND kind != 'file'"),
   };
-
-  const origDeleteEdges = db.prepare(
-    `DELETE FROM edges WHERE source_id IN (SELECT id FROM nodes WHERE file = @f) OR target_id IN (SELECT id FROM nodes WHERE file = @f)`,
-  );
-  const origCountEdges = db.prepare(
-    `SELECT COUNT(*) as c FROM edges WHERE source_id IN (SELECT id FROM nodes WHERE file = @f) OR target_id IN (SELECT id FROM nodes WHERE file = @f)`,
-  );
-  stmts.deleteEdgesForFile = { run: (f: string) => origDeleteEdges.run({ f }) };
-  stmts.countEdgesForFile = {
-    get: (f: string) => origCountEdges.get({ f }) as { c: number } | undefined,
-  };
-
-  return stmts as IncrementalStmts;
 }
 
 /** Rebuild result shape from rebuildFile. */
@@ -80,10 +65,23 @@ async function processPendingFiles(
 ): Promise<void> {
   const results: RebuildResult[] = [];
   for (const filePath of files) {
-    const result = (await rebuildFile(db, rootDir, filePath, stmts, engineOpts, cache, {
-      diffSymbols: diffSymbols as (old: unknown[], new_: unknown[]) => unknown,
-    })) as RebuildResult | null;
-    if (result) results.push(result);
+    // Per-file try/catch so one bad rebuild doesn't crash the watcher loop.
+    // The watcher is a long-running session — any SQLite error, parse failure,
+    // or filesystem race must be reported and skipped, not propagated. Issue #1176.
+    try {
+      const result = (await rebuildFile(db, rootDir, filePath, stmts, engineOpts, cache, {
+        diffSymbols: diffSymbols as (old: unknown[], new_: unknown[]) => unknown,
+      })) as RebuildResult | null;
+      if (result) results.push(result);
+    } catch (err: unknown) {
+      const relPath = normalizePath(path.relative(rootDir, filePath));
+      // Narrow with `instanceof` instead of casting: a non-Error throw (a plain
+      // string, `null`, or any value a third-party dependency throws) would log
+      // `(err as Error).message` as `undefined`. See Greptile review on #1182.
+      const message = err instanceof Error ? err.message : String(err);
+      warn(`Failed to rebuild ${relPath}: ${message} — skipping`);
+      debug(err instanceof Error ? (err.stack ?? message) : String(err));
+    }
   }
 
   if (results.length > 0) {

package/src/domain/parser.ts

@@ -457,6 +457,8 @@ export const NATIVE_SUPPORTED_EXTENSIONS: ReadonlySet<string> = new Set([
   '.cc',
   '.cxx',
   '.hpp',
+  '.cu',
+  '.cuh',
   '.kt',
   '.kts',
   '.swift',
@@ -471,6 +473,23 @@ export const NATIVE_SUPPORTED_EXTENSIONS: ReadonlySet<string> = new Set([
   '.hs',
   '.ml',
   '.mli',
+  '.fs',
+  '.fsx',
+  '.fsi',
+  '.m',
+  '.gleam',
+  '.jl',
+  '.clj',
+  '.cljs',
+  '.cljc',
+  '.erl',
+  '.hrl',
+  '.groovy',
+  '.gvy',
+  '.r',
+  '.sol',
+  '.v',
+  '.sv',
 ]);
 
 /**
@@ -812,11 +831,18 @@ export const LANGUAGE_REGISTRY: LanguageRegistryEntry[] = [
   },
   {
     id: 'fsharp',
-    extensions: ['.fs', '.fsx', '.fsi'],
+    extensions: ['.fs', '.fsx'],
     grammarFile: 'tree-sitter-fsharp.wasm',
     extractor: extractFSharpSymbols,
     required: false,
   },
+  {
+    id: 'fsharp-signature',
+    extensions: ['.fsi'],
+    grammarFile: 'tree-sitter-fsharp_signature.wasm',
+    extractor: extractFSharpSymbols,
+    required: false,
+  },
   {
     id: 'gleam',
     extensions: ['.gleam'],

package/src/domain/search/models.ts

@@ -1,8 +1,40 @@
 import { execFileSync } from 'node:child_process';
+import { createRequire } from 'node:module';
+import path from 'node:path';
 import { createInterface } from 'node:readline';
 import { info } from '../../infrastructure/logger.js';
 import { ConfigError, EngineError } from '../../shared/errors.js';
 
+const _require = createRequire(import.meta.url);
+
+/**
+ * Resolve the directory where `npm install` should run so the installed
+ * package ends up reachable by `await import(pkg)` from inside this module.
+ *
+ * Without a `cwd`, `execFileSync('npm', ['install', ...])` operates on
+ * `process.cwd()` — when the user runs codegraph against a repo that is *not*
+ * the directory where codegraph itself is installed, npm installs into the
+ * wrong `node_modules`, the dynamic import still fails, and the user gets
+ * `ENGINE_UNAVAILABLE: ... installed but failed to load`.
+ *
+ * Pin cwd to the directory that contains @optave/codegraph's `node_modules`
+ * so the install lands where Node's resolution algorithm will find it.
+ *
+ * @internal Exported for unit tests; not part of the public barrel.
+ */
+export function resolveNpmInstallCwd(): string | undefined {
+  try {
+    const pkgJsonPath = _require.resolve('@optave/codegraph/package.json');
+    // pkgJsonPath = <host>/node_modules/@optave/codegraph/package.json
+    // dirname x4: package.json → codegraph → @optave → node_modules → <host>
+    return path.dirname(path.dirname(path.dirname(path.dirname(pkgJsonPath))));
+  } catch {
+    // Source-of-truth checkout (no @optave/codegraph in node_modules) — fall back
+    // to process.cwd() so legacy behavior survives in tests.
+    return undefined;
+  }
+}
+
 export interface ModelConfig {
   name: string;
   dim: number;
@@ -104,12 +136,14 @@ export function getModelConfig(modelKey?: string): ModelConfig {
  * @internal Not part of the public barrel.
  */
 export function promptInstall(packageName: string): Promise<boolean> {
+  const installCwd = resolveNpmInstallCwd();
   if (!process.stdin.isTTY) {
     info(`Installing ${packageName} (optional dependency for semantic search)…`);
     try {
       execFileSync(NPM_BIN, ['install', '--no-save', packageName], {
         stdio: 'inherit',
         timeout: 300_000,
+        cwd: installCwd,
       });
       return Promise.resolve(true);
     } catch (err) {
@@ -128,9 +162,10 @@ export function promptInstall(packageName: string): Promise<boolean> {
         rl.close();
         if (answer.trim().toLowerCase() !== 'y') return resolve(false);
         try {
-          execFileSync(NPM_BIN, ['install', packageName], {
+          execFileSync(NPM_BIN, ['install', '--no-save', packageName], {
             stdio: 'inherit',
             timeout: 300_000,
+            cwd: installCwd,
           });
           resolve(true);
         } catch (err) {

package/src/domain/wasm-worker-entry.ts

@@ -306,11 +306,18 @@ const LANGUAGE_REGISTRY: LanguageRegistryEntry[] = [
   },
   {
     id: 'fsharp',
-    extensions: ['.fs', '.fsx', '.fsi'],
+    extensions: ['.fs', '.fsx'],
     grammarFile: 'tree-sitter-fsharp.wasm',
     extractor: extractFSharpSymbols,
     required: false,
   },
+  {
+    id: 'fsharp-signature',
+    extensions: ['.fsi'],
+    grammarFile: 'tree-sitter-fsharp_signature.wasm',
+    extractor: extractFSharpSymbols,
+    required: false,
+  },
   {
     id: 'gleam',
     extensions: ['.gleam'],

package/src/extractors/c.ts

@@ -159,6 +159,31 @@ function handleCCallExpression(node: TreeSitterNode, ctx: ExtractorOutput): void
 
 // ── Child extraction helpers ────────────────────────────────────────────────
 
+const C_DECLARATOR_WRAPPERS = new Set([
+  'pointer_declarator',
+  'array_declarator',
+  'parenthesized_declarator',
+  'function_declarator',
+]);
+
+/**
+ * Drill through pointer/array/parenthesized/function declarator wrappers to
+ * recover the bare identifier. Mirrors `unwrap_declarator` in the native C
+ * extractor so both engines agree on the name for parameters such as
+ * `void process(int callback(int))` (function-type parameter → `callback`) or
+ * `int *func(int)` (pointer-returning function → `func`).
+ */
+function unwrapCDeclaratorName(node: TreeSitterNode): string {
+  let current: TreeSitterNode | null = node;
+  while (current && C_DECLARATOR_WRAPPERS.has(current.type)) {
+    current = current.childForFieldName('declarator');
+  }
+  if (current?.type === 'identifier' || current?.type === 'field_identifier') {
+    return current.text;
+  }
+  return current?.text ?? node.text;
+}
+
 function extractCParameters(paramListNode: TreeSitterNode | null): SubDeclaration[] {
   const params: SubDeclaration[] = [];
   if (!paramListNode) return params;
@@ -167,10 +192,7 @@ function extractCParameters(paramListNode: TreeSitterNode | null): SubDeclaratio
     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);
+      const name = unwrapCDeclaratorName(nameNode);
       params.push({ name, kind: 'parameter', line: param.startPosition.row + 1 });
     }
   }
@@ -186,10 +208,7 @@ function extractStructFields(structNode: TreeSitterNode): SubDeclaration[] {
     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);
+      const name = unwrapCDeclaratorName(nameNode);
       fields.push({ name, kind: 'property', line: member.startPosition.row + 1 });
     }
   }

package/src/extractors/cpp.ts

@@ -239,6 +239,54 @@ function findCppParentClass(node: TreeSitterNode): string | null {
   return null;
 }
 
+const CPP_DECLARATOR_WRAPPERS = new Set([
+  'pointer_declarator',
+  'reference_declarator',
+  'array_declarator',
+  'parenthesized_declarator',
+  'function_declarator',
+]);
+
+/**
+ * Drill through pointer/reference/array/parenthesized/function declarator
+ * wrappers to recover the bare identifier. Mirrors `unwrap_cpp_declarator` in
+ * the native C++ extractor. tree-sitter-cpp's `reference_declarator` does not
+ * expose a `declarator` field, so the loop falls back to scanning children
+ * for the next nested declarator or identifier.
+ */
+function unwrapCppDeclaratorName(node: TreeSitterNode): string {
+  let current: TreeSitterNode | null = node;
+  while (current && CPP_DECLARATOR_WRAPPERS.has(current.type)) {
+    const named = current.childForFieldName('declarator');
+    if (named) {
+      current = named;
+      continue;
+    }
+    const fallback = nextCppDeclaratorChild(current);
+    if (!fallback) break;
+    current = fallback;
+  }
+  if (current?.type === 'identifier' || current?.type === 'field_identifier') {
+    return current.text;
+  }
+  return current?.text ?? node.text;
+}
+
+function nextCppDeclaratorChild(node: TreeSitterNode): TreeSitterNode | null {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (
+      child.type === 'identifier' ||
+      child.type === 'field_identifier' ||
+      CPP_DECLARATOR_WRAPPERS.has(child.type)
+    ) {
+      return child;
+    }
+  }
+  return null;
+}
+
 function extractCppParameters(paramListNode: TreeSitterNode | null): SubDeclaration[] {
   const params: SubDeclaration[] = [];
   if (!paramListNode) return params;
@@ -247,10 +295,7 @@ function extractCppParameters(paramListNode: TreeSitterNode | null): SubDeclarat
     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);
+      const name = unwrapCppDeclaratorName(nameNode);
       params.push({ name, kind: 'parameter', line: param.startPosition.row + 1 });
     }
   }
@@ -267,10 +312,7 @@ function extractCppClassFields(classNode: TreeSitterNode): SubDeclaration[] {
     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);
+      const name = unwrapCppDeclaratorName(nameNode);
       fields.push({
         name,
         kind: 'property',

package/src/extractors/cuda.ts

@@ -265,10 +265,10 @@ function extractCudaParameters(paramListNode: TreeSitterNode | null): SubDeclara
     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);
+      // Reuse the field-name drill helper so function-type parameters like
+      // `void process(int callback(int))` yield the bare name `callback`
+      // instead of the raw declarator text, matching the native unwrap path.
+      const name = extractCudaFieldName(nameNode);
       params.push({ name, kind: 'parameter', line: param.startPosition.row + 1 });
     }
   }
@@ -284,22 +284,96 @@ function extractCudaClassFields(classNode: TreeSitterNode): SubDeclaration[] {
     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,
-        visibility: extractModifierVisibility(member),
-      });
-    }
+    if (!nameNode) continue;
+    // Skip method declarations — a `field_declaration` whose declarator
+    // (after unwrapping pointer/reference/array) is a `function_declarator`
+    // is a method signature in a header, not a data field. Native and WASM
+    // previously diverged on how to format these (native stripped the `*`
+    // from pointer-return types, WASM kept it), and both produced
+    // method-signature-shaped "property" entries that are not real fields.
+    if (isCudaMethodDeclarator(nameNode)) continue;
+    const name = extractCudaFieldName(nameNode);
+    fields.push({
+      name,
+      kind: 'property',
+      line: member.startPosition.row + 1,
+      visibility: extractModifierVisibility(member),
+    });
   }
   return fields;
 }
 
+const CUDA_DECLARATOR_WRAPPERS = new Set([
+  'pointer_declarator',
+  'reference_declarator',
+  'array_declarator',
+  'parenthesized_declarator',
+]);
+
+function isCudaMethodDeclarator(node: TreeSitterNode): boolean {
+  let current: TreeSitterNode | null = node;
+  while (current && CUDA_DECLARATOR_WRAPPERS.has(current.type)) {
+    current = current.childForFieldName('declarator');
+  }
+  if (current?.type !== 'function_declarator') return false;
+  // A `function_declarator` whose inner declarator is a `parenthesized_declarator`
+  // is a function-pointer (or function-reference) field — e.g. `void (*cb)(int)`
+  // parses as function_declarator > parenthesized_declarator > pointer_declarator >
+  // field_identifier. Those are real data fields, not method declarations.
+  const inner = current.childForFieldName('declarator');
+  return inner?.type !== 'parenthesized_declarator';
+}
+
+/**
+ * Resolve the identifier of a declarator by walking through any combination of
+ * pointer/reference/array/parenthesized wrappers and `function_declarator`
+ * nodes. Used by both class-field extraction (where `function_declarator`
+ * indicates a function-pointer field after method declarations have been
+ * filtered out) and parameter extraction (where `function_declarator` wraps a
+ * bare function-type parameter name like `callback` in
+ * `void process(int callback(int))`).
+ */
+function extractCudaFieldName(decl: TreeSitterNode): string {
+  let current: TreeSitterNode | null = decl;
+  while (current) {
+    if (current.type === 'identifier' || current.type === 'field_identifier') {
+      return current.text;
+    }
+    if (CUDA_DECLARATOR_WRAPPERS.has(current.type) || current.type === 'function_declarator') {
+      const next = innerCudaDeclarator(current);
+      if (!next) break;
+      current = next;
+      continue;
+    }
+    break;
+  }
+  return decl.text;
+}
+
+/**
+ * Find the inner declarator of a wrapper node. Most C++ declarator wrappers
+ * expose it via the `declarator` field, but some (e.g. `parenthesized_declarator`
+ * and `reference_declarator` in tree-sitter-cuda) have unnamed children — so
+ * fall back to scanning children for a declarator-shaped node.
+ */
+function innerCudaDeclarator(node: TreeSitterNode): TreeSitterNode | null {
+  const named = node.childForFieldName('declarator');
+  if (named) return named;
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (
+      child.type === 'identifier' ||
+      child.type === 'field_identifier' ||
+      child.type === 'function_declarator' ||
+      CUDA_DECLARATOR_WRAPPERS.has(child.type)
+    ) {
+      return child;
+    }
+  }
+  return null;
+}
+
 function extractCudaEnumEntries(enumNode: TreeSitterNode): SubDeclaration[] {
   const entries: SubDeclaration[] = [];
   const body = findChild(enumNode, 'enumerator_list');

package/src/extractors/elixir.ts

@@ -190,14 +190,86 @@ function extractElixirParams(defCallNode: TreeSitterNode): SubDeclaration[] {
     for (let j = 0; j < innerArgs.childCount; j++) {
       const param = innerArgs.child(j);
       if (!param) continue;
-      if (param.type === 'identifier') {
-        params.push({ name: param.text, kind: 'parameter', line: param.startPosition.row + 1 });
-      }
+      collectElixirParamIdentifiers(param, params);
     }
   }
   return params;
 }
 
+/**
+ * Recursively walk a parameter pattern and emit each bound identifier as a
+ * `parameter` child. Handles bare identifiers, default-value `a \\ default`,
+ * list-cons `[head | tail]`, list `[a, b, c]`, tuple `{x, y}`, and
+ * map / struct destructuring (`%{k: v}`, `%Foo{k: v}`).
+ */
+function collectElixirParamIdentifiers(node: TreeSitterNode, out: SubDeclaration[]): void {
+  switch (node.type) {
+    case 'identifier':
+      out.push({ name: node.text, kind: 'parameter', line: node.startPosition.row + 1 });
+      return;
+    case 'binary_operator': {
+      // `name \\ default` (default-value) binds the left operand only.
+      // `head | tail` (list-cons, appears inside a `list` pattern) binds both operands.
+      const op = node.child(1);
+      if (!op) return;
+      if (op.type === '\\\\') {
+        const left = node.child(0);
+        if (left) collectElixirParamIdentifiers(left, out);
+        return;
+      }
+      if (op.type === '|') {
+        const left = node.child(0);
+        const right = node.child(2);
+        if (left) collectElixirParamIdentifiers(left, out);
+        if (right) collectElixirParamIdentifiers(right, out);
+        return;
+      }
+      return;
+    }
+    case 'list':
+      // `[a, b, c]` or `[head | tail]` — walk children, skipping punctuation. The
+      // `|` cons case is handled by the `binary_operator` arm when we recurse.
+      for (let i = 0; i < node.childCount; i++) {
+        const c = node.child(i);
+        if (!c || c.type === '[' || c.type === ']' || c.type === ',') continue;
+        collectElixirParamIdentifiers(c, out);
+      }
+      return;
+    case 'tuple':
+      for (let i = 0; i < node.childCount; i++) {
+        const c = node.child(i);
+        if (!c || c.type === '{' || c.type === '}' || c.type === ',') continue;
+        collectElixirParamIdentifiers(c, out);
+      }
+      return;
+    case 'map':
+      // `%{k: v}` or `%Foo{k: v}` — walk map_content > keywords > pair and emit each
+      // pair's value side (the bound name). The struct alias (`Foo`) is a type, not a
+      // bound identifier, so the leading `struct` child is intentionally skipped.
+      for (let i = 0; i < node.childCount; i++) {
+        const c = node.child(i);
+        if (c && c.type === 'map_content') collectElixirMapBindings(c, out);
+      }
+      return;
+  }
+}
+
+function collectElixirMapBindings(content: TreeSitterNode, out: SubDeclaration[]): void {
+  for (let i = 0; i < content.childCount; i++) {
+    const kws = content.child(i);
+    if (!kws || kws.type !== 'keywords') continue;
+    for (let j = 0; j < kws.childCount; j++) {
+      const pair = kws.child(j);
+      if (!pair || pair.type !== 'pair') continue;
+      for (let k = 0; k < pair.childCount; k++) {
+        const part = pair.child(k);
+        if (!part || part.type === 'keyword') continue;
+        collectElixirParamIdentifiers(part, out);
+      }
+    }
+  }
+}
+
 function handleDefprotocol(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const args = findChild(node, 'arguments');
   if (!args) return;