chore(parse): clarify test description and warning message phrasing

Agent-Logs-Url: https://github.com/abhigyanpatwari/GitNexus/sessions/5591f1ba-9032-4706-b007-effb0df46eb8

Co-authored-by: magyargergo <11230420+magyargergo@users.noreply.github.com>

gitnexus/src/cli/index.ts

@@ -81,6 +81,7 @@ program
       '  GITNEXUS_MAX_FILE_SIZE=N  Override large-file skip threshold (KB). Default 512, max 32768.\n' +
       '  GITNEXUS_WORKER_SUB_BATCH_TIMEOUT_MS=N  Worker idle timeout in milliseconds. Default 30000.\n' +
       '  GITNEXUS_WORKER_SUB_BATCH_MAX_BYTES=N  Worker job byte budget. Default 8388608.\n' +
+      '  GITNEXUS_ALLOW_CPP_WORKERS=1  Force worker threads even when C/C++ files are detected.\n' +
       '  GITNEXUS_EMBEDDING_THREADS=N  Limit local ONNX CPU threads for --embeddings.\n' +
       '  GITNEXUS_SEMANTIC_EXACT_SCAN_LIMIT=N  Max embedding chunks for exact-scan fallback. Default 10000.\n' +
       '\nTip: `.gitnexusignore` supports `.gitignore`-style negation. Add e.g.\n' +

gitnexus/src/core/ingestion/pipeline-phases/parse-impl.ts

@@ -71,6 +71,7 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 import { isDev } from '../utils/env.js';
 import { synthesizeWildcardImportBindings, needsSynthesis } from './wildcard-synthesis.js';
 import { extractORMQueriesInline } from './orm-extraction.js';
+import { hasWorkerUnsafeLanguages } from '../workers/worker-language-guard.js';
 
 import { logger } from '../../logger.js';
 // ── Constants ──────────────────────────────────────────────────────────────
@@ -315,6 +316,8 @@ export async function runChunkedParseAndResolve(
   const parseCache = options?.parseCache;
   let chunkCacheHits = 0;
   let chunkCacheMisses = 0;
+  // Suppress duplicate warnings when multiple consecutive chunks contain C/C++ files.
+  let hasWarnedAboutCppChunks = false;
 
   try {
     for (let chunkIdx = 0; chunkIdx < numChunks; chunkIdx++) {
@@ -370,6 +373,25 @@ export async function runChunkedParseAndResolve(
         // them under the chunk hash for the next run.
         chunkCacheMisses++;
         const rawResults: ParseWorkerResult[] = [];
+        // C/C++ grammar native bindings can crash worker threads with an
+        // unrecoverable Napi::Error / std::terminate(). Detect C/C++ files
+        // within this specific chunk and route them through the main-thread
+        // sequential path to avoid the crash. Other chunks (no C/C++) keep
+        // using the worker pool. GITNEXUS_ALLOW_CPP_WORKERS=1 opts out of
+        // this guard when a stable custom build is in use.
+        const chunkHasWorkerUnsafeFiles =
+          workerPool &&
+          process.env.GITNEXUS_ALLOW_CPP_WORKERS !== '1' &&
+          hasWorkerUnsafeLanguages(chunkFiles);
+        if (chunkHasWorkerUnsafeFiles && !hasWarnedAboutCppChunks) {
+          hasWarnedAboutCppChunks = true;
+          logger.warn(
+            `C/C++ files detected — parsing chunks containing C/C++ files in sequential mode to avoid known ` +
+              `worker-thread native binding errors (e.g. \`Napi::Error\`). C/C++ source files ` +
+              `are still fully indexed; chunks with no C/C++ continue using workers. ` +
+              `Set GITNEXUS_ALLOW_CPP_WORKERS=1 if you use a custom tree-sitter build without this issue.`,
+          );
+        }
         chunkWorkerData = await processParsing(
           graph,
           chunkFiles,
@@ -391,7 +413,11 @@ export async function runChunkedParseAndResolve(
               },
             });
           },
-          workerPool,
+          // For chunks containing C/C++ files, bypass the worker pool to avoid
+          // unrecoverable Napi::Error crashes from native grammar bindings in
+          // worker threads. processParsing falls through to processParsingSequential
+          // (main-thread safe). All other chunks keep using the worker pool.
+          chunkHasWorkerUnsafeFiles ? undefined : workerPool,
           // Capture raw results only when we have a cache to write to —
           // otherwise we'd retain extra arrays for nothing.
           parseCache && chunkHash ? rawResults : undefined,

gitnexus/src/core/ingestion/workers/worker-language-guard.ts

@@ -0,0 +1,12 @@
+import { getLanguageFromFilename, SupportedLanguages } from 'gitnexus-shared';
+
+const WORKER_UNSAFE_LANGUAGES = new Set<SupportedLanguages>([
+  SupportedLanguages.C,
+  SupportedLanguages.CPlusPlus,
+]);
+
+export const hasWorkerUnsafeLanguages = (files: ReadonlyArray<{ path: string }>): boolean =>
+  files.some((f) => {
+    const language = getLanguageFromFilename(f.path);
+    return language !== null && WORKER_UNSAFE_LANGUAGES.has(language);
+  });

gitnexus/test/unit/parse-impl-worker-guard.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, it } from 'vitest';
+
+import { hasWorkerUnsafeLanguages } from '../../src/core/ingestion/workers/worker-language-guard.js';
+
+describe('hasWorkerUnsafeLanguages', () => {
+  it('returns false for non-C/C++ inputs', () => {
+    expect(
+      hasWorkerUnsafeLanguages([
+        { path: 'src/app.ts', size: 123 },
+        { path: 'src/main.py', size: 456 },
+      ]),
+    ).toBe(false);
+  });
+
+  it('returns true when C++ (.cpp) files are present', () => {
+    expect(
+      hasWorkerUnsafeLanguages([
+        { path: 'src/main.ts', size: 123 },
+        { path: 'native/runtime.cpp', size: 456 },
+      ]),
+    ).toBe(true);
+  });
+
+  it('returns true when C files (.c extension) are present', () => {
+    expect(hasWorkerUnsafeLanguages([{ path: 'lib/util.c', size: 100 }])).toBe(true);
+  });
+
+  it('returns true when C header files are present', () => {
+    expect(hasWorkerUnsafeLanguages([{ path: 'include/api.h', size: 100 }])).toBe(true);
+  });
+
+  it('returns true when C++ header files (.hpp, .hxx, .hh) are present', () => {
+    expect(hasWorkerUnsafeLanguages([{ path: 'include/api.hpp', size: 100 }])).toBe(true);
+    expect(hasWorkerUnsafeLanguages([{ path: 'include/core.hxx', size: 100 }])).toBe(true);
+    expect(hasWorkerUnsafeLanguages([{ path: 'include/util.hh', size: 100 }])).toBe(true);
+  });
+
+  it('returns false for an empty list', () => {
+    expect(hasWorkerUnsafeLanguages([])).toBe(false);
+  });
+});