@optave/codegraph 3.7.0 → 3.8.1

package/src/domain/graph/watcher.ts

@@ -18,29 +18,8 @@ function isTrackedExt(filePath: string): boolean {
   return EXTENSIONS.has(path.extname(filePath));
 }
 
-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 });
-  }
-
-  const db = openDb(dbPath);
-  initSchema(db);
-  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);
-  info(`Watch mode using ${engineName} engine${engineVersion ? ` (v${engineVersion})` : ''}`);
-
-  const cache = createParseTreeCache();
-  info(
-    cache
-      ? 'Incremental parsing enabled (native tree cache)'
-      : 'Incremental parsing unavailable (full re-parse)',
-  );
-
+/** Prepare all SQL statements needed by the watcher's incremental rebuild. */
+function prepareWatcherStatements(db: ReturnType<typeof openDb>): IncrementalStmts {
   const stmts = {
     insertNode: db.prepare(
       'INSERT OR IGNORE INTO nodes (name, kind, file, line, end_line) VALUES (?, ?, ?, ?, ?)',
@@ -67,7 +46,6 @@ export async function watchProject(rootDir: string, opts: { engine?: string } =
     listSymbols: db.prepare("SELECT name, kind, line FROM nodes WHERE file = ? AND kind != 'file'"),
   };
 
-  // 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)`,
   );
@@ -79,96 +57,224 @@ export async function watchProject(rootDir: string, opts: { engine?: string } =
     get: (f: string) => origCountEdges.get({ f }) as { c: number } | undefined,
   };
 
+  return stmts as IncrementalStmts;
+}
+
+/** Rebuild result shape from rebuildFile. */
+interface RebuildResult {
+  file: string;
+  deleted?: boolean;
+  event: string;
+  symbolDiff: unknown;
+  nodesBefore: number;
+  nodesAfter: number;
+  nodesAdded: number;
+  nodesRemoved: number;
+  edgesAdded: number;
+}
+
+/** Process a batch of pending file changes: rebuild, journal, and log. */
+async function processPendingFiles(
+  files: string[],
+  db: ReturnType<typeof openDb>,
+  rootDir: string,
+  stmts: IncrementalStmts,
+  engineOpts: import('../../types.js').EngineOpts,
+  cache: ReturnType<typeof createParseTreeCache>,
+): Promise<void> {
+  const results: RebuildResult[] = [];
+  for (const filePath of files) {
+    const result = (await rebuildFile(db, rootDir, filePath, stmts, engineOpts, cache, {
+      diffSymbols: diffSymbols as (old: unknown[], new_: unknown[]) => unknown,
+    })) as RebuildResult | null;
+    if (result) results.push(result);
+  }
+
+  if (results.length > 0) {
+    writeJournalAndChangeEvents(rootDir, results);
+  }
+
+  logRebuildResults(results);
+}
+
+/** Write journal entries and change events for processed files. */
+function writeJournalAndChangeEvents(rootDir: string, updates: RebuildResult[]): void {
+  const entries = updates.map((r) => ({
+    file: r.file,
+    deleted: r.deleted || false,
+  }));
+  try {
+    appendJournalEntries(rootDir, entries);
+  } catch (e: unknown) {
+    debug(`Journal write failed (non-fatal): ${(e as Error).message}`);
+  }
+
+  const changeEvents = updates.map((r) =>
+    buildChangeEvent(r.file, r.event, r.symbolDiff, {
+      nodesBefore: r.nodesBefore,
+      nodesAfter: r.nodesAfter,
+      edgesAdded: r.edgesAdded,
+    }),
+  );
+  try {
+    appendChangeEvents(rootDir, changeEvents);
+  } catch (e: unknown) {
+    debug(`Change event write failed (non-fatal): ${(e as Error).message}`);
+  }
+}
+
+/** Log rebuild results to the user. */
+function logRebuildResults(updates: RebuildResult[]): void {
+  for (const r of updates) {
+    const nodeDelta = r.nodesAdded - r.nodesRemoved;
+    const nodeStr = nodeDelta >= 0 ? `+${nodeDelta}` : `${nodeDelta}`;
+    if (r.deleted) {
+      info(`Removed: ${r.file} (-${r.nodesRemoved} nodes)`);
+    } else {
+      info(`Updated: ${r.file} (${nodeStr} nodes, +${r.edgesAdded} edges)`);
+    }
+  }
+}
+
+/** Recursively collect tracked source files for stat-based polling. */
+function collectTrackedFiles(dir: string, result: string[]): void {
+  let entries: fs.Dirent[];
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (IGNORE_DIRS.has(entry.name) || entry.name.startsWith('.')) continue;
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      collectTrackedFiles(full, result);
+    } else if (EXTENSIONS.has(path.extname(entry.name))) {
+      result.push(full);
+    }
+  }
+}
+
+export async function watchProject(
+  rootDir: string,
+  opts: { engine?: string; poll?: boolean; pollInterval?: number } = {},
+): 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 });
+  }
+
+  const db = openDb(dbPath);
+  initSchema(db);
+  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);
+  info(`Watch mode using ${engineName} engine${engineVersion ? ` (v${engineVersion})` : ''}`);
+
+  const cache = createParseTreeCache();
+  info(
+    cache
+      ? 'Incremental parsing enabled (native tree cache)'
+      : 'Incremental parsing unavailable (full re-parse)',
+  );
+
+  const stmts = prepareWatcherStatements(db);
+
   const pending = new Set<string>();
   let timer: ReturnType<typeof setTimeout> | null = null;
   const DEBOUNCE_MS = 300;
 
