@optave/codegraph 3.2.0 → 3.3.1

package/src/domain/parser.js

@@ -320,7 +320,7 @@ export const LANGUAGE_REGISTRY = [
   },
   {
     id: 'python',
-    extensions: ['.py'],
+    extensions: ['.py', '.pyi'],
     grammarFile: 'tree-sitter-python.wasm',
     extractor: extractPythonSymbols,
     required: false,
@@ -355,14 +355,14 @@ export const LANGUAGE_REGISTRY = [
   },
   {
     id: 'ruby',
-    extensions: ['.rb'],
+    extensions: ['.rb', '.rake', '.gemspec'],
     grammarFile: 'tree-sitter-ruby.wasm',
     extractor: extractRubySymbols,
     required: false,
   },
   {
     id: 'php',
-    extensions: ['.php'],
+    extensions: ['.php', '.phtml'],
     grammarFile: 'tree-sitter-php.wasm',
     extractor: extractPHPSymbols,
     required: false,
@@ -378,6 +378,42 @@ for (const entry of LANGUAGE_REGISTRY) {
 
 export const SUPPORTED_EXTENSIONS = new Set(_extToLang.keys());
 
+/**
+ * WASM-based typeMap backfill for older native binaries that don't emit typeMap.
+ * Uses tree-sitter AST extraction instead of regex to avoid false positives from
+ * matches inside comments and string literals.
+ * TODO: Remove once all published native binaries include typeMap extraction (>= 3.2.0)
+ */
+async function backfillTypeMap(filePath, source) {
+  let code = source;
+  if (!code) {
+    try {
+      code = fs.readFileSync(filePath, 'utf-8');
+    } catch {
+      return { typeMap: [], backfilled: false };
+    }
+  }
+  const parsers = await createParsers();
+  const extracted = wasmExtractSymbols(parsers, filePath, code);
+  try {
+    if (!extracted?.symbols?.typeMap) {
+      return { typeMap: [], backfilled: false };
+    }
+    const tm = extracted.symbols.typeMap;
+    return {
+      typeMap: tm instanceof Map ? tm : new Map(tm.map((e) => [e.name, e.typeName])),
+      backfilled: true,
+    };
+  } 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 {}
+    }
+  }
+}
+
 /**
  * WASM extraction helper: picks the right extractor based on file extension.
  */
@@ -414,7 +450,20 @@ export async function parseFileAuto(filePath, source, opts = {}) {
 
   if (native) {
     const result = native.parseFile(filePath, source, !!opts.dataflow, opts.ast !== false);
-    return result ? patchNativeResult(result) : null;
+    if (!result) return null;
+    const patched = patchNativeResult(result);
+    // Only backfill typeMap for TS/TSX — JS files have no type annotations,
+    // and the native engine already handles `new Expr()` patterns.
+    const TS_BACKFILL_EXTS = new Set(['.ts', '.tsx']);
+    if (
+      (!patched.typeMap || patched.typeMap.length === 0) &&
+      TS_BACKFILL_EXTS.has(path.extname(filePath))
+    ) {
+      const { typeMap, backfilled } = await backfillTypeMap(filePath, source);
+      patched.typeMap = typeMap;
+      if (backfilled) patched._typeMapBackfilled = true;
+    }
+    return patched;
   }
 
   // WASM path
@@ -442,10 +491,49 @@ export async function parseFilesAuto(filePaths, rootDir, opts = {}) {
       !!opts.dataflow,
       opts.ast !== false,
     );
+    const needsTypeMap = [];
     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, patchNativeResult(r));
+      result.set(relPath, patched);
+      if (!patched.typeMap || patched.typeMap.length === 0) {
+        needsTypeMap.push({ filePath: r.file, relPath });
+      }
+    }
+    // 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 TS_EXTS = new Set(['.ts', '.tsx']);
+      const tsFiles = needsTypeMap.filter(({ filePath }) => TS_EXTS.has(path.extname(filePath)));
+      if (tsFiles.length > 0) {
+        const parsers = await createParsers();
+        for (const { filePath, relPath } of tsFiles) {
+          let extracted;
+          try {
+            const code = fs.readFileSync(filePath, 'utf-8');
+            extracted = wasmExtractSymbols(parsers, filePath, code);
+            if (extracted?.symbols?.typeMap) {
+              const symbols = result.get(relPath);
+              symbols.typeMap =
+                extracted.symbols.typeMap instanceof Map
+                  ? extracted.symbols.typeMap
+                  : new Map(extracted.symbols.typeMap.map((e) => [e.name, e.typeName]));
+              symbols._typeMapBackfilled = true;
+            }
+          } catch {
+            /* skip — typeMap is a best-effort backfill */
+          } 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 {}
+            }
+          }
+        }
+      }
     }
     return result;
   }
