Merge main into docs/claude-code-architecture-analysis

Author: carlos-alm

Cargo.lock

@@ -117,8 +117,16 @@ pub fn run_pipeline(
 
     // ── Stage 2: Collect files ─────────────────────────────────────────
     let t0 = Instant::now();
+    // For scoped builds, track all scoped relative paths (including deleted files)
+    // so detect_removed_files only flags scoped files as removed, not everything.
+    let scoped_rel_paths: Option<HashSet<String>> = opts.scope.as_ref().map(|scope| {
+        scope
+            .iter()
+            .map(|f| normalize_path(f))
+            .collect()
+    });
     let collect_result = if let Some(ref scope) = opts.scope {
-        // Scoped rebuild
+        // Scoped rebuild — only collect files that exist on disk
         let files: Vec<String> = scope
             .iter()
             .map(|f| {
@@ -179,6 +187,7 @@ pub fn run_pipeline(
         root_dir,
         incremental,
         force_full_rebuild,
+        scoped_rel_paths.as_ref(),
     );
     timing.detect_ms = t0.elapsed().as_secs_f64() * 1000.0;
 
@@ -292,7 +301,8 @@ pub fn run_pipeline(
     let mut batch_inputs: Vec<ImportResolutionInput> = Vec::new();
     for (rel_path, symbols) in &file_symbols {
         let abs_file = Path::new(root_dir).join(rel_path);
-        let abs_str = abs_file.to_str().unwrap_or("").to_string();
+        // Normalize to forward slashes so batch_resolved keys match Stage 6b lookups on Windows.
+        let abs_str = abs_file.to_str().unwrap_or("").replace('\\', "/");
         for imp in &symbols.imports {
             batch_inputs.push(ImportResolutionInput {
                 from_file: abs_str.clone(),
@@ -416,8 +426,9 @@ pub fn run_pipeline(
                     rusqlite::params![&rel],
                 );
                 // Re-resolve imports for the barrel file
+                // Normalize to forward slashes so batch_resolved keys match get_resolved lookups on Windows.
                 let abs_str =
-                    Path::new(root_dir).join(&rel).to_str().unwrap_or("").to_string();
+                    Path::new(root_dir).join(&rel).to_str().unwrap_or("").replace('\\', "/");
                 for imp in &sym.imports {
                     let input = ImportResolutionInput {
                         from_file: abs_str.clone(),
@@ -549,7 +560,7 @@ pub fn run_pipeline(
 
     // Persist build metadata
     let version = env!("CARGO_PKG_VERSION");
-    let meta_sql = "INSERT OR REPLACE INTO metadata (key, value) VALUES (?, ?)";
+    let meta_sql = "INSERT OR REPLACE INTO build_meta (key, value) VALUES (?, ?)";
     if let Ok(mut stmt) = conn.prepare(meta_sql) {
         let _ = stmt.execute(["engine", "native"]);
         let _ = stmt.execute(["engine_version", version]);
@@ -593,7 +604,7 @@ pub fn run_pipeline(
 /// Check if engine/schema/version changed since last build (forces full rebuild).
 fn check_version_mismatch(conn: &Connection) -> bool {
     let get_meta = |key: &str| -> Option<String> {
-        conn.query_row("SELECT value FROM metadata WHERE key = ?", [key], |row| {
+        conn.query_row("SELECT value FROM build_meta WHERE key = ?", [key], |row| {
             row.get(0)
         })
         .ok()

crates/codegraph-core/src/build_pipeline.rs

@@ -125,10 +125,15 @@ fn load_file_hashes(conn: &Connection) -> Option<HashMap<String, FileHashRow>> {
 }
 
 /// Detect removed files: files in DB but not in current file list.
+///
+/// When `scoped_rel_paths` is provided (scoped rebuild), only files within that
+/// scope are considered candidates for removal. Without it, all DB files not
+/// found on disk are treated as removed.
 fn detect_removed_files(
     existing: &HashMap<String, FileHashRow>,
     all_files: &[String],
     root_dir: &str,
+    scoped_rel_paths: Option<&HashSet<String>>,
 ) -> Vec<String> {
     let current: HashSet<String> = all_files
         .iter()
@@ -137,7 +142,14 @@ fn detect_removed_files(
 
     existing
         .keys()
-        .filter(|f| !current.contains(*f))
+        .filter(|f| {
+            // When scope is set, only consider files within scope as candidates.
+            if let Some(scope) = scoped_rel_paths {
+                scope.contains(*f) && !current.contains(*f)
+            } else {
+                !current.contains(*f)
+            }
+        })
         .cloned()
         .collect()
 }
@@ -371,6 +383,10 @@ pub fn find_reverse_dependencies(
 }
 
 /// Purge graph data for changed/removed files and delete outgoing edges for reverse deps.
+///
+/// Deletion order: analysis dependents → edges → nodes (matches `native_db::purge_files_data`).
+/// Analysis tables use join-based queries (node_id IN SELECT id FROM nodes) because they
+/// reference nodes by ID, not by file path directly.
 pub fn purge_changed_files(
     conn: &Connection,
     files_to_purge: &[String],
@@ -385,48 +401,36 @@ pub fn purge_changed_files(
         Err(_) => return,
     };
 
-    // Purge nodes and edges for changed/removed files
-    if !files_to_purge.is_empty() {
-        // Delete edges where source or target is in the purged files
-        if let Ok(mut stmt) =
-            tx.prepare("DELETE FROM edges WHERE source_id IN (SELECT id FROM nodes WHERE file = ?)")
-        {
-            for f in files_to_purge {
-                let _ = stmt.execute([f]);
-            }
-        }
-        if let Ok(mut stmt) =
-            tx.prepare("DELETE FROM edges WHERE target_id IN (SELECT id FROM nodes WHERE file = ?)")
-        {
-            for f in files_to_purge {
-                let _ = stmt.execute([f]);
-            }
-        }
-        // Delete nodes
-        if let Ok(mut stmt) = tx.prepare("DELETE FROM nodes WHERE file = ?") {
-            for f in files_to_purge {
-                let _ = stmt.execute([f]);
-            }
-        }
-        // Delete analysis data
-        for table in &[
-            "function_complexity",
-            "cfg_blocks",
-            "cfg_edges",
-            "dataflow",
-            "ast_nodes",
-            "node_metrics",
-        ] {
-            let sql = format!("DELETE FROM {table} WHERE file = ?");
-            if let Ok(mut stmt) = tx.prepare(&sql) {
-                for f in files_to_purge {
-                    let _ = stmt.execute([f]);
+    // Purge each file across all tables. Optional tables are silently skipped
+    // if they don't exist. Order: analysis dependents → edges → nodes.
+    let purge_sql: &[(&str, bool)] = &[
+        // Analysis tables (optional — may not exist)
+        ("DELETE FROM embeddings WHERE node_id IN (SELECT id FROM nodes WHERE file = ?1)", false),
+        ("DELETE FROM cfg_edges WHERE function_node_id IN (SELECT id FROM nodes WHERE file = ?1)", false),
+        ("DELETE FROM cfg_blocks WHERE function_node_id IN (SELECT id FROM nodes WHERE file = ?1)", false),
+        ("DELETE FROM dataflow WHERE source_id IN (SELECT id FROM nodes WHERE file = ?1) OR target_id IN (SELECT id FROM nodes WHERE file = ?1)", false),
+        ("DELETE FROM function_complexity WHERE node_id IN (SELECT id FROM nodes WHERE file = ?1)", false),
+        ("DELETE FROM node_metrics WHERE node_id IN (SELECT id FROM nodes WHERE file = ?1)", false),
+        ("DELETE FROM ast_nodes WHERE file = ?1", false),
+        // Core tables (errors logged)
+        ("DELETE FROM edges WHERE source_id IN (SELECT id FROM nodes WHERE file = ?1) OR target_id IN (SELECT id FROM nodes WHERE file = ?1)", true),
+        ("DELETE FROM nodes WHERE file = ?1", true),
+    ];
+
+    for file in files_to_purge {
+        for &(sql, required) in purge_sql {
+            match tx.execute(sql, rusqlite::params![file]) {
+                Ok(_) => {}
+                Err(e) if required => {
+                    eprintln!("[codegraph] purge failed for \"{file}\": {e}");
                 }
+                Err(_) => {} // optional table missing — skip
             }
         }
     }
 
-    // Delete outgoing edges for reverse-dep files (they'll be re-built)
+    // Delete outgoing edges for reverse-dep files (they'll be re-built).
+    // These files keep their nodes but need outgoing edges rebuilt.
     if !reverse_dep_files.is_empty() {
         if let Ok(mut stmt) =
             tx.prepare("DELETE FROM edges WHERE source_id IN (SELECT id FROM nodes WHERE file = ?)")
@@ -487,12 +491,16 @@ pub fn heal_metadata(conn: &Connection, updates: &[MetadataUpdate]) {
 /// Main entry point: detect changes using the tiered strategy.
 ///
 /// Returns `None` for full builds (no file_hashes table or force flag).
+///
+/// When `scoped_rel_paths` is provided, removal detection is limited to files
+/// within that scope — non-scoped files in the DB are left untouched.
 pub fn detect_changes(
     conn: &Connection,
     all_files: &[String],
     root_dir: &str,
     incremental: bool,
     force_full_rebuild: bool,
+    scoped_rel_paths: Option<&HashSet<String>>,
 ) -> ChangeResult {
     if !incremental || force_full_rebuild {
         return ChangeResult {
@@ -539,7 +547,7 @@ pub fn detect_changes(
         }
     };
 
-    let removed = detect_removed_files(&existing, all_files, root_dir);
+    let removed = detect_removed_files(&existing, all_files, root_dir, scoped_rel_paths);
 
     // Try Tier 0 (journal) first
     if let Some(result) = try_journal_tier(conn, &existing, root_dir, &removed) {
@@ -597,7 +605,7 @@ mod tests {
         );
 
         let all_files = vec!["/project/src/a.ts".to_string()];
-        let removed = detect_removed_files(&existing, &all_files, "/project");
+        let removed = detect_removed_files(&existing, &all_files, "/project", None);
         assert_eq!(removed, vec!["src/b.ts"]);
     }
 }

crates/codegraph-core/src/change_detection.rs

@@ -50,7 +50,9 @@ pub struct EdgeRow {
 impl ImportEdgeContext {
     /// Resolve an import source to a relative path, using batch cache first.
     pub fn get_resolved(&self, abs_file: &str, import_source: &str) -> String {
-        let key = format!("{abs_file}|{import_source}");
+        // Normalize to forward slashes so cache keys match across platforms (#826).
+        let normalized = abs_file.replace('\\', "/");
+        let key = format!("{normalized}|{import_source}");
         if let Some(hit) = self.batch_resolved.get(&key) {
             return hit.clone();
         }

crates/codegraph-core/src/import_edges.rs

@@ -271,7 +271,7 @@ interface NativeOrchestratorResult {
 function shouldSkipNativeOrchestrator(ctx: PipelineContext): string | null {
   if (process.env.CODEGRAPH_FORCE_JS_PIPELINE === '1') return 'CODEGRAPH_FORCE_JS_PIPELINE=1';
   if (ctx.forceFullRebuild) return 'forceFullRebuild';
-  const orchestratorBuggy = !!ctx.engineVersion && semverCompare(ctx.engineVersion, '3.8.1') <= 0;
+  const orchestratorBuggy = !!ctx.engineVersion && semverCompare(ctx.engineVersion, '3.9.0') <= 0;
   if (orchestratorBuggy) return `buggy addon ${ctx.engineVersion}`;
   if (ctx.engineName !== 'native') return `engine=${ctx.engineName}`;
   return null;