@optave/codegraph 3.3.1 → 3.4.1

package/src/domain/graph/{resolve.js → resolve.ts}

@@ -1,12 +1,15 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { debug } from '../../infrastructure/logger.js';
 import { loadNative } from '../../infrastructure/native.js';
 import { normalizePath } from '../../shared/constants.js';
+import { toErrorMessage } from '../../shared/errors.js';
+import type { BareSpecifier, BatchResolvedMap, ImportBatchItem, PathAliases } from '../../types.js';
 
 // ── package.json exports resolution ─────────────────────────────────
 
 /** Cache: packageDir → parsed exports field (or null) */
-const _exportsCache = new Map();
+const _exportsCache: Map<string, any> = new Map();
 
 /**
  * Parse a bare specifier into { packageName, subpath }.
@@ -14,8 +17,8 @@ const _exportsCache = new Map();
  * Plain:  "pkg/sub"        → { packageName: "pkg", subpath: "./sub" }
  * No sub: "pkg"            → { packageName: "pkg", subpath: "." }
  */
-export function parseBareSpecifier(specifier) {
-  let packageName, rest;
+export function parseBareSpecifier(specifier: string): BareSpecifier | null {
+  let packageName: string, rest: string;
   if (specifier.startsWith('@')) {
     const parts = specifier.split('/');
     if (parts.length < 2) return null;
@@ -38,7 +41,7 @@ export function parseBareSpecifier(specifier) {
  * Find the package directory for a given package name, starting from rootDir.
  * Walks up node_modules directories.
  */
-function findPackageDir(packageName, rootDir) {
+function findPackageDir(packageName: string, rootDir: string): string | null {
   let dir = rootDir;
   while (true) {
     const candidate = path.join(dir, 'node_modules', packageName);
@@ -53,7 +56,7 @@ function findPackageDir(packageName, rootDir) {
  * Read and cache the exports field from a package's package.json.
  * Returns the exports value or null.
  */
-function getPackageExports(packageDir) {
+function getPackageExports(packageDir: string): any {
   if (_exportsCache.has(packageDir)) return _exportsCache.get(packageDir);
   try {
     const raw = fs.readFileSync(path.join(packageDir, 'package.json'), 'utf8');
@@ -61,20 +64,21 @@ function getPackageExports(packageDir) {
     const exports = pkg.exports ?? null;
     _exportsCache.set(packageDir, exports);
     return exports;
-  } catch {
+  } catch (e) {
+    debug(`readPackageExports: failed to read package.json in ${packageDir}: ${toErrorMessage(e)}`);
     _exportsCache.set(packageDir, null);
     return null;
   }
 }
 
 /** Condition names to try, in priority order. */
-const CONDITION_ORDER = ['import', 'require', 'default'];
+const CONDITION_ORDER: readonly string[] = ['import', 'require', 'default'];
 
 /**
  * Resolve a conditional exports value (string, object with conditions, or array).
  * Returns a string target or null.
  */
-function resolveCondition(value) {
+function resolveCondition(value: unknown): string | null {
   if (typeof value === 'string') return value;
   if (Array.isArray(value)) {
     for (const item of value) {
@@ -85,7 +89,8 @@ function resolveCondition(value) {
   }
   if (value && typeof value === 'object') {
     for (const cond of CONDITION_ORDER) {
-      if (cond in value) return resolveCondition(value[cond]);
+      if (cond in (value as Record<string, unknown>))
+        return resolveCondition((value as Record<string, unknown>)[cond]);
     }
     return null;
   }
@@ -96,7 +101,7 @@ function resolveCondition(value) {
  * 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) {
+function matchSubpathPattern(pattern: string, subpath: string): string | null {
   const starIdx = pattern.indexOf('*');
   if (starIdx === -1) return null;
   const prefix = pattern.slice(0, starIdx);
@@ -112,7 +117,7 @@ function matchSubpathPattern(pattern, subpath) {
  * Resolve a bare specifier through the package.json exports field.
  * Returns an absolute path or null.
  */
-export function resolveViaExports(specifier, rootDir) {
+export function resolveViaExports(specifier: string, rootDir: string): string | null {
   const parsed = parseBareSpecifier(specifier);
   if (!parsed) return null;
 
@@ -189,25 +194,26 @@ export function resolveViaExports(specifier, rootDir) {
 }
 
 /** Clear the exports cache (for testing). */
-export function clearExportsCache() {
+export function clearExportsCache(): void {
   _exportsCache.clear();
 }
 
 // ── Monorepo workspace resolution ───────────────────────────────────
 
 /** Cache: rootDir → Map<packageName, { dir, entry }> */
-const _workspaceCache = new Map();
+const _workspaceCache: Map<string, Map<string, { dir: string; entry: string | null }>> = new Map();
 
 /** Set of resolved relative paths that came from workspace resolution. */
-const _workspaceResolvedPaths = new Set();
+const _workspaceResolvedPaths: Set<string> = 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) {
+export function setWorkspaces(
+  rootDir: string,
+  map: Map<string, { dir: string; entry: string | null }>,
+): void {
   _workspaceCache.set(rootDir, map);
   _workspaceResolvedPaths.clear();
   _exportsCache.clear();
@@ -216,7 +222,7 @@ export function setWorkspaces(rootDir, map) {
 /**
  * Get workspace packages for a rootDir. Returns empty map if not set.
  */
-function getWorkspaces(rootDir) {
+function getWorkspaces(rootDir: string): Map<string, { dir: string; entry: string | null }> {
   return _workspaceCache.get(rootDir) || new Map();
 }
 
@@ -226,9 +232,9 @@ function getWorkspaces(rootDir) {
  * 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.
+ * @returns Absolute path to resolved file, or null.
  */
-export function resolveViaWorkspace(specifier, rootDir) {
+export function resolveViaWorkspace(specifier: string, rootDir: string): string | null {
   const parsed = parseBareSpecifier(specifier);
   if (!parsed) return null;
 
@@ -293,23 +299,77 @@ export function resolveViaWorkspace(specifier, rootDir) {
  * 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) {
+export function isWorkspaceResolved(resolvedPath: string): boolean {
   return _workspaceResolvedPaths.has(resolvedPath);
 }
 
 /** Clear workspace caches (for testing). */
-export function clearWorkspaceCache() {
+export function clearWorkspaceCache(): void {
   _workspaceCache.clear();
   _workspaceResolvedPaths.clear();
 }
 
+// ── JS → TS extension remap cache ───────────────────────────────────
+
+/** Cache: absolute .js path → remapped .ts/.tsx relative path (or null if no TS file exists). */
+const _jsToTsCache: Map<string, string | null> = new Map();
+
+/**
+ * If `resolved` ends with `.js`, check whether a `.ts` or `.tsx` counterpart
+ * exists on disk and return its relative path from `rootDir`.  Results are
+ * cached for the lifetime of the process to avoid repeated stat calls in the
+ * batch hot path.
+ *
+ * The cache stores **absolute** `.ts`/`.tsx` paths (or `null`) so that the
+ * same cached entry is correct regardless of which `rootDir` is passed — the
+ * relative path is computed on every cache hit.  This is important for MCP
+ * `--multi-repo` mode where the same absolute `.js` file may be resolved with
+ * different `rootDir` values.
+ *
+ * Always returns a normalised relative path from `rootDir` — both the remap
+ * branch and the fallback compute `path.relative(rootDir, abs)` to ensure a
+ * consistent format regardless of whether the native resolver returned an
+ * absolute or relative path.
+ */
+function remapJsToTs(resolved: string, rootDir: string): string {
+  if (!resolved.endsWith('.js')) return resolved;
+  const abs = path.resolve(rootDir, resolved);
+  if (_jsToTsCache.has(abs)) {
+    const cachedAbs = _jsToTsCache.get(abs);
+    return cachedAbs
+      ? normalizePath(path.relative(rootDir, cachedAbs))
+      : normalizePath(path.relative(rootDir, abs));
+  }
+  const tsAbs = abs.replace(/\.js$/, '.ts');
+  if (fs.existsSync(tsAbs)) {
+    _jsToTsCache.set(abs, tsAbs);
+    return normalizePath(path.relative(rootDir, tsAbs));
+  }
+  const tsxAbs = abs.replace(/\.js$/, '.tsx');
+  if (fs.existsSync(tsxAbs)) {
+    _jsToTsCache.set(abs, tsxAbs);
+    return normalizePath(path.relative(rootDir, tsxAbs));
+  }
+  _jsToTsCache.set(abs, null);
+  // Normalise fallback to relative to stay consistent with the remap branch —
+  // avoids a format mismatch if the native resolver ever returns an absolute path.
+  return normalizePath(path.relative(rootDir, abs));
+}
+
+/** Clear the .js → .ts remap cache (for testing). */
+export function clearJsToTsCache(): void {
+  _jsToTsCache.clear();
+}
+
 // ── Alias format conversion ─────────────────────────────────────────
 
 /**
  * Convert JS alias format { baseUrl, paths: { pattern: [targets] } }
  * to native format { baseUrl, paths: [{ pattern, targets }] }.
  */
-export function convertAliasesForNative(aliases) {
+export function convertAliasesForNative(
+  aliases: PathAliases | null | undefined,
+): { baseUrl: string; paths: { pattern: string; targets: string[] }[] } | null {
   if (!aliases) return null;
   return {
     baseUrl: aliases.baseUrl || '',
@@ -322,7 +382,11 @@ export function convertAliasesForNative(aliases) {
 
 // ── JS fallback implementations ─────────────────────────────────────
 
-function resolveViaAlias(importSource, aliases, _rootDir) {
+function resolveViaAlias(
+  importSource: string,
+  aliases: PathAliases,
+  _rootDir: string,
+): string | null {
   if (aliases.baseUrl && !importSource.startsWith('.') && !importSource.startsWith('/')) {
     const candidate = path.resolve(aliases.baseUrl, importSource);
     for (const ext of ['', '.ts', '.tsx', '.js', '.jsx', '/index.ts', '/index.tsx', '/index.js']) {
@@ -355,7 +419,12 @@ function resolveViaAlias(importSource, aliases, _rootDir) {
   return null;
 }
 
-function resolveImportPathJS(fromFile, importSource, rootDir, aliases) {
+function resolveImportPathJS(
+  fromFile: string,
+  importSource: string,
+  rootDir: string,
+  aliases: PathAliases | null,
+): string {
   if (!importSource.startsWith('.') && aliases) {
     const aliasResolved = resolveViaAlias(importSource, aliases, rootDir);
     if (aliasResolved) return normalizePath(path.relative(rootDir, aliasResolved));
@@ -404,7 +473,11 @@ function resolveImportPathJS(fromFile, importSource, rootDir, aliases) {
   return normalizePath(path.relative(rootDir, resolved));
 }
 
-function computeConfidenceJS(callerFile, targetFile, importedFrom) {
+function computeConfidenceJS(
+  callerFile: string,
+  targetFile: string,
+  importedFrom: string | null,
+): number {
   if (!targetFile || !callerFile) return 0.3;
   if (callerFile === targetFile) return 1.0;
   if (importedFrom === targetFile) return 1.0;
@@ -423,7 +496,12 @@ function computeConfidenceJS(callerFile, targetFile, importedFrom) {
  * Resolve a single import path.
  * Tries native, falls back to JS.
  */
-export function resolveImportPath(fromFile, importSource, rootDir, aliases) {
+export function resolveImportPath(
+  fromFile: string,
+  importSource: string,
+  rootDir: string,
+  aliases: PathAliases | null,
+): string {
   const native = loadNative();
   if (native) {
     try {
@@ -433,9 +511,15 @@ export function resolveImportPath(fromFile, importSource, rootDir, aliases) {
         rootDir,
         convertAliasesForNative(aliases),
       );
-      return normalizePath(path.normalize(result));
-    } catch {
-      // fall through to JS
+      const normalized = normalizePath(path.normalize(result));
+      // The native resolver's .js → .ts remap fails when paths contain
+      // unresolved ".." components (PathBuf::components().collect() doesn't
+      // collapse parent refs). Apply the remap on the JS side as a fallback.
+      return remapJsToTs(normalized, rootDir);
+    } catch (e) {
+      debug(
+        `resolveImportPath: native resolution failed, falling back to JS: ${toErrorMessage(e)}`,
+      );
     }
   }
   return resolveImportPathJS(fromFile, importSource, rootDir, aliases);
@@ -445,13 +529,19 @@ export function resolveImportPath(fromFile, importSource, rootDir, aliases) {
  * Compute proximity-based confidence for call resolution.
  * Tries native, falls back to JS.
  */
-export function computeConfidence(callerFile, targetFile, importedFrom) {
+export function computeConfidence(
+  callerFile: string,
+  targetFile: string,
+  importedFrom: string | null,
+): number {
   const native = loadNative();
   if (native) {
     try {
       return native.computeConfidence(callerFile, targetFile, importedFrom || null);
-    } catch {
-      // fall through to JS
+    } catch (e) {
+      debug(
+        `computeConfidence: native computation failed, falling back to JS: ${toErrorMessage(e)}`,
+      );
     }
   }
   return computeConfidenceJS(callerFile, targetFile, importedFrom);
@@ -460,12 +550,13 @@ export function computeConfidence(callerFile, targetFile, importedFrom) {
 /**
  * Batch resolve multiple imports in a single native call.
  * Returns Map<"fromFile|importSource", resolvedPath> or null when native unavailable.
- * @param {Array} inputs - Array of { fromFile, importSource }
- * @param {string} rootDir - Project root
- * @param {object} aliases - Path aliases
- * @param {string[]} [knownFiles] - Optional file paths for FS cache (avoids syscalls)
  */
-export function resolveImportsBatch(inputs, rootDir, aliases, knownFiles) {
+export function resolveImportsBatch(
+  inputs: ImportBatchItem[],
+  rootDir: string,
+  aliases: PathAliases | null,
+  knownFiles?: string[] | null,
+): BatchResolvedMap | null {
   const native = loadNative();
   if (!native) return null;
 
@@ -480,12 +571,17 @@ export function resolveImportsBatch(inputs, rootDir, aliases, knownFiles) {
       convertAliasesForNative(aliases),
       knownFiles || null,
     );
-    const map = new Map();
+    const map: BatchResolvedMap = new Map();
     for (const r of results) {
-      map.set(`${r.fromFile}|${r.importSource}`, normalizePath(path.normalize(r.resolvedPath)));
+      const normalized = normalizePath(path.normalize(r.resolvedPath));
+      // Native resolver's .js → .ts remap fails on unnormalized paths —
+      // apply JS-side fallback (same fix as resolveImportPath).
+      const resolved = remapJsToTs(normalized, rootDir);
+      map.set(`${r.fromFile}|${r.importSource}`, resolved);
     }
     return map;
-  } catch {
+  } catch (e) {
+    debug(`batchResolve: native batch resolution failed: ${toErrorMessage(e)}`);
     return null;
   }
 }

package/src/domain/graph/{watcher.js → watcher.ts}

@@ -5,20 +5,20 @@ import { info } from '../../infrastructure/logger.js';
 import { EXTENSIONS, IGNORE_DIRS, normalizePath } from '../../shared/constants.js';
 import { DbError } from '../../shared/errors.js';
 import { createParseTreeCache, getActiveEngine } from '../parser.js';
-import { rebuildFile } from './builder/incremental.js';
+import { type IncrementalStmts, rebuildFile } from './builder/incremental.js';
 import { appendChangeEvents, buildChangeEvent, diffSymbols } from './change-journal.js';
 import { appendJournalEntries } from './journal.js';
 
-function shouldIgnore(filePath) {
+function shouldIgnore(filePath: string): boolean {
   const parts = filePath.split(path.sep);
   return parts.some((p) => IGNORE_DIRS.has(p));
 }
 
-function isTrackedExt(filePath) {
+function isTrackedExt(filePath: string): boolean {
   return EXTENSIONS.has(path.extname(filePath));
 }
 
-export async function watchProject(rootDir, opts = {}) {
+export async function watchProject(rootDir: string, opts: { engine?: string } = {}): Promise<void> {
   const dbPath = path.join(rootDir, '.codegraph', 'graph.db');
   if (!fs.existsSync(dbPath)) {
     throw new DbError('No graph.db found. Run `codegraph build` first.', { file: dbPath });
@@ -26,7 +26,11 @@ export async function watchProject(rootDir, opts = {}) {
 
   const db = openDb(dbPath);
   initSchema(db);
-  const engineOpts = { engine: opts.engine || 'auto' };
+  const engineOpts: import('../../types.js').EngineOpts = {
+    engine: (opts.engine || 'auto') as import('../../types.js').EngineMode,
+    dataflow: false,
+    ast: false,
+  };
   const { name: engineName, version: engineVersion } = getActiveEngine(engineOpts);
   console.log(
     `Watch mode using ${engineName} engine${engineVersion ? ` (v${engineVersion})` : ''}`,
@@ -44,7 +48,7 @@ export async function watchProject(rootDir, opts = {}) {
       'INSERT OR IGNORE INTO nodes (name, kind, file, line, end_line) VALUES (?, ?, ?, ?, ?)',
     ),
     getNodeId: {
-      get: (name, kind, file, line) => {
+      get: (name: string, kind: string, file: string, line: number) => {
         const id = getNodeIdQuery(db, name, kind, file, line);
         return id != null ? { id } : undefined;
       },
@@ -53,9 +57,9 @@ export async function watchProject(rootDir, opts = {}) {
       'INSERT INTO edges (source_id, target_id, kind, confidence, dynamic) VALUES (?, ?, ?, ?, ?)',
     ),
     deleteNodes: db.prepare('DELETE FROM nodes WHERE file = ?'),
-    deleteEdgesForFile: null,
+    deleteEdgesForFile: null as { run: (f: string) => void } | null,
     countNodes: db.prepare('SELECT COUNT(*) as c FROM nodes WHERE file = ?'),
-    countEdgesForFile: null,
+    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 = ?",
     ),
@@ -72,22 +76,42 @@ export async function watchProject(rootDir, opts = {}) {
   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) => origDeleteEdges.run({ f }) };
-  stmts.countEdgesForFile = { get: (f) => origCountEdges.get({ f }) };
+  stmts.deleteEdgesForFile = { run: (f: string) => origDeleteEdges.run({ f }) };
+  stmts.countEdgesForFile = {
+    get: (f: string) => origCountEdges.get({ f }) as { c: number } | undefined,
+  };
 
-  const pending = new Set();
-  let timer = null;
+  const pending = new Set<string>();
+  let timer: ReturnType<typeof setTimeout> | null = null;
   const DEBOUNCE_MS = 300;
 
-  async function processPending() {
+  async function processPending(): Promise<void> {
     const files = [...pending];
     pending.clear();
 
-    const results = [];
+    const results: Array<{
+      file: string;
+      deleted?: boolean;
+      event: string;
+      symbolDiff: unknown;
+      nodesBefore: number;
+      nodesAfter: number;
+      nodesAdded: number;
+      nodesRemoved: number;
+      edgesAdded: number;
+    }> = [];
     for (const filePath of files) {
-      const result = await rebuildFile(db, rootDir, filePath, stmts, engineOpts, cache, {
-        diffSymbols,
-      });
+      const result = (await rebuildFile(
+        db,
+        rootDir,
+        filePath,
+        stmts as IncrementalStmts,
+        engineOpts,
+        cache,
+        {
+          diffSymbols: diffSymbols as (old: unknown[], new_: unknown[]) => unknown,
+        },
+      )) as (typeof results)[number] | null;
       if (result) results.push(result);
     }
     const updates = results;