cgraphx 2.0.1 → 2.0.3

package/dist/core/code/engine/core/tree-sitter/parser-loader.js

@@ -0,0 +1,281 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createParserForLanguage = exports.loadLanguage = exports.loadParser = exports.getLanguageGrammar = exports.isGrammarRuntimeSkipped = exports.isLanguageAvailable = exports.resolveLanguageKey = exports.listGrammarSources = void 0;
+const tree_sitter_1 = __importDefault(require("tree-sitter"));
+const node_module_1 = require("node:module");
+const index_js_1 = require("../../../shared/index.js");
+const logger_js_1 = require("../logger.js");
+const vendored_grammars_js_1 = require("./vendored-grammars.js");
+const _require = (0, node_module_1.createRequire)(__filename);
+const ISSUES_URL = 'https://github.com/abhigyanpatwari/GitNexus/issues';
+const SOURCES = {
+    [index_js_1.SupportedLanguages.JavaScript]: {
+        load: () => _require('tree-sitter-javascript'),
+        unavailableNote: 'JavaScript parsing requires `tree-sitter-javascript`. ' +
+            'Check that the package and its native binding installed cleanly (`npm ci`).',
+    },
+    [index_js_1.SupportedLanguages.TypeScript]: {
+        load: () => _require('tree-sitter-typescript').typescript,
+        unavailableNote: 'TypeScript parsing requires `tree-sitter-typescript`. ' +
+            'Check that the package and its native binding installed cleanly (`npm ci`).',
+    },
+    [`${index_js_1.SupportedLanguages.TypeScript}:tsx`]: {
+        load: () => _require('tree-sitter-typescript').tsx,
+        unavailableNote: 'TSX parsing requires `tree-sitter-typescript` (re-uses the same native binding as TS).',
+    },
+    [index_js_1.SupportedLanguages.Python]: {
+        load: () => _require('tree-sitter-python'),
+        unavailableNote: 'Python parsing requires `tree-sitter-python`. Check the install and native binding.',
+    },
+    [index_js_1.SupportedLanguages.Java]: {
+        load: () => _require('tree-sitter-java'),
+        unavailableNote: 'Java parsing requires `tree-sitter-java`. Check the install and native binding.',
+    },
+    // tree-sitter-c-sharp declares `type: "module"` with `main: "bindings/node"`
+    // (no extension) and no `exports` field, which triggers Node 22's DEP0151
+    // deprecation warning on the bare-package import. The explicit subpath
+    // bypasses the deprecated ESM main-field resolution. (#1013)
+    [index_js_1.SupportedLanguages.CSharp]: {
+        load: () => _require('tree-sitter-c-sharp/bindings/node/index.js'),
+        unavailableNote: 'C# parsing requires `tree-sitter-c-sharp/bindings/node/index.js`. ' +
+            `If the subpath is missing, see ${ISSUES_URL}/1013.`,
+    },
+    [index_js_1.SupportedLanguages.CPlusPlus]: {
+        load: () => _require('tree-sitter-cpp'),
+        unavailableNote: 'C++ parsing requires `tree-sitter-cpp`. Check the install and native binding.',
+    },
+    [index_js_1.SupportedLanguages.Go]: {
+        load: () => _require('tree-sitter-go'),
+        unavailableNote: 'Go parsing requires `tree-sitter-go`. Check the install and native binding.',
+    },
+    [index_js_1.SupportedLanguages.Rust]: {
+        load: () => _require('tree-sitter-rust'),
+        unavailableNote: 'Rust parsing requires `tree-sitter-rust`. Check the install and native binding.',
+    },
+    [index_js_1.SupportedLanguages.PHP]: {
+        load: () => _require('tree-sitter-php').php_only,
+        unavailableNote: 'PHP parsing requires `tree-sitter-php` (the `php_only` export). ' +
+            'Check the install and native binding.',
+    },
+    [index_js_1.SupportedLanguages.Ruby]: {
+        load: () => _require('tree-sitter-ruby'),
+        unavailableNote: 'Ruby parsing requires `tree-sitter-ruby`. Check the install and native binding.',
+    },
+    [index_js_1.SupportedLanguages.Vue]: {
+        load: () => _require('tree-sitter-typescript').typescript,
+        unavailableNote: 'Vue parsing piggybacks on `tree-sitter-typescript`. Check the install and native binding.',
+    },
+    // tree-sitter-c is a core grammar, vendored prebuild-only (under
+    // cgraph/vendor/tree-sitter-c) with GitNexus-built prebuilds for every
+    // supported platform-arch — upstream ships only 4/6 (#2116) and C is a
+    // required grammar whose source build hard-fails install on a toolchain-less
+    // ARM host. Loading through the optional machinery turns a would-be ABI
+    // segfault (#1242, #858) into a clean degradation while preserving every
+    // other language's analysis. Severity stays `error` because C is not a
+    // user-opt-out grammar like Swift/Dart/Kotlin: a failure here is always an
+    // install/platform problem the user needs to see.
+    [index_js_1.SupportedLanguages.C]: {
+        load: () => (0, vendored_grammars_js_1.requireVendoredGrammar)('tree-sitter-c'),
+        optional: true,
+        severity: 'error',
+        unavailableNote: 'C parsing disabled: vendored `tree-sitter-c` (under ' +
+            '`cgraph/vendor/tree-sitter-c`) could not be loaded. GitNexus ships ' +
+            'prebuilt binaries for all supported platforms (win32/darwin/linux ' +
+            'x64+arm64, N-API), so this usually indicates a corrupted install or a ' +
+            'native ABI mismatch with the bundled tree-sitter@0.21.1 runtime. ' +
+            'Try reinstalling, then re-run analyze. ' +
+            `If the failure persists, file details at ${ISSUES_URL}/1242.`,
+    },
+    // optionalDependencies — may be absent on platforms without prebuilds
+    // or when users skip optional installs.
+    [index_js_1.SupportedLanguages.Swift]: {
+        load: () => (0, vendored_grammars_js_1.requireVendoredGrammar)('tree-sitter-swift'),
+        optional: true,
+        userSkippable: true,
+        unavailableNote: 'Swift parsing disabled: vendored `tree-sitter-swift` (under ' +
+            '`cgraph/vendor/tree-sitter-swift`) failed to load. ' +
+            'Likely cause: no prebuilt `.node` for this platform/architecture. ' +
+            `See ${ISSUES_URL}/1130.`,
+    },
+    [index_js_1.SupportedLanguages.Dart]: {
+        load: () => (0, vendored_grammars_js_1.requireVendoredGrammar)('tree-sitter-dart'),
+        optional: true,
+        userSkippable: true,
+        unavailableNote: 'Dart parsing disabled: vendored `tree-sitter-dart` (under ' +
+            '`cgraph/vendor/tree-sitter-dart`) failed to load. ' +
+            'Likely cause: native compile failed at install (missing python3/make/g++). ' +
+            `See ${ISSUES_URL}/1125.`,
+    },
+    [index_js_1.SupportedLanguages.Kotlin]: {
+        load: () => (0, vendored_grammars_js_1.requireVendoredGrammar)('tree-sitter-kotlin'),
+        optional: true,
+        userSkippable: true,
+        unavailableNote: 'Kotlin parsing disabled: vendored `tree-sitter-kotlin` (under ' +
+            '`cgraph/vendor/tree-sitter-kotlin`) failed to load. ' +
+            'Likely cause: no prebuilt `.node` for this platform/architecture. ' +
+            `See ${ISSUES_URL}/2107.`,
+    },
+};
+const listGrammarSources = () => Object.entries(SOURCES).map(([key, source]) => ({
+    key,
+    optional: source.optional === true,
+}));
+exports.listGrammarSources = listGrammarSources;
+const loadCache = new Map();
+const logged = new Set();
+// Parsed form of CGRAPH_SKIP_OPTIONAL_GRAMMARS, resolved lazily ONCE per
+// process. The env is set before analyze runs, so re-reading + re-allocating a
+// Set on every call was wasted work (and a latent trap for any future per-file
+// caller). `vi.resetModules()` gives the unit tests a fresh module — and thus a
+// fresh memo — per case, so this stays test-friendly.
+//   'all' → every userSkippable grammar; Set → only the named ids
+//   (and `tree-sitter-<id>` spellings); null → env unset/empty (nothing).
+let _skipDirective;
+const skipDirective = () => {
+    if (_skipDirective !== undefined)
+        return _skipDirective;
+    const raw = (process.env.CGRAPH_SKIP_OPTIONAL_GRAMMARS ?? '').trim().toLowerCase();
+    if (raw === '')
+        return (_skipDirective = null);
+    if (raw === '1' || raw === 'true' || raw === 'all' || raw === '*')
+        return (_skipDirective = 'all');
+    return (_skipDirective = new Set(raw
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean)
+        .flatMap((s) => [s, s.replace(/^tree-sitter-/, '')])));
+};
+const isRuntimeSkippedGrammar = (key, source) => {
+    // Only grammars explicitly flagged user-skippable (swift/dart/kotlin) — never
+    // required deps that use the optional machinery for ABI safety (C carries no
+    // `userSkippable`).
+    if (source.userSkippable !== true)
+        return false;
+    const directive = skipDirective();
+    if (directive === null)
+        return false;
+    if (directive === 'all')
+        return true;
+    // `key` is the SupportedLanguages value (e.g. `swift`); the directive Set
+    // already holds both the bare id and the `tree-sitter-<id>` spelling.
+    return directive.has(key) || directive.has(`tree-sitter-${key}`);
+};
+const logFailure = (key, result) => {
+    if (result.ok === true)
+        return;
+    if (logged.has(key))
+        return;
+    logged.add(key);
+    const message = `[gitnexus] ${result.note} (${result.error.message})`;
+    // Severity routes to the correct pino level. Both go to stderr (pino's
+    // default destination), so MCP stdio framing is preserved either way —
+    // the level tag drives log filtering, not channel selection.
+    if (result.severity === 'error') {
+        logger_js_1.logger.error(message);
+    }
+    else {
+        logger_js_1.logger.warn(message);
+    }
+};
+const resolveLanguageKey = (language, filePath) => language === index_js_1.SupportedLanguages.TypeScript && filePath?.endsWith('.tsx')
+    ? `${language}:tsx`
+    : language;
+exports.resolveLanguageKey = resolveLanguageKey;
+const loadGrammar = (key) => {
+    const cached = loadCache.get(key);
+    if (cached)
+        return cached;
+    const source = SOURCES[key];
+    if (!source) {
+        const result = {
+            ok: false,
+            error: new Error(`Unsupported language: ${key}`),
+            note: `No grammar registered for language key \`${key}\`. Add a row to SOURCES.`,
+            fatal: true,
+            severity: 'error',
+        };
+        loadCache.set(key, result);
+        return result;
+    }
+    // Runtime opt-out: treat a user-skipped optional grammar exactly like an
+    // absent binding (non-fatal unavailable + one warning), without attempting
+    // the native load. See `isRuntimeSkippedGrammar`.
+    if (isRuntimeSkippedGrammar(key, source)) {
+        // Deliberate opt-out: emit an accurate "disabled on purpose" note rather
+        // than `source.unavailableNote` (which blames a missing/unbuilt binding and
+        // would mislead a user who set the env intentionally — #2101 review).
+        const result = {
+            ok: false,
+            error: new Error('runtime opt-out'),
+            note: `${key} parsing disabled via CGRAPH_SKIP_OPTIONAL_GRAMMARS (unset it to re-enable).`,
+            fatal: false,
+            severity: 'warn',
+        };
+        loadCache.set(key, result);
+        logFailure(key, result);
+        return result;
+    }
+    let result;
+    try {
+        result = { ok: true, grammar: source.load() };
+    }
+    catch (err) {
+        const fatal = !source.optional;
+        result = {
+            ok: false,
+            error: err,
+            note: source.unavailableNote,
+            fatal,
+            severity: source.severity ?? (fatal ? 'error' : 'warn'),
+        };
+    }
+    loadCache.set(key, result);
+    if (result.ok === false)
+        logFailure(key, result);
+    return result;
+};
+const isLanguageAvailable = (language, filePath) => loadGrammar((0, exports.resolveLanguageKey)(language, filePath)).ok;
+exports.isLanguageAvailable = isLanguageAvailable;
+/**
+ * True when `language`'s grammar is being treated as unavailable specifically
+ * because of the runtime CGRAPH_SKIP_OPTIONAL_GRAMMARS opt-out — as opposed
+ * to a genuinely-missing/broken native binding. Lets callers surface an
+ * accurate "skipped on purpose" message instead of a spurious "npm rebuild"
+ * recovery hint. Returns false for required grammars and for an absent env.
+ */
+const isGrammarRuntimeSkipped = (language, filePath) => {
+    const key = (0, exports.resolveLanguageKey)(language, filePath);
+    const source = SOURCES[key];
+    return source !== undefined && isRuntimeSkippedGrammar(key, source);
+};
+exports.isGrammarRuntimeSkipped = isGrammarRuntimeSkipped;
+const getLanguageGrammar = (language, filePath) => {
+    const key = (0, exports.resolveLanguageKey)(language, filePath);
+    const result = loadGrammar(key);
+    if (result.ok === true)
+        return result.grammar;
+    // Fatal failures throw the original underlying error (preserving stack)
+    // after the note has been logged. Optional failures fall through to the
+    // standard "Unsupported language" message that callers already handle.
+    if (result.fatal)
+        throw result.error;
+    throw new Error(`Unsupported language: ${language}`);
+};
+exports.getLanguageGrammar = getLanguageGrammar;
+let sharedParser = null;
+const loadParser = async () => (sharedParser ??= new tree_sitter_1.default());
+exports.loadParser = loadParser;
+const loadLanguage = async (language, filePath) => {
+    const parser = await (0, exports.loadParser)();
+    parser.setLanguage((0, exports.getLanguageGrammar)(language, filePath));
+};
+exports.loadLanguage = loadLanguage;
+const createParserForLanguage = async (language, filePath) => {
+    const parser = new tree_sitter_1.default();
+    parser.setLanguage((0, exports.getLanguageGrammar)(language, filePath));
+    return parser;
+};
+exports.createParserForLanguage = createParserForLanguage;

