@optave/codegraph 3.2.0 → 3.3.0

package/src/domain/graph/resolve.js

@@ -3,6 +3,306 @@ import path from 'node:path';
 import { loadNative } from '../../infrastructure/native.js';
 import { normalizePath } from '../../shared/constants.js';
 
+// ── package.json exports resolution ─────────────────────────────────
+
+/** Cache: packageDir → parsed exports field (or null) */
+const _exportsCache = new Map();
+
+/**
+ * Parse a bare specifier into { packageName, subpath }.
+ * Scoped: "@scope/pkg/sub" → { packageName: "@scope/pkg", subpath: "./sub" }
+ * Plain:  "pkg/sub"        → { packageName: "pkg", subpath: "./sub" }
+ * No sub: "pkg"            → { packageName: "pkg", subpath: "." }
+ */
+export function parseBareSpecifier(specifier) {
+  let packageName, rest;
+  if (specifier.startsWith('@')) {
+    const parts = specifier.split('/');
+    if (parts.length < 2) return null;
+    packageName = `${parts[0]}/${parts[1]}`;
+    rest = parts.slice(2).join('/');
+  } else {
+    const slashIdx = specifier.indexOf('/');
+    if (slashIdx === -1) {
+      packageName = specifier;
+      rest = '';
+    } else {
+      packageName = specifier.slice(0, slashIdx);
+      rest = specifier.slice(slashIdx + 1);
+    }
+  }
+  return { packageName, subpath: rest ? `./${rest}` : '.' };
+}
+
+/**
+ * Find the package directory for a given package name, starting from rootDir.
+ * Walks up node_modules directories.
+ */
+function findPackageDir(packageName, rootDir) {
+  let dir = rootDir;
+  while (true) {
+    const candidate = path.join(dir, 'node_modules', packageName);
+    if (fs.existsSync(path.join(candidate, 'package.json'))) return candidate;
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+
+/**
+ * Read and cache the exports field from a package's package.json.
+ * Returns the exports value or null.
+ */
+function getPackageExports(packageDir) {
+  if (_exportsCache.has(packageDir)) return _exportsCache.get(packageDir);
+  try {
+    const raw = fs.readFileSync(path.join(packageDir, 'package.json'), 'utf8');
+    const pkg = JSON.parse(raw);
+    const exports = pkg.exports ?? null;
+    _exportsCache.set(packageDir, exports);
+    return exports;
+  } catch {
+    _exportsCache.set(packageDir, null);
+    return null;
+  }
+}
+
+/** Condition names to try, in priority order. */
+const CONDITION_ORDER = ['import', 'require', 'default'];
+
+/**
+ * Resolve a conditional exports value (string, object with conditions, or array).
+ * Returns a string target or null.
+ */
+function resolveCondition(value) {
+  if (typeof value === 'string') return value;
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      const r = resolveCondition(item);
+      if (r) return r;
+    }
+    return null;
+  }
+  if (value && typeof value === 'object') {
+    for (const cond of CONDITION_ORDER) {
+      if (cond in value) return resolveCondition(value[cond]);
+    }
+    return null;
+  }
+  return null;
+}
+
+/**
+ * Match a subpath against an exports map key that uses a wildcard pattern.
+ * Key: "./lib/*" matches subpath "./lib/foo/bar" → substitution "foo/bar"
+ */
+function matchSubpathPattern(pattern, subpath) {
+  const starIdx = pattern.indexOf('*');
+  if (starIdx === -1) return null;
+  const prefix = pattern.slice(0, starIdx);
+  const suffix = pattern.slice(starIdx + 1);
+  if (!subpath.startsWith(prefix)) return null;
+  if (suffix && !subpath.endsWith(suffix)) return null;
+  const matched = subpath.slice(prefix.length, suffix ? -suffix.length || undefined : undefined);
+  if (!suffix && subpath.length <= prefix.length) return null;
+  return matched;
+}
+
+/**
+ * Resolve a bare specifier through the package.json exports field.
+ * Returns an absolute path or null.
+ */
+export function resolveViaExports(specifier, rootDir) {
+  const parsed = parseBareSpecifier(specifier);
+  if (!parsed) return null;
+
+  const packageDir = findPackageDir(parsed.packageName, rootDir);
+  if (!packageDir) return null;
+
+  const exports = getPackageExports(packageDir);
+  if (exports == null) return null;
+
+  const { subpath } = parsed;
+
+  // Simple string exports: "exports": "./index.js"
+  if (typeof exports === 'string') {
+    if (subpath === '.') {
+      const resolved = path.resolve(packageDir, exports);
+      return fs.existsSync(resolved) ? resolved : null;
+    }
+    return null;
+  }
+
+  // Array form at top level
+  if (Array.isArray(exports)) {
+    if (subpath === '.') {
+      const target = resolveCondition(exports);
+      if (target) {
+        const resolved = path.resolve(packageDir, target);
+        return fs.existsSync(resolved) ? resolved : null;
+      }
+    }
+    return null;
+  }
+
+  if (typeof exports !== 'object') return null;
+
+  // Determine if exports is a conditions object (no keys start with ".")
+  // or a subpath map (keys start with ".")
+  const keys = Object.keys(exports);
+  const isSubpathMap = keys.length > 0 && keys.some((k) => k.startsWith('.'));
+
+  if (!isSubpathMap) {
+    // Conditions object at top level → applies to "." subpath only
+    if (subpath === '.') {
+      const target = resolveCondition(exports);
+      if (target) {
+        const resolved = path.resolve(packageDir, target);
+        return fs.existsSync(resolved) ? resolved : null;
+      }
+    }
+    return null;
+  }
+
+  // Subpath map: try exact match first, then pattern match
+  if (subpath in exports) {
+    const target = resolveCondition(exports[subpath]);
+    if (target) {
+      const resolved = path.resolve(packageDir, target);
+      return fs.existsSync(resolved) ? resolved : null;
+    }
+  }
+
+  // Pattern matching (keys with *)
+  for (const [pattern, value] of Object.entries(exports)) {
+    if (!pattern.includes('*')) continue;
+    const matched = matchSubpathPattern(pattern, subpath);
+    if (matched == null) continue;
+    const rawTarget = resolveCondition(value);
+    if (!rawTarget) continue;
+    const target = rawTarget.replace(/\*/g, matched);
+    const resolved = path.resolve(packageDir, target);
+    if (fs.existsSync(resolved)) return resolved;
+  }
+
+  return null;
+}
+
+/** Clear the exports cache (for testing). */
+export function clearExportsCache() {
+  _exportsCache.clear();
+}
+
+// ── Monorepo workspace resolution ───────────────────────────────────
+
+/** Cache: rootDir → Map<packageName, { dir, entry }> */
+const _workspaceCache = new Map();
+
+/** Set of resolved relative paths that came from workspace resolution. */
+const _workspaceResolvedPaths = new Set();
+
+/**
+ * Set the workspace map for a given rootDir.
+ * Called by the build pipeline after detecting workspaces.
+ * @param {string} rootDir
+ * @param {Map<string, { dir: string, entry: string|null }>} map
+ */
+export function setWorkspaces(rootDir, map) {
+  _workspaceCache.set(rootDir, map);
+  _workspaceResolvedPaths.clear();
+  _exportsCache.clear();
+}
+
+/**
+ * Get workspace packages for a rootDir. Returns empty map if not set.
+ */
+function getWorkspaces(rootDir) {
+  return _workspaceCache.get(rootDir) || new Map();
+}
+
+/**
+ * Resolve a bare specifier through monorepo workspace packages.
+ *
+ * For "@myorg/utils" → finds the workspace package dir → resolves entry point.
+ * For "@myorg/utils/sub" → finds package dir → tries exports field → filesystem probe.
+ *
+ * @returns {string|null} Absolute path to resolved file, or null.
+ */
+export function resolveViaWorkspace(specifier, rootDir) {
+  const parsed = parseBareSpecifier(specifier);
+  if (!parsed) return null;
+
+  const workspaces = getWorkspaces(rootDir);
+  if (workspaces.size === 0) return null;
+
+  const info = workspaces.get(parsed.packageName);
+  if (!info) return null;
+
+  // Root import ("@myorg/utils") — use the entry point
+  if (parsed.subpath === '.') {
+    // Try exports field first (reuses existing exports logic)
+    const exportsResult = resolveViaExports(specifier, rootDir);
+    if (exportsResult) return exportsResult;
+    // Fall back to workspace entry
+    return info.entry;
+  }
+
+  // Subpath import ("@myorg/utils/helpers") — try exports, then filesystem probe
+  const exportsResult = resolveViaExports(specifier, rootDir);
+  if (exportsResult) return exportsResult;
+
+  // Filesystem probe within the package directory
+  const subRel = parsed.subpath.slice(2); // strip "./"
+  const base = path.resolve(info.dir, subRel);
+  for (const ext of [
+    '',
+    '.ts',
+    '.tsx',
+    '.js',
+    '.jsx',
+    '.mjs',
+    '/index.ts',
+    '/index.tsx',
+    '/index.js',
+  ]) {
+    const candidate = base + ext;
+    if (fs.existsSync(candidate)) return candidate;
+  }
+
+  // Try src/ subdirectory (common monorepo convention)
+  const srcBase = path.resolve(info.dir, 'src', subRel);
+  for (const ext of [
+    '',
+    '.ts',
+    '.tsx',
+    '.js',
+    '.jsx',
+    '.mjs',
+    '/index.ts',
+    '/index.tsx',
+    '/index.js',
+  ]) {
+    const candidate = srcBase + ext;
+    if (fs.existsSync(candidate)) return candidate;
+  }
+
+  return null;
+}
+
+/**
+ * Check if a resolved relative path was resolved via workspace detection.
+ * Used by computeConfidence to assign high confidence (0.95) to workspace imports.
+ */
+export function isWorkspaceResolved(resolvedPath) {
+  return _workspaceResolvedPaths.has(resolvedPath);
+}
+
+/** Clear workspace caches (for testing). */
+export function clearWorkspaceCache() {
+  _workspaceCache.clear();
+  _workspaceResolvedPaths.clear();
+}
+
 // ── Alias format conversion ─────────────────────────────────────────
 
 /**
@@ -60,7 +360,18 @@ function resolveImportPathJS(fromFile, importSource, rootDir, aliases) {
     const aliasResolved = resolveViaAlias(importSource, aliases, rootDir);
     if (aliasResolved) return normalizePath(path.relative(rootDir, aliasResolved));
   }
-  if (!importSource.startsWith('.')) return importSource;
+  if (!importSource.startsWith('.')) {
+    // Workspace packages take priority over node_modules
+    const wsResolved = resolveViaWorkspace(importSource, rootDir);
+    if (wsResolved) {
+      const rel = normalizePath(path.relative(rootDir, wsResolved));
+      _workspaceResolvedPaths.add(rel);
+      return rel;
+    }
+    const exportsResolved = resolveViaExports(importSource, rootDir);
+    if (exportsResolved) return normalizePath(path.relative(rootDir, exportsResolved));
+    return importSource;
+  }
   const dir = path.dirname(fromFile);
   const resolved = path.resolve(dir, importSource);
 
@@ -78,6 +389,7 @@ function resolveImportPathJS(fromFile, importSource, rootDir, aliases) {
     '.jsx',
     '.mjs',
     '.py',
+    '.pyi',
     '/index.ts',
     '/index.tsx',
     '/index.js',
@@ -96,6 +408,8 @@ function computeConfidenceJS(callerFile, targetFile, importedFrom) {
   if (!targetFile || !callerFile) return 0.3;
   if (callerFile === targetFile) return 1.0;
   if (importedFrom === targetFile) return 1.0;
+  // Workspace-resolved imports get high confidence even across package boundaries
+  if (importedFrom && _workspaceResolvedPaths.has(importedFrom)) return 0.95;
   if (path.dirname(callerFile) === path.dirname(targetFile)) return 0.7;
   const callerParent = path.dirname(path.dirname(callerFile));
   const targetParent = path.dirname(path.dirname(targetFile));

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,31 @@ 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);
+  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,
+  };
+}
+
 /**
  * WASM extraction helper: picks the right extractor based on file extension.
  */
@@ -414,7 +439,14 @@ 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);
+    if (!patched.typeMap || patched.typeMap.length === 0) {
+      const { typeMap, backfilled } = await backfillTypeMap(filePath, source);
+      patched.typeMap = typeMap;
+      if (backfilled) patched._typeMapBackfilled = true;
+    }
+    return patched;
   }
 
   // WASM path
@@ -442,10 +474,35 @@ 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) {
+      const parsers = await createParsers();
+      for (const { filePath, relPath } of needsTypeMap) {
+        try {
+          const code = fs.readFileSync(filePath, 'utf-8');
+          const 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 */
+        }
+      }
     }
     return result;
   }
@@ -519,7 +576,14 @@ 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);
+    if (!patched.typeMap || patched.typeMap.length === 0) {
+      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;