@optave/codegraph 3.9.6 → 3.11.0

package/src/ast-analysis/visitors/ast-store-visitor.ts

@@ -131,6 +131,21 @@ function extractChildExpressionText(node: TreeSitterNode): string | null {
   return truncate(node.text);
 }
 
+/**
+ * Count code points cheaply: skip the `[...s]` spread when `s.length` already
+ * decides the answer. Each code point is 1 or 2 UTF-16 units, so `.length < 2`
+ * implies `< 2` code points and `.length >= 3` already guarantees `>= 2` code
+ * points (worst case: one surrogate pair + one BMP char = 2 code points).
+ * Only `.length === 2` is genuinely ambiguous (could be a single surrogate
+ * pair = 1 code point, or two BMP chars = 2 code points) and needs the spread.
+ */
+function codePointCountAtLeast2(s: string): boolean {
+  const len = s.length;
+  if (len < 2) return false;
+  if (len >= 3) return true;
+  return [...s].length >= 2;
+}
+
 /**
  * Extract string content from a string-literal node, mirroring the native
  * engine's `build_string_node` (`helpers.rs`). Returns `null` when the
@@ -142,15 +157,27 @@ function extractStringContent(node: TreeSitterNode, cfg: AstStringConfig): strin
 
   let s = raw;
   s = trimLeadingChars(s, '@');
-  s = trimLeadingChars(s, cfg.stringPrefixes);
+  if (cfg.stringPrefixes) s = trimLeadingChars(s, cfg.stringPrefixes);
   if (isRawString) s = trimLeadingChars(s, 'r#');
   s = trimLeadingChars(s, cfg.quoteChars);
   if (isRawString) s = trimTrailingChars(s, '#');
   s = trimTrailingChars(s, cfg.quoteChars);
 
-  // Count code points, not UTF-16 code units — matches Rust `chars().count()`.
-  const codePointCount = [...s].length;
-  if (codePointCount < 2) return null;
+  return codePointCountAtLeast2(s) ? s : null;
+}
+
+// Per-astTypeMap cache for the set of node-types that map to kind 'new'.
+// Computed once per unique astTypeMap reference (one per language) instead
+// of once per file.
+const _newTypesCache = new WeakMap<Record<string, string>, Set<string>>();
+function newTypesFor(astTypeMap: Record<string, string>): Set<string> {
+  let s = _newTypesCache.get(astTypeMap);
+  if (s) return s;
+  s = new Set<string>();
+  for (const type in astTypeMap) {
+    if (astTypeMap[type] === 'new') s.add(type);
+  }
+  _newTypesCache.set(astTypeMap, s);
   return s;
 }
 
@@ -164,11 +191,12 @@ export function createAstStoreVisitor(
 ): Visitor {
   const rows: AstStoreRow[] = [];
   const matched = new Set<number>();
-  const newTypes = new Set<string>(
-    Object.entries(astTypeMap)
-      .filter(([, kind]) => kind === 'new')
-      .map(([type]) => type),
-  );
+  const newTypes = newTypesFor(astTypeMap);
+  // When nodeIdMap is empty, parentNodeId resolution is wasted work — the
+  // worker passes an empty map and the main thread re-resolves against its
+  // own DB-populated map in features/ast.ts::collectFileAstRows. Skip the
+  // findParentDef linear scan in that case.
+  const skipParentLookup = nodeIdMap.size === 0;
 
   function findParentDef(line: number): Definition | null {
     let best: Definition | null = null;
@@ -183,6 +211,7 @@ export function createAstStoreVisitor(
   }
 
   function resolveParentNodeId(line: number): number | null {
+    if (skipParentLookup) return null;
     const parentDef = findParentDef(line);
     if (!parentDef) return null;
     return nodeIdMap.get(`${parentDef.name}|${parentDef.kind}|${parentDef.line}`) || null;
@@ -240,6 +269,13 @@ export function createAstStoreVisitor(
       // unrelated subtree. The parent call's skipChildren handles the intended case.
       if (matched.has(node.id)) return;
 
+      // Gate with `hasOwn` because plain-object lookup walks Object.prototype:
+      // tree-sitter node types like `constructor` (Haskell sum-types: Left,
+      // Right) would otherwise resolve to `Object.prototype.constructor` (the
+      // Object() function), which then crashes the worker boundary with
+      // "function Object() { [native code] } could not be cloned" when the
+      // resulting astNodes row is structured-cloned back to the main thread.
+      if (!Object.hasOwn(astTypeMap, node.type)) return;
       const kind = astTypeMap[node.type];
       if (!kind) return;
 

package/src/cli/commands/audit.ts

@@ -17,7 +17,7 @@ export const command: CommandDefinition = {
     ['-T, --no-tests', 'Exclude test/spec files from results'],
     ['--include-tests', 'Include test/spec files (overrides excludeTests config)'],
     ['-j, --json', 'Output as JSON'],
-    ['--limit <number>', 'Max results to return (quick mode)'],
+    ['-n, --limit <number>', 'Max results to return (quick mode)'],
     ['--offset <number>', 'Skip N results (quick mode)'],
     ['--ndjson', 'Newline-delimited JSON output (quick mode)'],
   ],

package/src/cli/commands/build.ts

@@ -7,6 +7,7 @@ export const command: CommandDefinition = {
   name: 'build [dir]',
   description: 'Parse repo and build graph in .codegraph/graph.db',
   options: [
+    ['-d, --db <path>', 'Path to graph.db (default: <dir>/.codegraph/graph.db)'],
     ['--no-incremental', 'Force full rebuild (ignore file hashes)'],
     ['--no-ast', 'Skip AST node extraction (calls, new, string, regex, throw, await)'],
     ['--no-complexity', 'Skip complexity metrics computation'],
@@ -23,6 +24,7 @@ export const command: CommandDefinition = {
       engine: engine as EngineMode,
       dataflow: opts.dataflow as boolean,
       cfg: opts.cfg as boolean,
+      dbPath: opts.db ? path.resolve(opts.db as string) : undefined,
     });
   },
 };

package/src/cli/commands/check.ts

@@ -38,7 +38,7 @@ export const command: CommandDefinition = {
     ['-T, --no-tests', 'Exclude test/spec files from results'],
     ['--include-tests', 'Include test/spec files (overrides excludeTests config)'],
     ['-j, --json', 'Output as JSON'],
-    ['--limit <number>', 'Max results to return (manifesto mode)'],
+    ['-n, --limit <number>', 'Max results to return (manifesto mode)'],
     ['--offset <number>', 'Skip N results (manifesto mode)'],
     ['--ndjson', 'Newline-delimited JSON output (manifesto mode)'],
   ],

package/src/cli/commands/children.ts

@@ -16,7 +16,7 @@ export const command: CommandDefinition = {
     ['-k, --kind <kind>', 'Filter to a specific symbol kind'],
     ['-T, --no-tests', 'Exclude test/spec files from results'],
     ['-j, --json', 'Output as JSON'],
-    ['--limit <number>', 'Max results to return'],
+    ['-n, --limit <number>', 'Max results to return'],
     ['--offset <number>', 'Skip N results (default: 0)'],
   ],
   validate([_name], opts) {

package/src/cli/commands/diff-impact.ts

@@ -8,7 +8,7 @@ export const command: CommandDefinition = {
     ['-d, --db <path>', 'Path to graph.db'],
     ['-T, --no-tests', 'Exclude test/spec files from results'],
     ['--include-tests', 'Include test/spec files (overrides excludeTests config)'],
-    ['--limit <number>', 'Max results to return'],
+    ['-n, --limit <number>', 'Max results to return'],
     ['--offset <number>', 'Skip N results (default: 0)'],
     ['--ndjson', 'Newline-delimited JSON output'],
     ['--staged', 'Analyze staged changes instead of unstaged'],

package/src/cli/commands/roles.ts

@@ -14,7 +14,7 @@ export const command: CommandDefinition = {
     ['-T, --no-tests', 'Exclude test/spec files'],
     ['--include-tests', 'Include test/spec files (overrides excludeTests config)'],
     ['-j, --json', 'Output as JSON'],
-    ['--limit <number>', 'Max results to return'],
+    ['-n, --limit <number>', 'Max results to return'],
     ['--offset <number>', 'Skip N results (default: 0)'],
     ['--ndjson', 'Newline-delimited JSON output'],
   ],

package/src/cli/commands/structure.ts

@@ -12,7 +12,7 @@ export const command: CommandDefinition = {
     ['-T, --no-tests', 'Exclude test/spec files'],
     ['--include-tests', 'Include test/spec files (overrides excludeTests config)'],
     ['-j, --json', 'Output as JSON'],
-    ['--limit <number>', 'Max results to return'],
+    ['-n, --limit <number>', 'Max results to return'],
     ['--offset <number>', 'Skip N results (default: 0)'],
     ['--ndjson', 'Newline-delimited JSON output'],
     ['--modules', 'Show module boundaries (directories with high cohesion)'],

package/src/cli/shared/options.ts

@@ -13,7 +13,7 @@ export function applyQueryOpts(cmd: Command): Command {
     .option('-T, --no-tests', 'Exclude test/spec files from results')
     .option('--include-tests', 'Include test/spec files (overrides excludeTests config)')
     .option('-j, --json', 'Output as JSON')
-    .option('--limit <number>', 'Max results to return')
+    .option('-n, --limit <number>', 'Max results to return')
     .option('--offset <number>', 'Skip N results (default: 0)')
     .option('--ndjson', 'Newline-delimited JSON output')
     .option('--table', 'Output as aligned table')

package/src/db/connection.ts

@@ -292,6 +292,14 @@ export function findDbPath(customPath?: string): string {
       debug(`findDbPath: stopped at git ceiling ${ceiling}`);
       break;
     }
+    // Outside a git repo, cwd is the first (and only) directory we'll check.
+    // Walking past it risks attaching to a stale .codegraph/ in an unrelated
+    // parent — e.g. /private/tmp/.codegraph/ leaking into every /tmp/foo/ run,
+    // or $HOME/.codegraph/ leaking into every scratch dir under $HOME.
+    if (!ceiling) {
+      debug(`findDbPath: no git ceiling, stopping at ${dir}`);
+      break;
+    }
     const parent = path.dirname(dir);
     if (parent === dir) break;
     dir = parent;

package/src/domain/graph/builder/context.ts

@@ -28,6 +28,16 @@ export class PipelineContext {
   engineOpts!: EngineOpts;
   engineName!: 'native' | 'wasm';
   engineVersion!: string | null;
+  /**
+   * The version reported by the native binary itself (CARGO_PKG_VERSION at
+   * build time), as opposed to `engineVersion` which prefers the platform
+   * package.json. The Rust orchestrator's check_version_mismatch compares
+   * `build_meta.engine_version` against CARGO_PKG_VERSION, so build_meta
+   * writes must use this value to avoid a perpetual full-rebuild loop when
+   * the binary and platform package.json drift apart (e.g., CI hot-swap
+   * via ci-install-native.mjs — #1066).
+   */
+  nativeBinaryVersion!: string | null;
   aliases!: PathAliases;
   incremental!: boolean;
   forceFullRebuild: boolean = false;

