fix: address all 11 code review issues

- Move _walkNodes/_findChildOfType/_stripQuotes to LanguageAdapter base
  class, removing duplication across 6 adapters
- Add try/finally in parseFile to prevent WASM resource leaks on error
- Accept optional sourceCode param in parseFile; scanner now reads each
  file once (eliminates double-read and TOCTOU race)
- Build normalised path lookup Map for O(1) import resolution instead
  of O(n) linear scan per import
- Detect C++ projects and reclassify .h files as cpp when .cpp/.cc/.cxx
  files are present in the same project
- Rename misleading calls/calledBy fields to fileImports/importedBy in
  query results to accurately reflect semantics
- Extract getGitCommitHash and isEntryPoint into graph.js, eliminating
  duplication between scan and update commands
- Export buildModuleSlice from slicer.js; slice command now builds only
  the target module slice instead of generating all slices
- Unify error handling: all commands use process.exit(1) for fatal errors

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: invalid

cli/src/commands/query.js

@@ -59,8 +59,8 @@ export function registerQueryCommand(program) {
         console.log(`    File: ${result.file}`);
         console.log(`    Module: ${result.module}`);
         console.log(`    Lines: ${result.lines.start}-${result.lines.end}`);
-        if (result.calledBy.length > 0) {
-          console.log(`    Called by: ${result.calledBy.join(', ')}`);
+        if (result.importedBy.length > 0) {
+          console.log(`    Imported by: ${result.importedBy.join(', ')}`);
         }
       }
     });

cli/src/commands/scan.js

@@ -1,28 +1,8 @@
 import path from 'path';
 import { scanProject } from '../scanner.js';
-import { saveGraph, computeFileHash } from '../graph.js';
+import { saveGraph, computeFileHash, getGitCommitHash } from '../graph.js';
 import { saveSlices } from '../slicer.js';
 
