@optave/codegraph 1.1.0 → 1.4.1

package/src/resolve.js

@@ -0,0 +1,171 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { normalizePath } from './constants.js';
+import { loadNative } from './native.js';
+
+// ── Alias format conversion ─────────────────────────────────────────
+
+/**
+ * Convert JS alias format { baseUrl, paths: { pattern: [targets] } }
+ * to native format { baseUrl, paths: [{ pattern, targets }] }.
+ */
+export function convertAliasesForNative(aliases) {
+  if (!aliases) return null;
+  return {
+    baseUrl: aliases.baseUrl || '',
+    paths: Object.entries(aliases.paths || {}).map(([pattern, targets]) => ({
+      pattern,
+      targets,
+    })),
+  };
+}
+
+// ── JS fallback implementations ─────────────────────────────────────
+
+function resolveViaAlias(importSource, aliases, _rootDir) {
+  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']) {
+      const full = candidate + ext;
+      if (fs.existsSync(full)) return full;
+    }
+  }
+
+  for (const [pattern, targets] of Object.entries(aliases.paths)) {
+    const prefix = pattern.replace(/\*$/, '');
+    if (!importSource.startsWith(prefix)) continue;
+    const rest = importSource.slice(prefix.length);
+    for (const target of targets) {
+      const resolved = target.replace(/\*$/, rest);
+      for (const ext of [
+        '',
+        '.ts',
+        '.tsx',
+        '.js',
+        '.jsx',
+        '/index.ts',
+        '/index.tsx',
+        '/index.js',
+      ]) {
+        const full = resolved + ext;
+        if (fs.existsSync(full)) return full;
+      }
+    }
+  }
+  return null;
+}
+
+function resolveImportPathJS(fromFile, importSource, rootDir, aliases) {
+  if (!importSource.startsWith('.') && aliases) {
+    const aliasResolved = resolveViaAlias(importSource, aliases, rootDir);
+    if (aliasResolved) return normalizePath(path.relative(rootDir, aliasResolved));
+  }
+  if (!importSource.startsWith('.')) return importSource;
+  const dir = path.dirname(fromFile);
+  const resolved = path.resolve(dir, importSource);
+
+  if (resolved.endsWith('.js')) {
+    const tsCandidate = resolved.replace(/\.js$/, '.ts');
+    if (fs.existsSync(tsCandidate)) return normalizePath(path.relative(rootDir, tsCandidate));
+    const tsxCandidate = resolved.replace(/\.js$/, '.tsx');
+    if (fs.existsSync(tsxCandidate)) return normalizePath(path.relative(rootDir, tsxCandidate));
+  }
+
+  for (const ext of [
+    '.ts',
+    '.tsx',
+    '.js',
+    '.jsx',
+    '.mjs',
+    '.py',
+    '/index.ts',
+    '/index.tsx',
+    '/index.js',
+    '/__init__.py',
+  ]) {
+    const candidate = resolved + ext;
+    if (fs.existsSync(candidate)) {
+      return normalizePath(path.relative(rootDir, candidate));
+    }
+  }
+  if (fs.existsSync(resolved)) return normalizePath(path.relative(rootDir, resolved));
+  return normalizePath(path.relative(rootDir, resolved));
+}
+
+function computeConfidenceJS(callerFile, targetFile, importedFrom) {
+  if (!targetFile || !callerFile) return 0.3;
+  if (callerFile === targetFile) return 1.0;
+  if (importedFrom === targetFile) return 1.0;
+  if (path.dirname(callerFile) === path.dirname(targetFile)) return 0.7;
+  const callerParent = path.dirname(path.dirname(callerFile));
+  const targetParent = path.dirname(path.dirname(targetFile));
+  if (callerParent === targetParent) return 0.5;
+  return 0.3;
+}
+
+// ── Public API with native dispatch ─────────────────────────────────
+
+/**
+ * Resolve a single import path.
+ * Tries native, falls back to JS.
+ */
+export function resolveImportPath(fromFile, importSource, rootDir, aliases) {
+  const native = loadNative();
+  if (native) {
+    try {
+      return native.resolveImport(
+        fromFile,
+        importSource,
+        rootDir,
+        convertAliasesForNative(aliases),
+      );
+    } catch {
+      // fall through to JS
+    }
+  }
+  return resolveImportPathJS(fromFile, importSource, rootDir, aliases);
+}
+
+/**
+ * Compute proximity-based confidence for call resolution.
+ * Tries native, falls back to JS.
+ */
+export function computeConfidence(callerFile, targetFile, importedFrom) {
+  const native = loadNative();
+  if (native) {
+    try {
+      return native.computeConfidence(callerFile, targetFile, importedFrom || null);
+    } catch {
+      // fall through to JS
+    }
+  }
+  return computeConfidenceJS(callerFile, targetFile, importedFrom);
+}
+
+/**
+ * Batch resolve multiple imports in a single native call.
+ * Returns Map<"fromFile|importSource", resolvedPath> or null when native unavailable.
+ */
+export function resolveImportsBatch(inputs, rootDir, aliases) {
+  const native = loadNative();
+  if (!native) return null;
+
+  try {
+    const nativeInputs = inputs.map(({ fromFile, importSource }) => ({
+      fromFile,
+      importSource,
+    }));
+    const results = native.resolveImports(nativeInputs, rootDir, convertAliasesForNative(aliases));
+    const map = new Map();
+    for (const r of results) {
+      map.set(`${r.fromFile}|${r.importSource}`, r.resolvedPath);
+    }
+    return map;
+  } catch {
+    return null;
+  }
+}
+
+// ── Exported for testing ────────────────────────────────────────────
+
+export { resolveImportPathJS, computeConfidenceJS };