package/dist/core/code/engine/core/tree-sitter/safe-parse.js

@@ -0,0 +1,258 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParseTimeoutError = void 0;
+exports.resetDegradedParseCounter = resetDegradedParseCounter;
+exports._resetDegradedParseCounter = _resetDegradedParseCounter;
+exports.parseHadErrors = parseHadErrors;
+exports.getParseDiagnostics = getParseDiagnostics;
+exports.parseSourceSafe = parseSourceSafe;
+const logger_js_1 = require("../logger.js");
+/**
+ * tree-sitter 0.21.x's Node native binding crashes (SIGSEGV) on Windows when
+ * `parser.parse(string, …)` is handed a JS string longer than 32 767 chars.
+ * The crash happens inside the binding's V8 string-to-buffer conversion and
+ * cannot be intercepted from JavaScript. The callback (`Parser.Input`) overload
+ * pulls source in fixed-size chunks via repeated callback invocations and
+ * bypasses that conversion path entirely.
+ *
+ * Chunk size is comfortably below the boundary; any value < 32 767 works.
+ */
+const SAFE_PARSE_CHUNK_CHARS = 16 * 1024;
+/**
+ * Files at or below this length skip the callback machinery and use the
+ * direct string overload — the bug only manifests above the int16 boundary,
+ * so small inputs save the cost of N callback invocations per parse.
+ */
+const DIRECT_PARSE_LIMIT_CHARS = 16 * 1024;
+/**
+ * Default per-parse wall-clock budget in milliseconds. A pathological input
+ * (deeply nested / quadratic-grammar source) can spin tree-sitter for tens of
+ * seconds, stalling the worker that holds it. The pool's per-dispatch idle
+ * timeout is 30 s (`DEFAULT_SUB_BATCH_IDLE_TIMEOUT_MS` in
+ * `workers/worker-pool.ts`); this budget MUST stay below it so a single bad
+ * file is hard-skipped here rather than tripping the slower pool-level
+ * retry/respawn machinery. 15 s leaves comfortable headroom.
+ *
+ * Override via `CGRAPH_PARSE_TIMEOUT_MS`; `0` disables the budget entirely
+ * (unlimited parse time — restore the historical behaviour for debugging).
+ */
+const DEFAULT_PARSE_TIMEOUT_MS = 15_000;
+/**
+ * Resolve the per-parse budget in milliseconds from the environment. A
+ * non-negative integer overrides the default; `0` disables the timeout.
+ * Unparseable / negative values fall back to the default rather than
+ * silently disabling the safety net.
+ */
+function resolveParseTimeoutMs() {
+    const raw = process.env.CGRAPH_PARSE_TIMEOUT_MS;
+    if (raw === undefined || raw === '')
+        return DEFAULT_PARSE_TIMEOUT_MS;
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed) || parsed < 0)
+        return DEFAULT_PARSE_TIMEOUT_MS;
+    return Math.floor(parsed);
+}
+/**
+ * Tiny shim around the runtime's parse-interruption knob so the future
+ * 0.25/0.26 swap (where `setTimeoutMicros` is removed in favour of
+ * `Parser.Options.progressCallback`) is a single-function change.
+ *
+ * Returns `true` when a budget was armed (caller must clear it afterwards),
+ * `false` when the runtime offers no interruption mechanism (older/newer
+ * runtimes) so the caller can skip the reset/clear dance.
+ *
+ * Only the `setTimeoutMicros` branch is implemented today; add the
+ * `progressCallback` branch here when the runtime moves to 0.25+.
+ */
+function armParseBudget(parser, budgetMs) {
+    if (budgetMs <= 0)
+        return false;
+    const cap = parser;
+    if (typeof cap.setTimeoutMicros !== 'function')
+        return false;
+    cap.setTimeoutMicros(Math.floor(budgetMs * 1000));
+    return true;
+}
+/**
+ * Clear any armed parse budget so it never leaks to the next parse on a
+ * reused/singleton parser. Safe to call when nothing was armed.
+ */
+function clearParseBudget(parser) {
+    const cap = parser;
+    cap.setTimeoutMicros?.(0);
+}
+/**
+ * Reset parser state after a timeout. tree-sitter RESUMES the interrupted
+ * parse on the next `parse()` call unless `reset()` is invoked first
+ * (tree-sitter `api.h`); skipping this corrupts the next file's tree on the
+ * shared singleton.
+ */
+function resetParser(parser) {
+    parser.reset?.();
+}
+/**
+ * Thrown when a parse exceeds its wall-clock budget (see
+ * {@link DEFAULT_PARSE_TIMEOUT_MS}). The parser has already been `reset()` and
+ * its budget cleared by the time this propagates, so callers may safely reuse
+ * the same parser for the next file.
+ *
+ * Hard-skip contract: a timeout is fatal for the offending file but MUST NOT
+ * abort the run. Every caller is responsible for catching this specific error
+ * (`instanceof ParseTimeoutError`), skipping that one file (degrade-and-
+ * continue), and re-throwing anything else. Catching it generically and
+ * swallowing all errors would mask real bugs, so callers match on the type.
+ */
+class ParseTimeoutError extends Error {
+    budgetMs;
+    label;
+    constructor(budgetMs, label) {
+        super(`tree-sitter parse exceeded its ${budgetMs}ms budget` +
+            (label ? ` while parsing ${label}` : '') +
+            ' (set CGRAPH_PARSE_TIMEOUT_MS=0 to disable, or raise the budget)');
+        this.name = 'ParseTimeoutError';
+        this.budgetMs = budgetMs;
+        this.label = label;
+    }
+}
+exports.ParseTimeoutError = ParseTimeoutError;
+/**
+ * Per-run counter so a corpus full of minor-error files emits a bounded
+ * number of degraded-parse logs instead of one per file. The count is
+ * reported on the throttled records so operators still see the true scale.
+ */
+let degradedParseCount = 0;
+const DEGRADED_PARSE_LOG_LIMIT = 20;
+/**
+ * Reset the per-run degraded-parse log throttle. Called at the start of every
+ * analysis run (`runFullAnalysis`) so the first-N-then-suppress budget is
+ * scoped to a single run rather than to the lifetime of the module (which, on
+ * a reused process, would suppress all degraded-parse logs after the first
+ * run). Safe to call at any time.
+ */
+function resetDegradedParseCounter() {
+    degradedParseCount = 0;
+}
+/**
+ * @internal Test-only alias for {@link resetDegradedParseCounter}, kept so the
+ * existing `safe-parse.test.ts` import keeps working. Prefer the public name.
+ */
+function _resetDegradedParseCounter() {
+    resetDegradedParseCounter();
+}
+/**
+ * True when the parsed tree contains any ERROR or MISSING node — i.e. the
+ * source did not parse cleanly and tree-sitter applied error recovery.
+ * `parse` never throws on bad syntax (it recovers into ERROR/MISSING nodes),
+ * so this is the only signal callers have that a tree is degraded.
+ */
+function parseHadErrors(tree) {
+    const root = tree.rootNode;
+    if (root == null)
+        return false;
+    return root.hasError || root.isMissing;
+}
+/**
+ * Structured diagnostics for a parsed tree. Cheap (reads boolean node
+ * properties only); callers that just want a yes/no use {@link parseHadErrors}.
+ */
+function getParseDiagnostics(tree) {
+    const root = tree.rootNode;
+    if (root == null)
+        return { hasError: false, isMissing: false };
+    return { hasError: root.hasError, isMissing: root.isMissing };
+}
+/**
+ * Parse `sourceText` safely on every platform.
+ *
+ * This is the single "parse safely" entry point and its contract covers four
+ * concerns:
+ *
+ *  1. **Windows crash workaround.** Inputs longer than 32 767 chars are fed
+ *     through the chunked `Parser.Input` callback overload to dodge the
+ *     0.21.x string-to-buffer SIGSEGV. See {@link SAFE_PARSE_CHUNK_CHARS}.
+ *
+ *  2. **Runaway-parse timeout.** A per-parse budget (default 15 s, env
+ *     `CGRAPH_PARSE_TIMEOUT_MS`, `0` disables) is armed before parsing on
+ *     both the direct and chunked paths. On timeout the runtime returns
+ *     `null`; this function `reset()`s the parser, clears the budget, and
+ *     throws {@link ParseTimeoutError}. The budget is always cleared in a
+ *     `finally` so it never leaks to the next parse on a reused/singleton
+ *     parser (`loadParser()` and the worker both reuse one `Parser`).
+ *
+ *  3. **Intrinsic error detection.** On a successful parse, a degraded tree
+ *     (`rootNode.hasError`) is logged at `debug` level with throttling, then
+ *     the tree is **returned anyway** — error recovery is a downgrade, never a
+ *     drop. Callers wanting the boolean use {@link parseHadErrors}.
+ *
+ *  4. **Embedded NUL recovery.** U+0000 is replaced with one ASCII space in
+ *     the parser-only input. The one-for-one substitution keeps tree indices
+ *     aligned with the original source while preventing language lexers from
+ *     swallowing declarations during error recovery.
+ *
+ * @param label optional context (e.g. file path) attached to timeout errors,
+ *   recovery warnings, and degraded-parse logs. Non-breaking trailing param.
+ */
+function parseSourceSafe(parser, sourceText, oldTree, options, label) {
+    let parserInput = sourceText;
+    if (sourceText.includes('\0')) {
+        let nullByteCount = 0;
+        parserInput = sourceText.replaceAll('\0', () => {
+            nullByteCount += 1;
+            return ' ';
+        });
+        logger_js_1.logger.warn({ ...(label ? { file: label } : {}), nullByteCount }, 'replaced embedded NUL bytes before tree-sitter parsing');
+    }
+    const budgetMs = resolveParseTimeoutMs();
+    const armed = armParseBudget(parser, budgetMs);
+    let tree;
+    try {
+        if (parserInput.length <= DIRECT_PARSE_LIMIT_CHARS) {
+            tree = parser.parse(parserInput, oldTree, options);
+        }
+        else {
+            const input = (index) => {
+                if (index >= parserInput.length)
+                    return null;
+                return parserInput.slice(index, index + SAFE_PARSE_CHUNK_CHARS);
+            };
+            tree = parser.parse(input, oldTree, options);
+        }
+    }
+    finally {
+        // Always clear the budget — otherwise it leaks onto the next parse on a
+        // reused singleton parser, prematurely killing an innocent file.
+        if (armed)
+            clearParseBudget(parser);
+    }
+    // A `null` return means the runtime hit the budget mid-parse. The parser
+    // would otherwise RESUME this parse on the next call, so reset it before
+    // surfacing the timeout as a typed throw (callers skip the file).
+    if (tree === null) {
+        if (armed)
+            resetParser(parser);
+        throw new ParseTimeoutError(budgetMs, label);
+    }
+    // Intrinsic ERROR detection. tree-sitter recovers from bad syntax into
+    // ERROR/MISSING nodes rather than throwing, so a clean return can still
+    // wrap a degraded tree. Log it (throttled, debug-level so common minor
+    // errors don't flood) but DOWNGRADE — never drop — and return the tree.
+    //
+    // Guard `rootNode` defensively: a real tree-sitter tree always exposes one,
+    // but stub parsers in tests (and any future non-standard `Parser.Tree`) may
+    // not. A missing root is treated as "no detectable errors" so detection
+    // never throws on the parse success path.
+    if (tree.rootNode != null && parseHadErrors(tree)) {
+        degradedParseCount += 1;
+        if (degradedParseCount <= DEGRADED_PARSE_LOG_LIMIT) {
+            logger_js_1.logger.debug({
+                ...(label ? { file: label } : {}),
+                rootType: tree.rootNode.type,
+                degradedParseCount,
+                ...(degradedParseCount === DEGRADED_PARSE_LOG_LIMIT
+                    ? { note: 'further degraded-parse logs suppressed this run' }
+                    : {}),
+            }, 'tree-sitter parsed with errors (degraded tree)');
+        }
+    }
+    return tree;
+}

