fix: run analysis phases after native Rust build orchestrator (#757)

* fix: run analysis phases after native Rust build orchestrator

The native Rust orchestrator early-returned with hardcoded 0ms for AST,
complexity, CFG, and dataflow phases — meaning these analyses were never
computed during native builds. After the orchestrator completes, reconstruct
a minimal fileSymbols map from the DB and run analyses via the JS engine
(native standalone functions + WASM fallback) with proper WAL handoff.

* fix: address review feedback for native analysis phases (#757)

- Scope analysis SQL query to changed files for incremental builds by
  returning changedFiles from the Rust build pipeline result (P1)
- Guard against openDb failure leaving ctx.db as a stale closed handle
  by nullifying before reopen (P1)
- Clear ctx.engineOpts.nativeDb after analysis nativeDb cleanup,
  matching the pattern used in runPipelineStages (P2)

* fix: add missing changed_files field to early-exit BuildPipelineResult (#757)

The Rust struct gained a changed_files field but the early-exit
return path was not updated, causing a compile error on all platforms.

* fix: handle openDb failure after native build with clear error (#757)

If openDb throws after the native build succeeds, return a partial
result (with 0ms analysis timings) instead of falling through to the
JS pipeline with ctx.db = null, which would cause a confusing
secondary error. Addresses Greptile P2 feedback.

* fix: guard against empty changedFiles array in SQL query (#757)

An empty changedFiles array is truthy in JavaScript, so the previous
`if (changedFiles)` guard would pass and generate invalid SQL
`IN ()` which SQLite rejects. Check `.length > 0` as well so empty
arrays fall through to the full-table scan, matching the correct
behavior for deletion-only incremental builds.

Author: carlos-alm

crates/codegraph-core/src/build_pipeline.rs

@@ -57,6 +57,10 @@ pub struct BuildPipelineResult {
     pub edge_count: i64,
     pub file_count: usize,
     pub early_exit: bool,
+    /// Files that were parsed/changed in this build cycle.
+    /// `None` for full builds (all files), `Some` for incremental builds.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub changed_files: Option<Vec<String>>,
     pub changed_count: usize,
     pub removed_count: usize,
     pub is_full_build: bool,
@@ -194,6 +198,7 @@ pub fn run_pipeline(
             edge_count: 0,
             file_count: collect_result.files.len(),
             early_exit: true,
+            changed_files: Some(vec![]),
             changed_count: 0,
             removed_count: 0,
             is_full_build: false,
@@ -342,6 +347,12 @@ pub fn run_pipeline(
     let t0 = Instant::now();
     let line_count_map = structure::build_line_count_map(&file_symbols, root_dir);
     let changed_files: Vec<String> = file_symbols.keys().cloned().collect();
+    // Keep a copy for the result — changed_files is moved into roles classification below.
+    let analysis_scope: Option<Vec<String>> = if change_result.is_full_build {
+        None
+    } else {
+        Some(changed_files.clone())
+    };
 
     let existing_file_count = structure::get_existing_file_count(conn);
     // Use parse_changes.len() for the threshold — changed_files includes
@@ -433,6 +444,7 @@ pub fn run_pipeline(
         edge_count,
         file_count: collect_result.files.len(),
         early_exit: false,
+        changed_files: analysis_scope,
         changed_count: parse_changes.len(),
         removed_count: change_result.removed.len(),
         is_full_build: change_result.is_full_build,

src/domain/graph/builder/pipeline.ts

@@ -19,7 +19,7 @@ import { debug, info, warn } from '../../../infrastructure/logger.js';
 import { loadNative } from '../../../infrastructure/native.js';
 import { semverCompare } from '../../../infrastructure/update-check.js';
 import { CODEGRAPH_VERSION } from '../../../shared/version.js';
-import type { BuildGraphOpts, BuildResult } from '../../../types.js';
+import type { BuildGraphOpts, BuildResult, Definition, ExtractorOutput } from '../../../types.js';
 import { getActiveEngine } from '../../parser.js';
 import { setWorkspaces } from '../resolve.js';
 import { PipelineContext } from './context.js';
@@ -381,6 +381,7 @@ export async function buildGraph(
           nodeCount?: number;
           edgeCount?: number;
           fileCount?: number;
+          changedFiles?: string[];
           changedCount?: number;
           removedCount?: number;
           isFullBuild?: boolean;
@@ -419,10 +420,154 @@ export async function buildGraph(
           edge_count: String(result.edgeCount ?? 0),
         });
 
-        closeDbPair({ db: ctx.db, nativeDb: ctx.nativeDb });
         info(
           `Native build orchestrator completed: ${result.nodeCount ?? 0} nodes, ${result.edgeCount ?? 0} edges, ${result.fileCount ?? 0} files`,
         );
+
+        // ── Run analysis phases (AST, complexity, CFG, dataflow) ──────
+        // Not yet ported to Rust. After the native orchestrator finishes,
+        // reconstruct a minimal fileSymbols map from the DB and run analyses
+        // via the JS engine (native standalone functions + WASM fallback).
+        let analysisTiming = { astMs: 0, complexityMs: 0, cfgMs: 0, dataflowMs: 0 };
+        const needsAnalysis =
+          opts.ast !== false ||
+          opts.complexity !== false ||
+          opts.cfg !== false ||
+          opts.dataflow !== false;
+
+        if (needsAnalysis) {
+          // WAL handoff: checkpoint through rusqlite, close nativeDb,
+          // reopen better-sqlite3 with a fresh page cache (#715, #736).
+          try {
+            ctx.nativeDb!.exec('PRAGMA wal_checkpoint(TRUNCATE)');
+          } catch {
+            /* ignore checkpoint errors */
+          }
+          try {
+            ctx.nativeDb!.close();
+          } catch {
+            /* ignore close errors */
+          }
+          ctx.nativeDb = undefined;
+          try {
+            ctx.db.close();
+          } catch {
+            /* ignore close errors */
+          }
+          ctx.db = null!; // avoid closeDbPair operating on a stale handle
+          try {
+            ctx.db = openDb(ctx.dbPath);
+          } catch (reopenErr) {
+            warn(
+              `Failed to reopen DB for analysis after native build: ${(reopenErr as Error).message}`,
+            );
+            // Native build succeeded but we can't run analyses — return partial result
+            return {
+              phases: {
+                setupMs: +((p.setupMs ?? 0) + (p.collectMs ?? 0) + (p.detectMs ?? 0)).toFixed(1),
+                parseMs: +(p.parseMs ?? 0).toFixed(1),
+                insertMs: +(p.insertMs ?? 0).toFixed(1),
+                resolveMs: +(p.resolveMs ?? 0).toFixed(1),
+                edgesMs: +(p.edgesMs ?? 0).toFixed(1),
+                structureMs: +(p.structureMs ?? 0).toFixed(1),
+                rolesMs: +(p.rolesMs ?? 0).toFixed(1),
+                astMs: 0,
+                complexityMs: 0,
+                cfgMs: 0,
+                dataflowMs: 0,
+                finalizeMs: +(p.finalizeMs ?? 0).toFixed(1),
+              },
+            };
+          }
+
+          // Reconstruct minimal fileSymbols from DB for analysis visitors.
+          // Each entry needs definitions with name/kind/line/endLine so the
+          // engine can match complexity/CFG results to the right functions.
+          // For incremental builds, scope to only the files that were parsed
+          // in this cycle (matching the JS pipeline's behaviour in run-analyses.ts).
+          const changedFiles = result.changedFiles;
+          let query =
+            'SELECT file, name, kind, line, end_line as endLine FROM nodes WHERE file IS NOT NULL';
+          const params: string[] = [];
+          if (changedFiles && changedFiles.length > 0) {
+            const placeholders = changedFiles.map(() => '?').join(',');
+            query += ` AND file IN (${placeholders})`;
+            params.push(...changedFiles);
+          }
+          query += ' ORDER BY file, line';
+          const rows = ctx.db.prepare(query).all(...params) as {
+            file: string;
+            name: string;
+            kind: string;
+            line: number;
+            endLine: number | null;
+          }[];
+
+          const fileSymbols = new Map<string, ExtractorOutput>();
+          for (const row of rows) {
+            let entry = fileSymbols.get(row.file);
+            if (!entry) {
+              entry = {
+                definitions: [],
+                calls: [],
+                imports: [],
+                classes: [],
+                exports: [],
+                typeMap: new Map(),
+              };
+              fileSymbols.set(row.file, entry);
+            }
+            entry.definitions.push({
+              name: row.name,
+              kind: row.kind as Definition['kind'],
+              line: row.line,
+              endLine: row.endLine ?? undefined,
+            });
+          }
+
+          // Reopen nativeDb for analysis features (suspend/resume WAL pattern).
+          const native = loadNative();
+          if (native?.NativeDatabase) {
+            try {
+              ctx.nativeDb = native.NativeDatabase.openReadWrite(ctx.dbPath);
+              if (ctx.engineOpts) ctx.engineOpts.nativeDb = ctx.nativeDb;
+            } catch {
+              ctx.nativeDb = undefined;
+              if (ctx.engineOpts) ctx.engineOpts.nativeDb = undefined;
+            }
+          }
+
+          try {
+            const { runAnalyses: runAnalysesFn } = await import('../../../ast-analysis/engine.js');
+            analysisTiming = await runAnalysesFn(
+              ctx.db,
+              fileSymbols,
+              ctx.rootDir,
+              opts,
+              ctx.engineOpts,
+            );
+          } catch (err) {
+            warn(`Analysis phases failed after native build: ${(err as Error).message}`);
+          }
+
+          // Close nativeDb after analyses
+          if (ctx.nativeDb) {
+            try {
+              ctx.nativeDb.exec('PRAGMA wal_checkpoint(TRUNCATE)');
+            } catch {
+              /* ignore checkpoint errors */
+            }
+            try {
+              ctx.nativeDb.close();
+            } catch {
+              /* ignore close errors */
+            }
+            ctx.nativeDb = undefined;
+            if (ctx.engineOpts) ctx.engineOpts.nativeDb = undefined;
+          }
+        }
+
+        closeDbPair({ db: ctx.db, nativeDb: ctx.nativeDb });
         return {
           phases: {
             setupMs: +((p.setupMs ?? 0) + (p.collectMs ?? 0) + (p.detectMs ?? 0)).toFixed(1),
@@ -432,10 +577,10 @@ export async function buildGraph(
             edgesMs: +(p.edgesMs ?? 0).toFixed(1),
             structureMs: +(p.structureMs ?? 0).toFixed(1),
             rolesMs: +(p.rolesMs ?? 0).toFixed(1),
-            astMs: 0,
-            complexityMs: 0,
-            cfgMs: 0,
-            dataflowMs: 0,
+            astMs: +(analysisTiming.astMs ?? 0).toFixed(1),
+            complexityMs: +(analysisTiming.complexityMs ?? 0).toFixed(1),
+            cfgMs: +(analysisTiming.cfgMs ?? 0).toFixed(1),
+            dataflowMs: +(analysisTiming.dataflowMs ?? 0).toFixed(1),
             finalizeMs: +(p.finalizeMs ?? 0).toFixed(1),
           },
         };