package/src/watcher.js

@@ -1,15 +1,14 @@
-
-import fs from 'fs';
-import path from 'path';
-import { openDb, initSchema } from './db.js';
-import { createParsers, getParser, extractSymbols, extractHCLSymbols, extractPythonSymbols } from './parser.js';
-import { IGNORE_DIRS, EXTENSIONS, normalizePath } from './constants.js';
-import { resolveImportPath } from './builder.js';
-import { warn, debug, info } from './logger.js';
+import fs from 'node:fs';
+import path from 'node:path';
+import { EXTENSIONS, IGNORE_DIRS, normalizePath } from './constants.js';
+import { initSchema, openDb } from './db.js';
+import { info, warn } from './logger.js';
+import { createParseTreeCache, getActiveEngine, parseFileIncremental } from './parser.js';
+import { resolveImportPath } from './resolve.js';
 
 function shouldIgnore(filePath) {
   const parts = filePath.split(path.sep);
-  return parts.some(p => IGNORE_DIRS.has(p));
+  return parts.some((p) => IGNORE_DIRS.has(p));
 }
 
 function isTrackedExt(filePath) {
@@ -19,41 +18,30 @@ function isTrackedExt(filePath) {
 /**
  * Parse a single file and update the database incrementally.
  */
-function updateFile(db, rootDir, filePath, parsers, stmts) {
+async function updateFile(_db, rootDir, filePath, stmts, engineOpts, cache) {
   const relPath = normalizePath(path.relative(rootDir, filePath));
 
   const oldNodes = stmts.countNodes.get(relPath)?.c || 0;
-  const oldEdges = stmts.countEdgesForFile.get(relPath)?.c || 0;
+  const _oldEdges = stmts.countEdgesForFile.get(relPath)?.c || 0;
 
   stmts.deleteEdgesForFile.run(relPath);
   stmts.deleteNodes.run(relPath);
 
   if (!fs.existsSync(filePath)) {
+    if (cache) cache.remove(filePath);
     return { file: relPath, nodesAdded: 0, nodesRemoved: oldNodes, edgesAdded: 0, deleted: true };
   }
 
-  const parser = getParser(parsers, filePath);
-  if (!parser) return null;
-
   let code;
-  try { code = fs.readFileSync(filePath, 'utf-8'); }
-  catch (err) {
+  try {
+    code = fs.readFileSync(filePath, 'utf-8');
+  } catch (err) {
     warn(`Cannot read ${relPath}: ${err.message}`);
     return null;
   }
 
-  let tree;
-  try { tree = parser.parse(code); }
-  catch (err) {
-    warn(`Parse error in ${relPath}: ${err.message}`);
-    return null;
-  }
-
-  const isHCL = filePath.endsWith('.tf') || filePath.endsWith('.hcl');
-  const isPython = filePath.endsWith('.py');
-  const symbols = isHCL ? extractHCLSymbols(tree, filePath)
-    : isPython ? extractPythonSymbols(tree, filePath)
-    : extractSymbols(tree, filePath);
+  const symbols = await parseFileIncremental(cache, filePath, code, engineOpts);
+  if (!symbols) return null;
 
   stmts.insertNode.run(relPath, 'file', relPath, 0, null);
 
@@ -68,14 +56,20 @@ function updateFile(db, rootDir, filePath, parsers, stmts) {
 
   let edgesAdded = 0;
   const fileNodeRow = stmts.getNodeId.get(relPath, 'file', relPath, 0);
-  if (!fileNodeRow) return { file: relPath, nodesAdded: newNodes, nodesRemoved: oldNodes, edgesAdded: 0 };
+  if (!fileNodeRow)
+    return { file: relPath, nodesAdded: newNodes, nodesRemoved: oldNodes, edgesAdded: 0 };
   const fileNodeId = fileNodeRow.id;
 
   // Load aliases for full import resolution
   const aliases = { baseUrl: null, paths: {} };
 
   for (const imp of symbols.imports) {
-    const resolvedPath = resolveImportPath(path.join(rootDir, relPath), imp.source, rootDir, aliases);
+    const resolvedPath = resolveImportPath(
+      path.join(rootDir, relPath),
+      imp.source,
+      rootDir,
+      aliases,
+    );
     const targetRow = stmts.getNodeId.get(resolvedPath, 'file', resolvedPath, 0);
     if (targetRow) {
       const edgeKind = imp.reexport ? 'reexports' : imp.typeOnly ? 'imports-type' : 'imports';
@@ -86,7 +80,12 @@ function updateFile(db, rootDir, filePath, parsers, stmts) {
 
   const importedNames = new Map();
   for (const imp of symbols.imports) {
-    const resolvedPath = resolveImportPath(path.join(rootDir, relPath), imp.source, rootDir, aliases);
+    const resolvedPath = resolveImportPath(
+      path.join(rootDir, relPath),
+      imp.source,
+      rootDir,
+      aliases,
+    );
     for (const name of imp.names) {
       importedNames.set(name.replace(/^\*\s+as\s+/, ''), resolvedPath);
     }
@@ -116,7 +115,13 @@ function updateFile(db, rootDir, filePath, parsers, stmts) {
 
     for (const t of targets) {
       if (t.id !== caller.id) {
-        stmts.insertEdge.run(caller.id, t.id, 'calls', importedFrom ? 1.0 : 0.5, call.dynamic ? 1 : 0);
+        stmts.insertEdge.run(
+          caller.id,
+          t.id,
+          'calls',
+          importedFrom ? 1.0 : 0.5,
+          call.dynamic ? 1 : 0,
+        );
         edgesAdded++;
       }
     }
@@ -127,11 +132,11 @@ function updateFile(db, rootDir, filePath, parsers, stmts) {
     nodesAdded: newNodes,
     nodesRemoved: oldNodes,
     edgesAdded,
-    deleted: false
+    deleted: false,
   };
 }
 
-export async function watchProject(rootDir) {
+export async function watchProject(rootDir, opts = {}) {
   const dbPath = path.join(rootDir, '.codegraph', 'graph.db');
   if (!fs.existsSync(dbPath)) {
     console.error('No graph.db found. Run `codegraph build` first.');
@@ -140,23 +145,48 @@ export async function watchProject(rootDir) {
 
   const db = openDb(dbPath);
   initSchema(db);
-  const parsers = await createParsers();
+  const engineOpts = { engine: opts.engine || 'auto' };
+  const { name: engineName, version: engineVersion } = getActiveEngine(engineOpts);
+  console.log(
+    `Watch mode using ${engineName} engine${engineVersion ? ` (v${engineVersion})` : ''}`,
+  );
+
+  const cache = createParseTreeCache();
+  console.log(
+    cache
+      ? 'Incremental parsing enabled (native tree cache)'
+      : 'Incremental parsing unavailable (full re-parse)',
+  );
 
   const stmts = {
-    insertNode: db.prepare('INSERT OR IGNORE INTO nodes (name, kind, file, line, end_line) VALUES (?, ?, ?, ?, ?)'),
-    getNodeId: db.prepare('SELECT id FROM nodes WHERE name = ? AND kind = ? AND file = ? AND line = ?'),
-    insertEdge: db.prepare('INSERT INTO edges (source_id, target_id, kind, confidence, dynamic) VALUES (?, ?, ?, ?, ?)'),
+    insertNode: db.prepare(
+      'INSERT OR IGNORE INTO nodes (name, kind, file, line, end_line) VALUES (?, ?, ?, ?, ?)',
+    ),
+    getNodeId: db.prepare(
+      'SELECT id FROM nodes WHERE name = ? AND kind = ? AND file = ? AND line = ?',
+    ),
+    insertEdge: db.prepare(
+      'INSERT INTO edges (source_id, target_id, kind, confidence, dynamic) VALUES (?, ?, ?, ?, ?)',
+    ),
     deleteNodes: db.prepare('DELETE FROM nodes WHERE file = ?'),
     deleteEdgesForFile: null,
     countNodes: db.prepare('SELECT COUNT(*) as c FROM nodes WHERE file = ?'),
     countEdgesForFile: null,
-    findNodeInFile: db.prepare('SELECT id, file FROM nodes WHERE name = ? AND kind IN (\'function\', \'method\', \'class\', \'interface\') AND file = ?'),
-    findNodeByName: db.prepare('SELECT id, file FROM nodes WHERE name = ? AND kind IN (\'function\', \'method\', \'class\', \'interface\')'),
+    findNodeInFile: db.prepare(
+      "SELECT id, file FROM nodes WHERE name = ? AND kind IN ('function', 'method', 'class', 'interface') AND file = ?",
+    ),
+    findNodeByName: db.prepare(
+      "SELECT id, file FROM nodes WHERE name = ? AND kind IN ('function', 'method', 'class', 'interface')",
+    ),
   };
 
   // Use named params for statements needing the same value twice
-  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)`);
+  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) => origDeleteEdges.run({ f }) };
   stmts.countEdgesForFile = { get: (f) => origCountEdges.get({ f }) };
 
@@ -164,18 +194,16 @@ export async function watchProject(rootDir) {
   let timer = null;
   const DEBOUNCE_MS = 300;
 
-  function processPending() {
+  async function processPending() {
     const files = [...pending];
     pending.clear();
 
-    const updates = db.transaction(() => {
-      const results = [];
-      for (const filePath of files) {
-        const result = updateFile(db, rootDir, filePath, parsers, stmts);
-        if (result) results.push(result);
-      }
-      return results;
-    })();
+    const results = [];
+    for (const filePath of files) {
+      const result = await updateFile(db, rootDir, filePath, stmts, engineOpts, cache);
+      if (result) results.push(result);
+    }
+    const updates = results;
 
     for (const r of updates) {
       const nodeDelta = r.nodesAdded - r.nodesRemoved;
@@ -191,7 +219,7 @@ export async function watchProject(rootDir) {
   console.log(`Watching ${rootDir} for changes...`);
   console.log('Press Ctrl+C to stop.\n');
 
-  const watcher = fs.watch(rootDir, { recursive: true }, (eventType, filename) => {
+  const watcher = fs.watch(rootDir, { recursive: true }, (_eventType, filename) => {
     if (!filename) return;
     if (shouldIgnore(filename)) return;
     if (!isTrackedExt(filename)) return;
@@ -206,8 +234,8 @@ export async function watchProject(rootDir) {
   process.on('SIGINT', () => {
     console.log('\nStopping watcher...');
     watcher.close();
+    if (cache) cache.clear();
     db.close();
     process.exit(0);
   });
 }
-