@optave/codegraph 1.1.0 → 1.4.1

package/src/builder.js

@@ -1,17 +1,20 @@
-
-import fs from 'fs';
-import path from 'path';
-import { createHash } from 'crypto';
-import { openDb, initSchema } from './db.js';
-import { createParsers, getParser, extractSymbols, extractHCLSymbols, extractPythonSymbols } from './parser.js';
-import { IGNORE_DIRS, EXTENSIONS, normalizePath } from './constants.js';
+import { createHash } from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
 import { loadConfig } from './config.js';
-import { warn, debug, info } from './logger.js';
+import { EXTENSIONS, IGNORE_DIRS, normalizePath } from './constants.js';
+import { initSchema, openDb } from './db.js';
+import { warn } from './logger.js';
+import { getActiveEngine, parseFilesAuto } from './parser.js';
+import { computeConfidence, resolveImportPath, resolveImportsBatch } from './resolve.js';
+
+export { resolveImportPath } from './resolve.js';
 
 export function collectFiles(dir, files = [], config = {}) {
   let entries;
-  try { entries = fs.readdirSync(dir, { withFileTypes: true }); }
-  catch (err) {
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch (err) {
     warn(`Cannot read directory ${dir}: ${err.message}`);
     return files;
   }
@@ -25,7 +28,7 @@ export function collectFiles(dir, files = [], config = {}) {
       if (entry.isDirectory()) continue;
     }
     if (IGNORE_DIRS.has(entry.name)) continue;
-    if (extraIgnore && extraIgnore.has(entry.name)) continue;
+    if (extraIgnore?.has(entry.name)) continue;
 
     const full = path.join(dir, entry.name);
     if (entry.isDirectory()) {
@@ -43,7 +46,8 @@ export function loadPathAliases(rootDir) {
     const configPath = path.join(rootDir, configName);
     if (!fs.existsSync(configPath)) continue;
     try {
-      const raw = fs.readFileSync(configPath, 'utf-8')
+      const raw = fs
+        .readFileSync(configPath, 'utf-8')
         .replace(/\/\/.*$/gm, '')
         .replace(/\/\*[\s\S]*?\*\//g, '')
         .replace(/,\s*([\]}])/g, '$1');
@@ -52,7 +56,7 @@ export function loadPathAliases(rootDir) {
       if (opts.baseUrl) aliases.baseUrl = path.resolve(rootDir, opts.baseUrl);
       if (opts.paths) {
         for (const [pattern, targets] of Object.entries(opts.paths)) {
-          aliases.paths[pattern] = targets.map(t => path.resolve(aliases.baseUrl || rootDir, t));
+          aliases.paths[pattern] = targets.map((t) => path.resolve(aliases.baseUrl || rootDir, t));
         }
       }
       break;
@@ -63,70 +67,6 @@ export function loadPathAliases(rootDir) {
   return aliases;
 }
 
-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;
-}
-
-export function resolveImportPath(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);
-  let 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));
-}
-
-/**
- * Compute proximity-based confidence for call resolution.
- */
-function computeConfidence(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;
-}
-
 /**
  * Compute MD5 hash of file contents for incremental builds.
  */
@@ -143,20 +83,24 @@ function getChangedFiles(db, allFiles, rootDir) {
   try {
     db.prepare('SELECT 1 FROM file_hashes LIMIT 1').get();
     hasTable = true;
-  } catch { /* table doesn't exist */ }
+  } catch {
+    /* table doesn't exist */
+  }
 
   if (!hasTable) {
     // No hash table = first build, everything is new
     return {
-      changed: allFiles.map(f => ({ file: f })),
+      changed: allFiles.map((f) => ({ file: f })),
       removed: [],
-      isFullBuild: true
+      isFullBuild: true,
     };
   }
 
   const existing = new Map(
-    db.prepare('SELECT file, hash FROM file_hashes').all()
-      .map(r => [r.file, r.hash])
+    db
+      .prepare('SELECT file, hash FROM file_hashes')
+      .all()
+      .map((r) => [r.file, r.hash]),
   );
 
   const changed = [];
@@ -167,7 +111,11 @@ function getChangedFiles(db, allFiles, rootDir) {
     currentFiles.add(relPath);
 
     let content;
-    try { content = fs.readFileSync(file, 'utf-8'); } catch { continue; }
+    try {
+      content = fs.readFileSync(file, 'utf-8');
+    } catch {
+      continue;
+    }
     const hash = fileHash(content);
 
     if (existing.get(relPath) !== hash) {
@@ -191,21 +139,28 @@ export async function buildGraph(rootDir, opts = {}) {
   initSchema(db);
 
   const config = loadConfig(rootDir);
-  const incremental = opts.incremental !== false && config.build && config.build.incremental !== false;
+  const incremental =
+    opts.incremental !== false && config.build && config.build.incremental !== false;
+
+  // Engine selection: 'native', 'wasm', or 'auto' (default)
+  const engineOpts = { engine: opts.engine || 'auto' };
+  const { name: engineName, version: engineVersion } = getActiveEngine(engineOpts);
+  console.log(`Using ${engineName} engine${engineVersion ? ` (v${engineVersion})` : ''}`);
 
-  const parsers = await createParsers();
   const aliases = loadPathAliases(rootDir);
   // Merge config aliases
   if (config.aliases) {
     for (const [key, value] of Object.entries(config.aliases)) {
-      const pattern = key.endsWith('/') ? key + '*' : key;
+      const pattern = key.endsWith('/') ? `${key}*` : key;
       const target = path.resolve(rootDir, value);
-      aliases.paths[pattern] = [target.endsWith('/') ? target + '*' : target + '/*'];
+      aliases.paths[pattern] = [target.endsWith('/') ? `${target}*` : `${target}/*`];
     }
   }
 
   if (aliases.baseUrl || Object.keys(aliases.paths).length > 0) {
-    console.log(`Loaded path aliases: baseUrl=${aliases.baseUrl || 'none'}, ${Object.keys(aliases.paths).length} path mappings`);
+    console.log(
+      `Loaded path aliases: baseUrl=${aliases.baseUrl || 'none'}, ${Object.keys(aliases.paths).length} path mappings`,
+    );
   }
 
   const files = collectFiles(rootDir, [], config);
@@ -214,7 +169,7 @@ export async function buildGraph(rootDir, opts = {}) {
   // Check for incremental build
   const { changed, removed, isFullBuild } = incremental
     ? getChangedFiles(db, files, rootDir)
-    : { changed: files.map(f => ({ file: f })), removed: [], isFullBuild: true };
+    : { changed: files.map((f) => ({ file: f })), removed: [], isFullBuild: true };
 
   if (!isFullBuild && changed.length === 0 && removed.length === 0) {
     console.log('No changes detected. Graph is up to date.');
@@ -223,7 +178,9 @@ export async function buildGraph(rootDir, opts = {}) {
   }
 
   if (isFullBuild) {
-    db.exec('PRAGMA foreign_keys = OFF; DELETE FROM edges; DELETE FROM nodes; PRAGMA foreign_keys = ON;');
+    db.exec(
+      'PRAGMA foreign_keys = OFF; DELETE FROM edges; DELETE FROM nodes; PRAGMA foreign_keys = ON;',
+    );
   } else {
     console.log(`Incremental: ${changed.length} changed, ${removed.length} removed`);
     // Remove nodes/edges for changed and removed files
@@ -243,86 +200,88 @@ export async function buildGraph(rootDir, opts = {}) {
     }
   }
 
-  const insertNode = db.prepare('INSERT OR IGNORE INTO nodes (name, kind, file, line, end_line) VALUES (?, ?, ?, ?, ?)');
-  const getNodeId = db.prepare('SELECT id FROM nodes WHERE name = ? AND kind = ? AND file = ? AND line = ?');
-  const insertEdge = db.prepare('INSERT INTO edges (source_id, target_id, kind, confidence, dynamic) VALUES (?, ?, ?, ?, ?)');
+  const insertNode = db.prepare(
+    'INSERT OR IGNORE INTO nodes (name, kind, file, line, end_line) VALUES (?, ?, ?, ?, ?)',
+  );
+  const getNodeId = db.prepare(
+    'SELECT id FROM nodes WHERE name = ? AND kind = ? AND file = ? AND line = ?',
+  );
+  const insertEdge = db.prepare(
+    'INSERT INTO edges (source_id, target_id, kind, confidence, dynamic) VALUES (?, ?, ?, ?, ?)',
+  );
 
   // Prepare hash upsert
   let upsertHash;
   try {
-    upsertHash = db.prepare('INSERT OR REPLACE INTO file_hashes (file, hash, mtime) VALUES (?, ?, ?)');
-  } catch { upsertHash = null; }
+    upsertHash = db.prepare(
+      'INSERT OR REPLACE INTO file_hashes (file, hash, mtime) VALUES (?, ?, ?)',
+    );
+  } catch {
+    upsertHash = null;
+  }
 
   // First pass: parse files and insert nodes
   const fileSymbols = new Map();
-  let parsed = 0, skipped = 0;
 
   // For incremental builds, also load existing symbols that aren't changing
   if (!isFullBuild) {
     // We need to reload ALL file symbols for edge building
-    const allExistingFiles = db.prepare("SELECT DISTINCT file FROM nodes WHERE kind = 'file'").all();
+    const _allExistingFiles = db
+      .prepare("SELECT DISTINCT file FROM nodes WHERE kind = 'file'")
+      .all();
     // We'll fill these in during the parse pass + edge pass
   }
 
-  const filesToParse = isFullBuild
-    ? files.map(f => ({ file: f }))
-    : changed;
-
-  const insertMany = db.transaction(() => {
-    for (const item of filesToParse) {
-      const filePath = item.file;
-      const parser = getParser(parsers, filePath);
-      if (!parser) { skipped++; continue; }
-
-      let code;
-      if (item.content) {
-        code = item.content;
-      } else {
-        try { code = fs.readFileSync(filePath, 'utf-8'); }
-        catch (err) {
-          warn(`Skipping ${path.relative(rootDir, filePath)}: ${err.message}`);
-          skipped++;
-          continue;
-        }
-      }
+  const filesToParse = isFullBuild ? files.map((f) => ({ file: f })) : changed;
 
-      let tree;
-      try { tree = parser.parse(code); }
-      catch (e) {
-        warn(`Parse error in ${path.relative(rootDir, filePath)}: ${e.message}`);
-        skipped++;
-        continue;
-      }
+  // ── Unified parse via parseFilesAuto ───────────────────────────────
+  const filePaths = filesToParse.map((item) => item.file);
+  const allSymbols = await parseFilesAuto(filePaths, rootDir, engineOpts);
+
+  // Build a hash lookup from incremental data (changed items may carry pre-computed hashes)
+  const precomputedHashes = new Map();
+  for (const item of filesToParse) {
+    if (item.hash && item.relPath) {
+      precomputedHashes.set(item.relPath, item.hash);
+    }
+  }
 
-      const relPath = normalizePath(path.relative(rootDir, filePath));
-      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 insertAll = db.transaction(() => {
+    for (const [relPath, symbols] of allSymbols) {
       fileSymbols.set(relPath, symbols);
 
       insertNode.run(relPath, 'file', relPath, 0, null);
-
       for (const def of symbols.definitions) {
         insertNode.run(def.name, def.kind, relPath, def.line, def.endLine || null);
       }
-
       for (const exp of symbols.exports) {
         insertNode.run(exp.name, exp.kind, relPath, exp.line, null);
       }
 
       // Update file hash for incremental builds
       if (upsertHash) {
-        const hash = item.hash || fileHash(code);
-        upsertHash.run(relPath, hash, Date.now());
+        const existingHash = precomputedHashes.get(relPath);
+        if (existingHash) {
+          upsertHash.run(relPath, existingHash, Date.now());
+        } else {
+          const absPath = path.join(rootDir, relPath);
+          let code;
+          try {
+            code = fs.readFileSync(absPath, 'utf-8');
+          } catch {
+            code = null;
+          }
+          if (code !== null) {
+            upsertHash.run(relPath, fileHash(code), Date.now());
+          }
+        }
       }
-
-      parsed++;
-      if (parsed % 100 === 0) process.stdout.write(`  Parsed ${parsed}/${filesToParse.length} files\r`);
     }
   });
-  insertMany();
+  insertAll();
+
+  const parsed = allSymbols.size;
+  const skipped = filesToParse.length - parsed;
   console.log(`Parsed ${parsed} files (${skipped} skipped)`);
 
   // Clean up removed file hashes
@@ -333,23 +292,46 @@ export async function buildGraph(rootDir, opts = {}) {
     }
   }
 
+  // ── Batch import resolution ────────────────────────────────────────
+  // Collect all (fromFile, importSource) pairs and resolve in one native call
+  const batchInputs = [];
+  for (const [relPath, symbols] of fileSymbols) {
+    const absFile = path.join(rootDir, relPath);
+    for (const imp of symbols.imports) {
+      batchInputs.push({ fromFile: absFile, importSource: imp.source });
+    }
+  }
+  const batchResolved = resolveImportsBatch(batchInputs, rootDir, aliases);
+
+  function getResolved(absFile, importSource) {
+    if (batchResolved) {
+      const key = `${absFile}|${importSource}`;
+      const hit = batchResolved.get(key);
+      if (hit !== undefined) return hit;
+    }
+    return resolveImportPath(absFile, importSource, rootDir, aliases);
+  }
+
   // Build re-export map for barrel resolution
   const reexportMap = new Map();
   for (const [relPath, symbols] of fileSymbols) {
-    const reexports = symbols.imports.filter(imp => imp.reexport);
+    const reexports = symbols.imports.filter((imp) => imp.reexport);
     if (reexports.length > 0) {
-      reexportMap.set(relPath, reexports.map(imp => ({
-        source: resolveImportPath(path.join(rootDir, relPath), imp.source, rootDir, aliases),
-        names: imp.names,
-        wildcardReexport: imp.wildcardReexport || false
-      })));
+      reexportMap.set(
+        relPath,
+        reexports.map((imp) => ({
+          source: getResolved(path.join(rootDir, relPath), imp.source),
+          names: imp.names,
+          wildcardReexport: imp.wildcardReexport || false,
+        })),
+      );
     }
   }
 
   function isBarrelFile(relPath) {
     const symbols = fileSymbols.get(relPath);
     if (!symbols) return false;
-    const reexports = symbols.imports.filter(imp => imp.reexport);
+    const reexports = symbols.imports.filter((imp) => imp.reexport);
     if (reexports.length === 0) return false;
     const ownDefs = symbols.definitions.length;
     return reexports.length >= ownDefs;
@@ -366,7 +348,7 @@ export async function buildGraph(rootDir, opts = {}) {
         if (re.names.includes(symbolName)) {
           const targetSymbols = fileSymbols.get(re.source);
           if (targetSymbols) {
-            const hasDef = targetSymbols.definitions.some(d => d.name === symbolName);
+            const hasDef = targetSymbols.definitions.some((d) => d.name === symbolName);
             if (hasDef) return re.source;
             const deeper = resolveBarrelExport(re.source, symbolName, visited);
             if (deeper) return deeper;
@@ -378,7 +360,7 @@ export async function buildGraph(rootDir, opts = {}) {
       if (re.wildcardReexport || re.names.length === 0) {
         const targetSymbols = fileSymbols.get(re.source);
         if (targetSymbols) {
-          const hasDef = targetSymbols.definitions.some(d => d.name === symbolName);
+          const hasDef = targetSymbols.definitions.some((d) => d.name === symbolName);
           if (hasDef) return re.source;
           const deeper = resolveBarrelExport(re.source, symbolName, visited);
           if (deeper) return deeper;
@@ -389,9 +371,11 @@ export async function buildGraph(rootDir, opts = {}) {
   }
 
   // N+1 optimization: pre-load all nodes into a lookup map for edge building
-  const allNodes = db.prepare(
-    `SELECT id, name, kind, file FROM nodes WHERE kind IN ('function','method','class','interface')`
-  ).all();
+  const allNodes = db
+    .prepare(
+      `SELECT id, name, kind, file FROM nodes WHERE kind IN ('function','method','class','interface')`,
+    )
+    .all();
   const nodesByName = new Map();
   for (const node of allNodes) {
     if (!nodesByName.has(node.name)) nodesByName.set(node.name, []);
@@ -414,7 +398,7 @@ export async function buildGraph(rootDir, opts = {}) {
 
       // Import edges
       for (const imp of symbols.imports) {
-        const resolvedPath = resolveImportPath(path.join(rootDir, relPath), imp.source, rootDir, aliases);
+        const resolvedPath = getResolved(path.join(rootDir, relPath), imp.source);
         const targetRow = getNodeId.get(resolvedPath, 'file', resolvedPath, 0);
         if (targetRow) {
           const edgeKind = imp.reexport ? 'reexports' : imp.typeOnly ? 'imports-type' : 'imports';
@@ -426,11 +410,21 @@ export async function buildGraph(rootDir, opts = {}) {
             for (const name of imp.names) {
               const cleanName = name.replace(/^\*\s+as\s+/, '');
               const actualSource = resolveBarrelExport(resolvedPath, cleanName);
-              if (actualSource && actualSource !== resolvedPath && !resolvedSources.has(actualSource)) {
+              if (
+                actualSource &&
+                actualSource !== resolvedPath &&
+                !resolvedSources.has(actualSource)
+              ) {
                 resolvedSources.add(actualSource);
                 const actualRow = getNodeId.get(actualSource, 'file', actualSource, 0);
                 if (actualRow) {
-                  insertEdge.run(fileNodeId, actualRow.id, edgeKind === 'imports-type' ? 'imports-type' : 'imports', 0.9, 0);
+                  insertEdge.run(
+                    fileNodeId,
+                    actualRow.id,
+                    edgeKind === 'imports-type' ? 'imports-type' : 'imports',
+                    0.9,
+                    0,
+                  );
                   edgeCount++;
                 }
               }
@@ -442,7 +436,7 @@ export async function buildGraph(rootDir, opts = {}) {
       // Build import name -> target file mapping
       const importedNames = new Map();
       for (const imp of symbols.imports) {
-        const resolvedPath = resolveImportPath(path.join(rootDir, relPath), imp.source, rootDir, aliases);
+        const resolvedPath = getResolved(path.join(rootDir, relPath), imp.source);
         for (const name of imp.names) {
           const cleanName = name.replace(/^\*\s+as\s+/, '');
           importedNames.set(cleanName, resolvedPath);
@@ -480,8 +474,8 @@ export async function buildGraph(rootDir, opts = {}) {
           targets = nodesByNameAndFile.get(`${call.name}|${relPath}`) || [];
           if (targets.length === 0) {
             // Method name match (e.g. ClassName.methodName)
-            const methodCandidates = (nodesByName.get(call.name) || []).filter(n =>
-              n.name.endsWith(`.${call.name}`) && n.kind === 'method'
+            const methodCandidates = (nodesByName.get(call.name) || []).filter(
+              (n) => n.name.endsWith(`.${call.name}`) && n.kind === 'method',
             );
             if (methodCandidates.length > 0) {
               targets = methodCandidates;
@@ -512,9 +506,11 @@ export async function buildGraph(rootDir, opts = {}) {
       // Class extends edges
       for (const cls of symbols.classes) {
         if (cls.extends) {
-          const sourceRow = db.prepare('SELECT id FROM nodes WHERE name = ? AND kind = ? AND file = ?').get(cls.name, 'class', relPath);
+          const sourceRow = db
+            .prepare('SELECT id FROM nodes WHERE name = ? AND kind = ? AND file = ?')
+            .get(cls.name, 'class', relPath);
           const targetCandidates = nodesByName.get(cls.extends) || [];
-          const targetRows = targetCandidates.filter(n => n.kind === 'class');
+          const targetRows = targetCandidates.filter((n) => n.kind === 'class');
           if (sourceRow) {
             for (const t of targetRows) {
               insertEdge.run(sourceRow.id, t.id, 'extends', 1.0, 0);
@@ -524,9 +520,13 @@ export async function buildGraph(rootDir, opts = {}) {
         }
 
         if (cls.implements) {
-          const sourceRow = db.prepare('SELECT id FROM nodes WHERE name = ? AND kind = ? AND file = ?').get(cls.name, 'class', relPath);
+          const sourceRow = db
+            .prepare('SELECT id FROM nodes WHERE name = ? AND kind = ? AND file = ?')
+            .get(cls.name, 'class', relPath);
           const targetCandidates = nodesByName.get(cls.implements) || [];
-          const targetRows = targetCandidates.filter(n => n.kind === 'interface' || n.kind === 'class');
+          const targetRows = targetCandidates.filter(
+            (n) => n.kind === 'interface' || n.kind === 'class',
+          );
           if (sourceRow) {
             for (const t of targetRows) {
               insertEdge.run(sourceRow.id, t.id, 'implements', 1.0, 0);
@@ -544,4 +544,3 @@ export async function buildGraph(rootDir, opts = {}) {
   console.log(`Stored in ${dbPath}`);
   db.close();
 }
-