@@ -519,7 +607,20 @@ export function createParseTreeCache() {
 export async function parseFileIncremental(cache, filePath, source, opts = {}) {
   if (cache) {
     const result = cache.parseFile(filePath, source);
-    return result ? patchNativeResult(result) : null;
+    if (!result) return null;
+    const patched = patchNativeResult(result);
+    // Only backfill typeMap for TS/TSX — JS files have no type annotations,
+    // and the native engine already handles `new Expr()` patterns.
+    const TS_BACKFILL_EXTS = new Set(['.ts', '.tsx']);
+    if (
+      (!patched.typeMap || patched.typeMap.length === 0) &&
+      TS_BACKFILL_EXTS.has(path.extname(filePath))
+    ) {
+      const { typeMap, backfilled } = await backfillTypeMap(filePath, source);
+      patched.typeMap = typeMap;
+      if (backfilled) patched._typeMapBackfilled = true;
+    }
+    return patched;
   }
   return parseFileAuto(filePath, source, opts);
 }

package/src/domain/queries.js

@@ -32,6 +32,7 @@ export {
   fnImpactData,
   impactAnalysisData,
 } from './analysis/impact.js';
+export { implementationsData, interfacesData } from './analysis/implementations.js';
 export {
   FALSE_POSITIVE_CALLER_THRESHOLD,
   FALSE_POSITIVE_NAMES,

package/src/domain/search/search/hybrid.js

@@ -1,4 +1,5 @@
 import { openReadonlyOrFail } from '../../../db/index.js';
+import { loadConfig } from '../../../infrastructure/config.js';
 import { hasFtsIndex } from '../stores/fts5.js';
 import { ftsSearchData } from './keyword.js';
 import { searchData } from './semantic.js';
@@ -9,9 +10,11 @@ import { searchData } from './semantic.js';
  * or null if no FTS5 index (caller should fall back to semantic-only).
  */
 export async function hybridSearchData(query, customDbPath, opts = {}) {
-  const limit = opts.limit || 15;
-  const k = opts.rrfK || 60;
-  const topK = (opts.limit || 15) * 5;
+  const config = opts.config || loadConfig();
+  const searchCfg = config.search || {};
+  const limit = opts.limit ?? searchCfg.topK ?? 15;
+  const k = opts.rrfK ?? searchCfg.rrfK ?? 60;
+  const topK = (opts.limit ?? searchCfg.topK ?? 15) * 5;
 
   // Split semicolons for multi-query support
   const queries =
@@ -49,7 +52,7 @@ export async function hybridSearchData(query, customDbPath, opts = {}) {
     const semData = await searchData(q, customDbPath, {
       ...opts,
       limit: topK,
-      minScore: opts.minScore || 0.2,
+      minScore: opts.minScore ?? 0.2,
     });
     if (semData?.results) {
       rankedLists.push(

package/src/domain/search/search/semantic.js

@@ -1,3 +1,4 @@
+import { loadConfig } from '../../../infrastructure/config.js';
 import { warn } from '../../../infrastructure/logger.js';
 import { normalizeSymbol } from '../../queries.js';
 import { embed } from '../models.js';
@@ -9,8 +10,10 @@ import { prepareSearch } from './prepare.js';
  * Returns { results: [{ name, kind, file, line, similarity }] } or null on failure.
  */
 export async function searchData(query, customDbPath, opts = {}) {
-  const limit = opts.limit || 15;
-  const minScore = opts.minScore || 0.2;
+  const config = opts.config || loadConfig();
+  const searchCfg = config.search || {};
+  const limit = opts.limit ?? searchCfg.topK ?? 15;
+  const minScore = opts.minScore ?? searchCfg.defaultMinScore ?? 0.2;
 
   const prepared = prepareSearch(customDbPath, opts);
   if (!prepared) return null;
@@ -56,9 +59,11 @@ export async function searchData(query, customDbPath, opts = {}) {
  * Returns { results: [{ name, kind, file, line, rrf, queryScores }] } or null on failure.
  */
 export async function multiSearchData(queries, customDbPath, opts = {}) {
-  const limit = opts.limit || 15;
-  const minScore = opts.minScore || 0.2;
-  const k = opts.rrfK || 60;
+  const config = opts.config || loadConfig();
+  const searchCfg = config.search || {};
+  const limit = opts.limit ?? searchCfg.topK ?? 15;
+  const minScore = opts.minScore ?? searchCfg.defaultMinScore ?? 0.2;
+  const k = opts.rrfK ?? searchCfg.rrfK ?? 60;
 
   const prepared = prepareSearch(customDbPath, opts);
   if (!prepared) return null;
@@ -68,7 +73,7 @@ export async function multiSearchData(queries, customDbPath, opts = {}) {
     const { vectors: queryVecs, dim } = await embed(queries, modelKey);
 
     // Warn about similar queries that may bias RRF results
-    const SIMILARITY_WARN_THRESHOLD = 0.85;
+    const SIMILARITY_WARN_THRESHOLD = searchCfg.similarityWarnThreshold ?? 0.85;
     for (let i = 0; i < queryVecs.length; i++) {
       for (let j = i + 1; j < queryVecs.length; j++) {
         const sim = cosineSim(queryVecs[i], queryVecs[j]);

package/src/extractors/csharp.js

@@ -10,9 +10,11 @@ export function extractCSharpSymbols(tree, _filePath) {
     imports: [],
     classes: [],
     exports: [],
+    typeMap: new Map(),
   };
 
   walkCSharpNode(tree.rootNode, ctx);
+  extractCSharpTypeMap(tree.rootNode, ctx);
   return ctx;
 }
 
@@ -308,6 +310,66 @@ function extractCSharpEnumMembers(enumNode) {
   return constants;
 }
 
+// ── Type map extraction ──────────────────────────────────────────────────────
+
+function extractCSharpTypeMap(node, ctx) {
+  extractCSharpTypeMapDepth(node, ctx, 0);
+}
+
+function extractCSharpTypeMapDepth(node, ctx, depth) {
+  if (depth >= 200) return;
+
+  // local_declaration_statement → variable_declaration → type + variable_declarator(s)
+  if (node.type === 'variable_declaration') {
+    const typeNode = node.childForFieldName('type') || node.child(0);
+    if (typeNode && typeNode.type !== 'var_keyword') {
+      const typeName = extractCSharpTypeName(typeNode);
+      if (typeName) {
+        for (let i = 0; i < node.childCount; i++) {
+          const child = node.child(i);
+          if (child && child.type === 'variable_declarator') {
+            const nameNode = child.childForFieldName('name') || child.child(0);
+            if (nameNode && nameNode.type === 'identifier') {
+              ctx.typeMap.set(nameNode.text, { type: typeName, confidence: 0.9 });
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // Method/constructor parameter: parameter node has type + name fields
+  if (node.type === 'parameter') {
+    const typeNode = node.childForFieldName('type');
+    const nameNode = node.childForFieldName('name');
+    if (typeNode && nameNode) {
+      const typeName = extractCSharpTypeName(typeNode);
+      if (typeName) ctx.typeMap.set(nameNode.text, { type: typeName, confidence: 0.9 });
+    }
+  }
+
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) extractCSharpTypeMapDepth(child, ctx, depth + 1);
+  }
+}
+
+function extractCSharpTypeName(typeNode) {
+  if (!typeNode) return null;
+  const t = typeNode.type;
+  if (t === 'identifier' || t === 'qualified_name') return typeNode.text;
+  if (t === 'predefined_type') return null; // skip int, string, etc
+  if (t === 'generic_name') {
+    const first = typeNode.child(0);
+    return first ? first.text : null;
+  }
+  if (t === 'nullable_type') {
+    const inner = typeNode.child(0);
+    return inner ? extractCSharpTypeName(inner) : null;
+  }
+  return null;
+}
+
 function extractCSharpBaseTypes(node, className, classes) {
   const baseList = node.childForFieldName('bases');
   if (!baseList) return;

package/src/extractors/go.js

@@ -10,9 +10,11 @@ export function extractGoSymbols(tree, _filePath) {
     imports: [],
     classes: [],
     exports: [],
+    typeMap: new Map(),
   };
 
   walkGoNode(tree.rootNode, ctx);
+  extractGoTypeMap(tree.rootNode, ctx);
   return ctx;
 }
 
@@ -200,6 +202,145 @@ function handleGoCallExpr(node, ctx) {
   }
 }
 
+// ── Type map extraction ─────────────────────────────────────────────────────
+
+function extractGoTypeMap(node, ctx) {
+  extractGoTypeMapDepth(node, ctx, 0);
+}
+
+function setIfHigher(typeMap, name, type, confidence) {
+  const existing = typeMap.get(name);
+  if (!existing || confidence > existing.confidence) {
+    typeMap.set(name, { type, confidence });
+  }
+}
+
+function extractGoTypeMapDepth(node, ctx, depth) {
+  if (depth >= 200) return;
+
+  // var x MyType = ... or var x, y MyType → var_declaration > var_spec (confidence 0.9)
+  if (node.type === 'var_spec') {
+    const typeNode = node.childForFieldName('type');
+    if (typeNode) {
+      const typeName = extractGoTypeName(typeNode);
+      if (typeName) {
+        for (let i = 0; i < node.childCount; i++) {
+          const child = node.child(i);
+          if (child && child.type === 'identifier') {
+            setIfHigher(ctx.typeMap, child.text, typeName, 0.9);
+          }
+        }
+      }
+    }
+  }
+
+  // Function/method parameter types: parameter_declaration (confidence 0.9)
+  if (node.type === 'parameter_declaration') {
+    const typeNode = node.childForFieldName('type');
+    if (typeNode) {
+      const typeName = extractGoTypeName(typeNode);
+      if (typeName) {
+        for (let i = 0; i < node.childCount; i++) {
+          const child = node.child(i);
+          if (child && child.type === 'identifier') {
+            setIfHigher(ctx.typeMap, child.text, typeName, 0.9);
+          }
+        }
+      }
+    }
+  }
+
+  // short_var_declaration: x := Struct{}, x := &Struct{}, x := NewFoo()
+  // Handles multi-variable forms: x, y := A{}, B{}
+  if (node.type === 'short_var_declaration') {
+    const left = node.childForFieldName('left');
+    const right = node.childForFieldName('right');
+    if (left && right) {
+      const lefts =
+        left.type === 'expression_list'
+          ? Array.from({ length: left.childCount }, (_, i) => left.child(i)).filter(
+              (c) => c?.type === 'identifier',
+            )
+          : left.type === 'identifier'
+            ? [left]
+            : [];
+      const rights =
+        right.type === 'expression_list'
+          ? Array.from({ length: right.childCount }, (_, i) => right.child(i)).filter(
+              (c) => c?.isNamed,
+            )
+          : [right];
+
+      for (let idx = 0; idx < lefts.length; idx++) {
+        const varNode = lefts[idx];
+        const rhs = rights[idx];
+        if (!varNode || !rhs) continue;
+
+        // x := Struct{...} — composite literal (confidence 1.0)
+        if (rhs.type === 'composite_literal') {
+          const typeNode = rhs.childForFieldName('type');
+          if (typeNode) {
+            const typeName = extractGoTypeName(typeNode);
+            if (typeName) setIfHigher(ctx.typeMap, varNode.text, typeName, 1.0);
+          }
+        }
+        // x := &Struct{...} — address-of composite literal (confidence 1.0)
+        if (rhs.type === 'unary_expression') {
+          const operand = rhs.childForFieldName('operand');
+          if (operand && operand.type === 'composite_literal') {
+            const typeNode = operand.childForFieldName('type');
+            if (typeNode) {
+              const typeName = extractGoTypeName(typeNode);
+              if (typeName) setIfHigher(ctx.typeMap, varNode.text, typeName, 1.0);
+            }
+          }
+        }
+        // x := NewFoo() or x := pkg.NewFoo() — factory function (confidence 0.7)
+        if (rhs.type === 'call_expression') {
+          const fn = rhs.childForFieldName('function');
+          if (fn && fn.type === 'selector_expression') {
+            const field = fn.childForFieldName('field');
+            if (field?.text.startsWith('New')) {
+              const typeName = field.text.slice(3);
+              if (typeName) setIfHigher(ctx.typeMap, varNode.text, typeName, 0.7);
+            }
+          } else if (fn && fn.type === 'identifier' && fn.text.startsWith('New')) {
+            const typeName = fn.text.slice(3);
+            if (typeName) setIfHigher(ctx.typeMap, varNode.text, typeName, 0.7);
+          }
+        }
+      }
+    }
+  }
+
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) extractGoTypeMapDepth(child, ctx, depth + 1);
+  }
+}
+
+function extractGoTypeName(typeNode) {
+  if (!typeNode) return null;
+  const t = typeNode.type;
+  if (t === 'type_identifier' || t === 'identifier') return typeNode.text;
+  if (t === 'qualified_type') return typeNode.text;
+  // pointer type: *MyType → MyType
+  if (t === 'pointer_type') {
+    for (let i = 0; i < typeNode.childCount; i++) {
+      const child = typeNode.child(i);
+      if (child && (child.type === 'type_identifier' || child.type === 'identifier')) {
+        return child.text;
+      }
+    }
+  }
+  // generic type: MyType[T] → MyType
+  if (t === 'generic_type') {
+    const first = typeNode.child(0);
+    return first ? first.text : null;
+  }
+  return null;
+}
+
 // ── Child extraction helpers ────────────────────────────────────────────────
 
 function extractGoParameters(paramListNode) {

package/src/extractors/java.js

@@ -10,6 +10,7 @@ export function extractJavaSymbols(tree, _filePath) {
     imports: [],
     classes: [],
     exports: [],
+    typeMap: new Map(),
   };
 
   walkJavaNode(tree.rootNode, ctx);
@@ -42,6 +43,9 @@ function walkJavaNode(node, ctx) {
     case 'object_creation_expression':
       handleJavaObjectCreation(node, ctx);
       break;
+    case 'local_variable_declaration':
+      handleJavaLocalVarDecl(node, ctx);
+      break;
   }
 
   for (let i = 0; i < node.childCount; i++) walkJavaNode(node.child(i), ctx);
@@ -166,7 +170,7 @@ function handleJavaMethodDecl(node, ctx) {
   if (!nameNode) return;
   const parentClass = findJavaParentClass(node);
   const fullName = parentClass ? `${parentClass}.${nameNode.text}` : nameNode.text;
-  const params = extractJavaParameters(node.childForFieldName('parameters'));
+  const params = extractJavaParameters(node.childForFieldName('parameters'), ctx.typeMap);
   ctx.definitions.push({
     name: fullName,
     kind: 'method',
@@ -182,7 +186,7 @@ function handleJavaConstructorDecl(node, ctx) {
   if (!nameNode) return;
   const parentClass = findJavaParentClass(node);
   const fullName = parentClass ? `${parentClass}.${nameNode.text}` : nameNode.text;
-  const params = extractJavaParameters(node.childForFieldName('parameters'));
+  const params = extractJavaParameters(node.childForFieldName('parameters'), ctx.typeMap);
   ctx.definitions.push({
     name: fullName,
     kind: 'method',
@@ -222,6 +226,20 @@ function handleJavaMethodInvocation(node, ctx) {
   ctx.calls.push(call);
 }
 
+function handleJavaLocalVarDecl(node, ctx) {
+  const typeNode = node.childForFieldName('type');
+  if (!typeNode) return;
+  const typeName = typeNode.type === 'generic_type' ? typeNode.child(0)?.text : typeNode.text;
+  if (!typeName) return;
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child?.type === 'variable_declarator') {
+      const nameNode = child.childForFieldName('name');
+      if (nameNode) ctx.typeMap.set(nameNode.text, { type: typeName, confidence: 0.9 });
+    }
+  }
+}
+
 function handleJavaObjectCreation(node, ctx) {
   const typeNode = node.childForFieldName('type');
   if (!typeNode) return;
@@ -247,7 +265,7 @@ function findJavaParentClass(node) {
 
 // ── Child extraction helpers ────────────────────────────────────────────────
 
-function extractJavaParameters(paramListNode) {
+function extractJavaParameters(paramListNode, typeMap) {
   const params = [];
   if (!paramListNode) return params;
   for (let i = 0; i < paramListNode.childCount; i++) {
@@ -257,6 +275,14 @@ function extractJavaParameters(paramListNode) {
       const nameNode = param.childForFieldName('name');
       if (nameNode) {
         params.push({ name: nameNode.text, kind: 'parameter', line: param.startPosition.row + 1 });
+        if (typeMap) {
+          const typeNode = param.childForFieldName('type');
+          if (typeNode) {
+            const typeName =
+              typeNode.type === 'generic_type' ? typeNode.child(0)?.text : typeNode.text;
+            if (typeName) typeMap.set(nameNode.text, { type: typeName, confidence: 0.9 });
+          }
+        }
       }
     }
   }