-  async function processPending(): Promise<void> {
-    const files = [...pending];
-    pending.clear();
-
-    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 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;
+  const usePoll = opts.poll ?? process.platform === 'win32';
+  const POLL_INTERVAL_MS = opts.pollInterval ?? 2000;
 
-    // Append processed files to journal for Tier 0 detection on next build
-    if (updates.length > 0) {
-      const entries = updates.map((r) => ({
-        file: r.file,
-        deleted: r.deleted || false,
-      }));
-      try {
-        appendJournalEntries(rootDir, entries);
-      } catch (e: unknown) {
-        debug(`Journal write failed (non-fatal): ${(e as Error).message}`);
-      }
+  info(`Watching ${rootDir} for changes${usePoll ? ' (polling mode)' : ''}...`);
+  info('Press Ctrl+C to stop.');
+
+  let cleanup: () => void;
+
+  if (usePoll) {
+    // Polling mode: avoids native OS file watchers (NtNotifyChangeDirectoryFileEx)
+    // which can crash ReFS drivers on Windows Dev Drives.
+    const mtimeMap = new Map<string, number>();
 
-      const changeEvents = updates.map((r) =>
-        buildChangeEvent(r.file, r.event, r.symbolDiff, {
-          nodesBefore: r.nodesBefore,
-          nodesAfter: r.nodesAfter,
-          edgesAdded: r.edgesAdded,
-        }),
-      );
+    // Seed initial mtimes
+    const initial: string[] = [];
+    collectTrackedFiles(rootDir, initial);
+    for (const f of initial) {
       try {
-        appendChangeEvents(rootDir, changeEvents);
-      } catch (e: unknown) {
-        debug(`Change event write failed (non-fatal): ${(e as Error).message}`);
+        mtimeMap.set(f, fs.statSync(f).mtimeMs);
+      } catch {
+        /* deleted between collect and stat */
       }
     }
+    info(`Polling ${initial.length} tracked files every ${POLL_INTERVAL_MS}ms`);
+
+    const pollTimer = setInterval(() => {
+      const current: string[] = [];
+      collectTrackedFiles(rootDir, current);
+      const currentSet = new Set(current);
 
-    for (const r of updates) {
-      const nodeDelta = r.nodesAdded - r.nodesRemoved;
-      const nodeStr = nodeDelta >= 0 ? `+${nodeDelta}` : `${nodeDelta}`;
-      if (r.deleted) {
-        info(`Removed: ${r.file} (-${r.nodesRemoved} nodes)`);
-      } else {
-        info(`Updated: ${r.file} (${nodeStr} nodes, +${r.edgesAdded} edges)`);
+      // Detect modified or new files
+      for (const f of current) {
+        try {
+          const mtime = fs.statSync(f).mtimeMs;
+          const prev = mtimeMap.get(f);
+          if (prev === undefined || mtime !== prev) {
+            mtimeMap.set(f, mtime);
+            pending.add(f);
+          }
+        } catch {
+          /* deleted between collect and stat */
+        }
       }
-    }
-  }
 
-  info(`Watching ${rootDir} for changes...`);
-  info('Press Ctrl+C to stop.');
+      // Detect deleted files
+      for (const f of mtimeMap.keys()) {
+        if (!currentSet.has(f)) {
+          mtimeMap.delete(f);
+          pending.add(f);
+        }
+      }
 
-  const watcher = fs.watch(rootDir, { recursive: true }, (_eventType, filename) => {
-    if (!filename) return;
-    if (shouldIgnore(filename)) return;
-    if (!isTrackedExt(filename)) return;
+      if (pending.size > 0) {
+        if (timer) clearTimeout(timer);
+        timer = setTimeout(async () => {
+          const files = [...pending];
+          pending.clear();
+          await processPendingFiles(files, db, rootDir, stmts, engineOpts, cache);
+        }, DEBOUNCE_MS);
+      }
+    }, POLL_INTERVAL_MS);
 
-    const fullPath = path.join(rootDir, filename);
-    pending.add(fullPath);
+    cleanup = () => clearInterval(pollTimer);
+  } else {
+    // Native OS watcher — efficient but can trigger ReFS crashes on Windows Dev Drives.
+    // Use --poll if you experience BSOD/HYPERVISOR_ERROR on ReFS volumes.
+    const watcher = fs.watch(rootDir, { recursive: true }, (_eventType, filename) => {
+      if (!filename) return;
+      if (shouldIgnore(filename)) return;
+      if (!isTrackedExt(filename)) return;
 
-    if (timer) clearTimeout(timer);
-    timer = setTimeout(processPending, DEBOUNCE_MS);
-  });
+      const fullPath = path.join(rootDir, filename);
+      pending.add(fullPath);
+
+      if (timer) clearTimeout(timer);
+      timer = setTimeout(async () => {
+        const files = [...pending];
+        pending.clear();
+        await processPendingFiles(files, db, rootDir, stmts, engineOpts, cache);
+      }, DEBOUNCE_MS);
+    });
+
+    cleanup = () => watcher.close();
+  }
 
   process.on('SIGINT', () => {
     info('Stopping watcher...');
-    watcher.close();
+    cleanup();
     // Flush any pending file paths to journal before exit
     if (pending.size > 0) {
       const entries = [...pending].map((filePath) => ({

package/src/domain/parser.ts

@@ -17,49 +17,71 @@ import type {
 // Re-export all extractors for backward compatibility
 export {
   extractBashSymbols,
+  extractClojureSymbols,
   extractCppSymbols,
   extractCSharpSymbols,
   extractCSymbols,
+  extractCudaSymbols,
   extractDartSymbols,
   extractElixirSymbols,
+  extractErlangSymbols,
+  extractFSharpSymbols,
+  extractGleamSymbols,
   extractGoSymbols,
+  extractGroovySymbols,
   extractHaskellSymbols,
   extractHCLSymbols,
   extractJavaSymbols,
+  extractJuliaSymbols,
   extractKotlinSymbols,
   extractLuaSymbols,
+  extractObjCSymbols,
   extractOCamlSymbols,
   extractPHPSymbols,
   extractPythonSymbols,
+  extractRSymbols,
   extractRubySymbols,
   extractRustSymbols,
   extractScalaSymbols,
+  extractSoliditySymbols,
   extractSwiftSymbols,
   extractSymbols,
+  extractVerilogSymbols,
   extractZigSymbols,
 } from '../extractors/index.js';
 
 import {
   extractBashSymbols,
+  extractClojureSymbols,
   extractCppSymbols,
   extractCSharpSymbols,
   extractCSymbols,
+  extractCudaSymbols,
   extractDartSymbols,
   extractElixirSymbols,
+  extractErlangSymbols,
+  extractFSharpSymbols,
+  extractGleamSymbols,
   extractGoSymbols,
+  extractGroovySymbols,
   extractHaskellSymbols,
   extractHCLSymbols,
   extractJavaSymbols,
+  extractJuliaSymbols,
   extractKotlinSymbols,
   extractLuaSymbols,
+  extractObjCSymbols,
   extractOCamlSymbols,
   extractPHPSymbols,
   extractPythonSymbols,
+  extractRSymbols,
   extractRubySymbols,
   extractRustSymbols,
   extractScalaSymbols,
+  extractSoliditySymbols,
   extractSwiftSymbols,
   extractSymbols,
+  extractVerilogSymbols,
   extractZigSymbols,
 } from '../extractors/index.js';
 
@@ -171,39 +193,27 @@ export async function createParsers(): Promise<Map<string, Parser | null>> {
  * Call this between repeated builds in the same process (e.g. benchmarks)
  * to prevent memory accumulation that can cause segfaults.
  */
-export function disposeParsers(): void {
-  if (_cachedParsers) {
-    for (const [id, parser] of _cachedParsers) {
-      if (parser && typeof parser.delete === 'function') {
-        try {
-          parser.delete();
-        } catch (e: unknown) {
-          debug(`Failed to dispose parser ${id}: ${(e as Error).message}`);
-        }
-      }
-    }
-    _cachedParsers = null;
-  }
-  for (const [id, query] of _queryCache) {
-    if (query && typeof query.delete === 'function') {
+function disposeMapEntries(entries: Iterable<[string, any]>, label: string): void {
+  for (const [id, item] of entries) {
+    if (item && typeof item.delete === 'function') {
       try {
-        query.delete();
+        item.delete();
       } catch (e: unknown) {
-        debug(`Failed to dispose query ${id}: ${(e as Error).message}`);
+        debug(`Failed to dispose ${label} ${id}: ${(e as Error).message}`);
       }
     }
   }
+}
+
+export function disposeParsers(): void {
+  if (_cachedParsers) {
+    disposeMapEntries(_cachedParsers, 'parser');
+    _cachedParsers = null;
+  }
+  disposeMapEntries(_queryCache, 'query');
   _queryCache.clear();
   if (_cachedLanguages) {
-    for (const [id, lang] of _cachedLanguages) {
-      if (lang && typeof (lang as any).delete === 'function') {
-        try {
-          (lang as any).delete();
-        } catch (e: unknown) {
-          debug(`Failed to dispose language ${id}: ${(e as Error).message}`);
-        }
-      }
-    }
+    disposeMapEntries(_cachedLanguages, 'language');
     _cachedLanguages = null;
   }
   _initialized = false;
@@ -529,11 +539,95 @@ export const LANGUAGE_REGISTRY: LanguageRegistryEntry[] = [
   },
   {
     id: 'ocaml',
-    extensions: ['.ml', '.mli'],
+    extensions: ['.ml'],
     grammarFile: 'tree-sitter-ocaml.wasm',
     extractor: extractOCamlSymbols,
     required: false,
   },
+  {
+    id: 'ocaml-interface',
+    extensions: ['.mli'],
+    grammarFile: 'tree-sitter-ocaml_interface.wasm',
+    extractor: extractOCamlSymbols,
+    required: false,
+  },
+  {
+    id: 'fsharp',
+    extensions: ['.fs', '.fsx', '.fsi'],
+    grammarFile: 'tree-sitter-fsharp.wasm',
+    extractor: extractFSharpSymbols,
+    required: false,
+  },
+  {
+    id: 'gleam',
+    extensions: ['.gleam'],
+    grammarFile: 'tree-sitter-gleam.wasm',
+    extractor: extractGleamSymbols,
+    required: false,
+  },
+  {
+    id: 'clojure',
+    extensions: ['.clj', '.cljs', '.cljc'],
+    grammarFile: 'tree-sitter-clojure.wasm',
+    extractor: extractClojureSymbols,
+    required: false,
+  },
+  {
+    id: 'julia',
+    extensions: ['.jl'],
+    grammarFile: 'tree-sitter-julia.wasm',
+    extractor: extractJuliaSymbols,
+    required: false,
+  },
+  {
+    id: 'r',
+    extensions: ['.r', '.R'],
+    grammarFile: 'tree-sitter-r.wasm',
+    extractor: extractRSymbols,
+    required: false,
+  },
+  {
+    id: 'erlang',
+    extensions: ['.erl', '.hrl'],
+    grammarFile: 'tree-sitter-erlang.wasm',
+    extractor: extractErlangSymbols,
+    required: false,
+  },
+  {
+    id: 'solidity',
+    extensions: ['.sol'],
+    grammarFile: 'tree-sitter-solidity.wasm',
+    extractor: extractSoliditySymbols,
+    required: false,
+  },
+  {
+    id: 'objc',
+    extensions: ['.m'],
+    grammarFile: 'tree-sitter-objc.wasm',
+    extractor: extractObjCSymbols,
+    required: false,
+  },
+  {
+    id: 'cuda',
+    extensions: ['.cu', '.cuh'],
+    grammarFile: 'tree-sitter-cuda.wasm',
+    extractor: extractCudaSymbols,
+    required: false,
+  },
+  {
+    id: 'groovy',
+    extensions: ['.groovy', '.gvy'],
+    grammarFile: 'tree-sitter-groovy.wasm',
+    extractor: extractGroovySymbols,
+    required: false,
+  },
+  {
+    id: 'verilog',
+    extensions: ['.v', '.sv'],
+    grammarFile: 'tree-sitter-verilog.wasm',
+    extractor: extractVerilogSymbols,
+    required: false,
+  },
 ];
 
 const _extToLang: Map<string, LanguageRegistryEntry> = new Map();
@@ -766,7 +860,7 @@ export function getActiveEngine(opts: ParseEngineOpts = {}): {
  */
 export function createParseTreeCache(): any {
   const native = loadNative();
-  if (!native || !native.ParseTreeCache) return null;
+  if (!native?.ParseTreeCache) return null;
   return new native.ParseTreeCache();
 }
 

package/src/domain/search/generator.ts

@@ -100,7 +100,7 @@ export async function buildEmbeddings(
   let overflowCount = 0;
 
   for (const [file, fileNodes] of byFile) {
-    const fullPath = path.join(rootDir, file);
+    const fullPath = path.isAbsolute(file) ? file : path.join(rootDir, file);
     let lines: string[];
     try {
       lines = fs.readFileSync(fullPath, 'utf-8').split('\n');

package/src/domain/search/models.ts

@@ -96,13 +96,26 @@ export function getModelConfig(modelKey?: string): ModelConfig {
 }
 
 /**
- * Prompt the user to install a missing package interactively.
+ * Attempt to install a missing package.
+ * In TTY environments, prompts the user for confirmation first.
+ * In non-TTY environments (CI, piped stdin), installs automatically with a log message.
  * Returns true if the package was installed, false otherwise.
- * Skips the prompt entirely in non-TTY environments (CI, piped stdin).
  * @internal Not part of the public barrel.
  */
 export function promptInstall(packageName: string): Promise<boolean> {
-  if (!process.stdin.isTTY) return Promise.resolve(false);
+  if (!process.stdin.isTTY) {
+    info(`Installing ${packageName} (optional dependency for semantic search)…`);
+    try {
+      execFileSync('npm', ['install', '--no-save', packageName], {
+        stdio: 'inherit',
+        timeout: 300_000,
+      });
+      return Promise.resolve(true);
+    } catch (err) {
+      info(`Auto-install failed: ${err instanceof Error ? err.message : String(err)}`);
+      return Promise.resolve(false);
+    }
+  }
 
   return new Promise((resolve) => {
     const rl = createInterface({ input: process.stdin, output: process.stderr });
@@ -128,7 +141,7 @@ export function promptInstall(packageName: string): Promise<boolean> {
 /**
  * Lazy-load @huggingface/transformers.
  * If the package is missing, prompts the user to install it interactively.
- * In non-TTY environments, prints an error and exits.
+ * In non-TTY environments, attempts automatic installation.
  * @internal Not part of the public barrel.
  */
 export async function loadTransformers(): Promise<unknown> {