-/**
- * Try to get the current git commit hash from the given directory.
- * Returns null if the directory is not a git repo or simple-git is unavailable.
- *
- * @param {string} dir - Directory to check for git.
- * @returns {Promise<string|null>} The current commit hash or null.
- */
-async function getGitCommitHash(dir) {
-  try {
-    const { simpleGit } = await import('simple-git');
-    const git = simpleGit(dir);
-    const isRepo = await git.checkIsRepo();
-    if (!isRepo) return null;
-    const log = await git.log({ maxCount: 1 });
-    return log.latest ? log.latest.hash : null;
-  } catch {
-    return null;
-  }
-}
-
 /**
  * Register the `scan` command on the given Commander program.
  *

cli/src/commands/slice.js

@@ -1,6 +1,6 @@
 import path from 'path';
 import { loadGraph } from '../graph.js';
-import { generateOverview, generateSlices, getModuleSliceWithDeps } from '../slicer.js';
+import { generateOverview, buildModuleSlice, getModuleSliceWithDeps } from '../slicer.js';
 
 /**
  * Register the `slice` command on the given Commander program.
@@ -40,13 +40,11 @@ export function registerSliceCommand(program) {
       }
 
       if (options.withDeps) {
-        // Include dependency info
         const sliceWithDeps = getModuleSliceWithDeps(graph, moduleName);
         console.log(JSON.stringify(sliceWithDeps, null, 2));
       } else {
-        // Simple module slice
-        const slices = generateSlices(graph);
-        const slice = slices[moduleName];
+        // Build only the target module's slice instead of all modules
+        const slice = buildModuleSlice(graph, moduleName, graph.modules[moduleName]);
         console.log(JSON.stringify(slice, null, 2));
       }
     });

cli/src/commands/status.js

@@ -19,8 +19,8 @@ export function registerStatusCommand(program) {
       try {
         await fs.access(outputDir);
       } catch {
-        console.log('No code graph found. Run "codegraph scan" first.');
-        return;
+        console.error('No code graph found. Run "codegraph scan" first.');
+        process.exit(1);
       }
 
       let graph, meta;
@@ -29,7 +29,7 @@ export function registerStatusCommand(program) {
         meta = await loadMeta(outputDir);
       } catch (err) {
         console.error(`Error loading code graph: ${err.message}`);
-        return;
+        process.exit(1);
       }
 
       // Print status

cli/src/commands/update.js

@@ -1,32 +1,12 @@
 import path from 'path';
 import fs from 'fs/promises';
-import { loadGraph, loadMeta, saveGraph, computeFileHash } from '../graph.js';
+import { loadGraph, loadMeta, saveGraph, computeFileHash, getGitCommitHash, isEntryPoint } from '../graph.js';
 import { traverseFiles, detectLanguage } from '../traverser.js';
 import { initParser, parseFile } from '../parser.js';
 import { detectModuleName } from '../scanner.js';
 import { detectChangedFiles, mergeGraphUpdate } from '../differ.js';
 import { saveSlices } from '../slicer.js';
 
-/**
- * Try to get the current git commit hash from the given directory.
- * Returns null if the directory is not a git repo or simple-git is unavailable.
- *
- * @param {string} dir - Directory to check for git.
- * @returns {Promise<string|null>} The current commit hash or null.
- */
-async function getGitCommitHash(dir) {
-  try {
-    const { simpleGit } = await import('simple-git');
-    const git = simpleGit(dir);
-    const isRepo = await git.checkIsRepo();
-    if (!isRepo) return null;
-    const log = await git.log({ maxCount: 1 });
-    return log.latest ? log.latest.hash : null;
-  } catch {
-    return null;
-  }
-}
-
 /**
  * Register the `update` command on the given Commander program.
  *
@@ -68,7 +48,6 @@ export function registerUpdateCommand(program) {
           const content = await fs.readFile(absPath, 'utf-8');
           currentHashes[relPath] = computeFileHash(content);
         } catch {
-          // Skip files that can't be read
           continue;
         }
       }
@@ -81,7 +60,7 @@ export function registerUpdateCommand(program) {
         return;
       }
 
-      // Step 5: Re-parse only changed/added files
+      // Step 5: Re-parse only changed/added files (single read per file)
       const updatedFiles = {};
       const changedPaths = [...changes.added, ...changes.modified];
 
@@ -90,18 +69,23 @@ export function registerUpdateCommand(program) {
         const language = detectLanguage(absPath);
         if (!language) continue;
 
+        let content;
+        try {
+          content = await fs.readFile(absPath, 'utf-8');
+        } catch {
+          continue;
+        }
+
+        const hash = computeFileHash(content);
+
         let parsed;
         try {
-          parsed = await parseFile(absPath, language);
+          parsed = await parseFile(absPath, language, content);
         } catch {
           continue;
         }
 
         const moduleName = detectModuleName(absPath, rootDir);
-        const content = await fs.readFile(absPath, 'utf-8');
-        const hash = computeFileHash(content);
-        const baseName = path.basename(absPath, path.extname(absPath)).toLowerCase();
-        const isEntryPoint = ['main', 'index', 'server', 'app', 'entry', 'bootstrap'].includes(baseName);
 
         updatedFiles[relPath] = {
           language,
@@ -113,7 +97,7 @@ export function registerUpdateCommand(program) {
           types: parsed.types,
           imports: parsed.imports,
           exports: parsed.exports,
-          isEntryPoint,
+          isEntryPoint: isEntryPoint(absPath),
         };
       }
 

cli/src/graph.js

@@ -1,5 +1,6 @@
 import crypto from 'crypto';
 import fs from 'fs/promises';
+import path from 'path';
 
 export function createEmptyGraph(projectName, rootDir) {
   return {
@@ -21,6 +22,34 @@ export function computeFileHash(content) {
   return 'sha256:' + crypto.createHash('sha256').update(content).digest('hex').slice(0, 16);
 }
 
+/** File basenames (without extension) that mark an entry point. */
+const ENTRY_POINT_NAMES = new Set([
+  'main', 'index', 'server', 'app', 'entry', 'bootstrap',
+]);
+
+/** Check whether a file path represents an entry point. */
+export function isEntryPoint(filePath) {
+  const baseName = path.basename(filePath, path.extname(filePath)).toLowerCase();
+  return ENTRY_POINT_NAMES.has(baseName);
+}
+
+/**
+ * Try to get the current git commit hash from the given directory.
+ * Returns null if the directory is not a git repo or simple-git is unavailable.
+ */
+export async function getGitCommitHash(dir) {
+  try {
+    const { simpleGit } = await import('simple-git');
+    const git = simpleGit(dir);
+    const isRepo = await git.checkIsRepo();
+    if (!isRepo) return null;
+    const log = await git.log({ maxCount: 1 });
+    return log.latest ? log.latest.hash : null;
+  } catch {
+    return null;
+  }
+}
+
 export async function saveGraph(outputDir, graph, meta) {
   await fs.mkdir(outputDir, { recursive: true });
   await fs.writeFile(`${outputDir}/graph.json`, JSON.stringify(graph, null, 2), 'utf-8');

cli/src/languages/base.js

@@ -62,4 +62,37 @@ export class LanguageAdapter {
   extractTypes(tree, sourceCode) {
     return [];
   }
+
+  // ---------------------------------------------------------------------------
+  // Shared helpers
+  // ---------------------------------------------------------------------------
+
+  /**
+   * Walk all nodes depth-first, calling `visitor(node)` for each.
+   * Uses an explicit stack (not the cursor API) for simplicity and reliability.
+   */
+  _walkNodes(root, visitor) {
+    const stack = [root];
+    while (stack.length > 0) {
+      const node = stack.pop();
+      visitor(node);
+      for (let i = node.childCount - 1; i >= 0; i--) {
+        stack.push(node.child(i));
+      }
+    }
+  }
+
+  /** Find the first direct child with the given type. */
+  _findChildOfType(node, type) {
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (child.type === type) return child;
+    }
+    return null;
+  }
+
+  /** Strip surrounding quotes from a string literal. */
+  _stripQuotes(text) {
+    return text.replace(/^['"`]|['"`]$/g, '');
+  }
 }

cli/src/languages/cpp.js

@@ -261,27 +261,6 @@ export class CppAdapter extends LanguageAdapter {
   // Helpers
   // ---------------------------------------------------------------------------
 
-  /** Walk all nodes depth-first, calling visitor(node) for each. */
-  _walkNodes(root, visitor) {
-    const stack = [root];
-    while (stack.length > 0) {
-      const node = stack.pop();
-      visitor(node);
-      for (let i = node.childCount - 1; i >= 0; i--) {
-        stack.push(node.child(i));
-      }
-    }
-  }
-
-  /** Find the first direct child with the given type. */
-  _findChildOfType(node, type) {
-    for (let i = 0; i < node.childCount; i++) {
-      const child = node.child(i);
-      if (child.type === type) return child;
-    }
-    return null;
-  }
-
   /** Find the first descendant (BFS) with the given type. */
   _findDescendantOfType(node, type) {
     const queue = [];

cli/src/languages/go.js

@@ -249,27 +249,10 @@ export class GoAdapter extends LanguageAdapter {
   // Helpers
   // ---------------------------------------------------------------------------
 
-  /** Walk all nodes depth-first, calling visitor(node) for each. */
-  _walkNodes(root, visitor) {
-    const stack = [root];
-    while (stack.length > 0) {
-      const node = stack.pop();
-      visitor(node);
-      for (let i = node.childCount - 1; i >= 0; i--) {
-        stack.push(node.child(i));
-      }
-    }
-  }
-
   /** Check whether a Go identifier is exported (starts with uppercase). */
   _isExported(name) {
     if (!name || name.length === 0) return false;
     const first = name.charCodeAt(0);
     return first >= 65 && first <= 90; // A-Z
   }
-
-  /** Strip surrounding quotes from a string literal. */
-  _stripQuotes(text) {
-    return text.replace(/^['"`]|['"`]$/g, '');
-  }
 }

cli/src/languages/java.js

@@ -168,20 +168,6 @@ export class JavaAdapter extends LanguageAdapter {
   // Helpers
   // ---------------------------------------------------------------------------
 
-  /**
-   * Walk all nodes depth-first, calling `visitor(node)` for each.
-   */
-  _walkNodes(root, visitor) {
-    const stack = [root];
-    while (stack.length > 0) {
-      const node = stack.pop();
-      visitor(node);
-      for (let i = node.childCount - 1; i >= 0; i--) {
-        stack.push(node.child(i));
-      }
-    }
-  }
-
   /**
    * Find the name of the enclosing class/interface/enum declaration.
    */