package/dist/core/code/engine/core/tree-sitter/vendored-grammars.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireVendoredGrammar = exports.vendoredGrammarDir = exports.VENDORED_GRAMMAR_PACKAGES = exports.VENDOR_ROOT = void 0;
+const node_module_1 = require("node:module");
+const node_path_1 = __importDefault(require("node:path"));
+const _require = (0, node_module_1.createRequire)(__filename);
+/**
+ * Absolute path to the vendored grammar tree (`<pkg>/vendor`).
+ *
+ * This module compiles to `<pkg>/dist/core/tree-sitter/vendored-grammars.js`
+ * and runs from `<pkg>/src/core/tree-sitter/...` under tsx in dev — both sit
+ * three directories below the package root, and the build (`tsc`) never bundles,
+ * so `import.meta.url` resolves the same way in both. `vendor/` ships in the
+ * published package via package.json `files`.
+ */
+exports.VENDOR_ROOT = node_path_1.default.resolve(__dirname, '..', '..', '..', 'vendor');
+/**
+ * The tree-sitter grammars GitNexus vendors inside its own package (NOT npm
+ * dependencies). Kept in one place so consumers (runtime loaders, the CLI
+ * availability probe, and the test grammar-introspection helper) agree on which
+ * grammars resolve from `vendor/` rather than `node_modules`.
+ */
+exports.VENDORED_GRAMMAR_PACKAGES = new Set([
+    'tree-sitter-c',
+    'tree-sitter-dart',
+    'tree-sitter-proto',
+    'tree-sitter-swift',
+    'tree-sitter-kotlin',
+]);
+/** Absolute directory of a vendored grammar package under `vendor/`. */
+const vendoredGrammarDir = (packageName) => node_path_1.default.join(exports.VENDOR_ROOT, packageName);
+exports.vendoredGrammarDir = vendoredGrammarDir;
+/**
+ * Load a vendored tree-sitter grammar by its absolute path under `vendor/`.
+ *
+ * GitNexus vendors five grammars (c/dart/proto/swift/kotlin) inside its own
+ * package under `vendor/`, each shipping committed per-platform prebuilds. They
+ * are deliberately NOT npm dependencies and must NEVER be copied into
+ * `node_modules`: an undeclared package under `node_modules` is "extraneous" to
+ * every subsequent `npm`/`npx` arborist reify, which prunes or relocates it.
+ * That is the root cause of #2111 / #1728 — on Windows the relocation throws
+ * `EPERM: operation not permitted, symlink` (errno -4048) during the npx-cache
+ * reify Antigravity triggers when it launches the MCP server, and on every OS
+ * the second run silently deletes the materialized grammars.
+ *
+ * Resolving the grammar by absolute path runs its own `bindings/node` entry,
+ * which calls `node-gyp-build(<grammarDir>)` and loads
+ * `vendor/<name>/prebuilds/<platform>-<arch>/…` directly — no build, no write,
+ * no `node_modules` copy. (`node-gyp-build` itself IS an npm dependency and
+ * resolves normally from the grammar directory.)
+ */
+const requireVendoredGrammar = (packageName) => {
+    // Fail loudly on a name that isn't actually vendored — a typo or a list that
+    // drifted out of sync (VENDORED_GRAMMAR_PACKAGES vs the CLI probe vs the build
+    // registry) would otherwise surface as a confusing absolute-path require miss.
+    if (!exports.VENDORED_GRAMMAR_PACKAGES.has(packageName)) {
+        throw new Error(`'${packageName}' is not a vendored grammar (expected one of: ${[...exports.VENDORED_GRAMMAR_PACKAGES].join(', ')}).`);
+    }
+    return _require((0, exports.vendoredGrammarDir)(packageName));
+};
+exports.requireVendoredGrammar = requireVendoredGrammar;