package/src/domain/graph/builder/helpers.ts

@@ -222,12 +222,17 @@ export function fileHash(content: string): string {
 }
 
 /**
- * Stat a file, returning { mtimeMs, size } or null on error.
+ * Stat a file, returning { mtime, size } or null on error.
+ *
+ * `mtime` is `Math.floor(stat.mtimeMs)` so it matches the integer column
+ * stored in the DB. Floor-once-here keeps every consumer honest: storing or
+ * comparing a non-floored `mtimeMs` against the integer DB column would cause
+ * spurious fast-skip misses on the next build.
  */
-export function fileStat(filePath: string): { mtimeMs: number; size: number } | null {
+export function fileStat(filePath: string): { mtime: number; size: number } | null {
   try {
     const s = fs.statSync(filePath);
-    return { mtimeMs: s.mtimeMs, size: s.size };
+    return { mtime: Math.floor(s.mtimeMs), size: s.size };
   } catch {
     return null;
   }

package/src/domain/graph/builder/incremental.ts

@@ -9,7 +9,7 @@
  */
 import fs from 'node:fs';
 import path from 'node:path';
-import { bulkNodeIdsByFile } from '../../../db/index.js';
+import { bulkNodeIdsByFile, purgeFileData } from '../../../db/index.js';
 import { debug, warn } from '../../../infrastructure/logger.js';
 import { normalizePath } from '../../../shared/constants.js';
 import type {
@@ -29,8 +29,6 @@ export interface IncrementalStmts {
   insertNode: { run: (...params: unknown[]) => unknown };
   insertEdge: { run: (...params: unknown[]) => unknown };
   getNodeId: { get: (...params: unknown[]) => { id: number } | undefined };
-  deleteEdgesForFile: { run: (...params: unknown[]) => unknown };
-  deleteNodes: { run: (...params: unknown[]) => unknown };
   countNodes: { get: (...params: unknown[]) => { c: number } | undefined };
   listSymbols: { all: (...params: unknown[]) => unknown[] };
   findNodeInFile: { all: (...params: unknown[]) => unknown[] };
@@ -208,40 +206,6 @@ function rebuildDirContainment(
   return 0;
 }
 
-// ── Ancillary table cleanup ────────────────────────────────────────────
-
-function purgeAncillaryData(db: BetterSqlite3Database, relPath: string): void {
-  const tryExec = (sql: string, ...args: string[]): void => {
-    try {
-      db.prepare(sql).run(...args);
-    } catch (err: unknown) {
-      if (!(err as Error | undefined)?.message?.includes('no such table')) throw err;
-    }
-  };
-  tryExec(
-    'DELETE FROM function_complexity WHERE node_id IN (SELECT id FROM nodes WHERE file = ?)',
-    relPath,
-  );
-  tryExec(
-    'DELETE FROM node_metrics WHERE node_id IN (SELECT id FROM nodes WHERE file = ?)',
-    relPath,
-  );
-  tryExec(
-    'DELETE FROM cfg_edges WHERE function_node_id IN (SELECT id FROM nodes WHERE file = ?)',
-    relPath,
-  );
-  tryExec(
-    'DELETE FROM cfg_blocks WHERE function_node_id IN (SELECT id FROM nodes WHERE file = ?)',
-    relPath,
-  );
-  tryExec(
-    'DELETE FROM dataflow WHERE source_id IN (SELECT id FROM nodes WHERE file = ?) OR target_id IN (SELECT id FROM nodes WHERE file = ?)',
-    relPath,
-    relPath,
-  );
-  tryExec('DELETE FROM ast_nodes WHERE file = ?', relPath);
-}
-
 // ── Import edge building ────────────────────────────────────────────────
 
 // Lazily-cached prepared statements for barrel resolution (avoid re-preparing in hot loops)
@@ -547,10 +511,11 @@ export async function rebuildFile(
   // Find reverse-deps BEFORE purging (edges still reference the old nodes)
   const reverseDeps = findReverseDeps(db, relPath);
 
-  // Purge ancillary tables, then edges, then nodes
-  purgeAncillaryData(db, relPath);
-  stmts.deleteEdgesForFile.run(relPath);
-  stmts.deleteNodes.run(relPath);
+  // Purge ancillary tables (incl. embeddings), edges, and nodes in one pass.
+  // Embeddings must be purged before nodes — better-sqlite3 enforces foreign
+  // keys by default, and `embeddings.node_id` references `nodes.id`. Issue #1176.
+  // `purgeHashes: false` preserves file_hashes for the next incremental build.
+  purgeFileData(db, relPath, { purgeHashes: false });
 
   if (!fs.existsSync(filePath)) {
     if (cache) (cache as { remove(p: string): void }).remove(filePath);