@veewo/gitnexus 1.5.0-rc.4 → 1.5.0

package/dist/core/ingestion/unity-runtime-binding-rules.js

@@ -1,6 +1,6 @@
 import { generateId } from '../../lib/utils.js';
 const RULE_EDGE_CONFIDENCE = 0.75;
-export function applyUnityRuntimeBindingRules(graph, rules, _config) {
+export function applyUnityRuntimeBindingRules(graph, rules, config) {
     const ruleResults = [];
     let totalEdges = 0;
     const existingPairs = new Set();
@@ -27,7 +27,10 @@ export function applyUnityRuntimeBindingRules(graph, rules, _config) {
     };
     // Pre-build indexes
     const methodsByClassId = new Map();
-    const classNodes = [];
+    const containerNodes = [];
+    const containerLabels = config.enableContainerNodes
+        ? new Set(['Class', 'Struct', 'Interface', 'Record'])
+        : new Set(['Class']);
     for (const rel of graph.iterRelationships()) {
         if (rel.type !== 'HAS_METHOD')
             continue;
@@ -39,8 +42,8 @@ export function applyUnityRuntimeBindingRules(graph, rules, _config) {
         methodsByClassId.set(rel.sourceId, list);
     }
     for (const node of graph.iterNodes()) {
-        if (node.label === 'Class')
-            classNodes.push(node);
+        if (containerLabels.has(node.label))
+            containerNodes.push(node);
     }
     // Collect UNITY_ASSET_GUID_REF and UNITY_COMPONENT_INSTANCE edges
     const assetGuidRefs = [];
@@ -67,10 +70,10 @@ export function applyUnityRuntimeBindingRules(graph, rules, _config) {
     for (const rule of rules) {
         let ruleEdges = 0;
         for (const binding of rule.resource_bindings ?? []) {
-            ruleEdges += processBinding(binding, rule.id, assetGuidRefs, componentInstances, methodsByClassId, classNodes, sceneFilesByName, addSyntheticEdge);
+            ruleEdges += processBinding(binding, rule.id, assetGuidRefs, componentInstances, methodsByClassId, containerNodes, sceneFilesByName, addSyntheticEdge);
         }
         if (rule.lifecycle_overrides?.additional_entry_points?.length) {
-            ruleEdges += processLifecycleOverrides(rule, methodsByClassId, classNodes, addSyntheticEdge);
+            ruleEdges += processLifecycleOverrides(rule, methodsByClassId, containerNodes, addSyntheticEdge);
         }
         totalEdges += ruleEdges;
         ruleResults.push({ ruleId: rule.id, edgesInjected: ruleEdges });
@@ -91,18 +94,18 @@ function findMethodsOnResource(resourceFileId, componentInstances, methodsByClas
     }
     return results;
 }
-function processBinding(binding, ruleId, assetGuidRefs, componentInstances, methodsByClassId, classNodes, sceneFilesByName, addEdge) {
+function processBinding(binding, ruleId, assetGuidRefs, componentInstances, methodsByClassId, containerNodes, sceneFilesByName, addEdge) {
     if (binding.kind === 'asset_ref_loads_components') {
         return processAssetRefLoadsComponents(binding, ruleId, assetGuidRefs, componentInstances, methodsByClassId, addEdge);
     }
     if (binding.kind === 'method_triggers_field_load') {
-        return processMethodTriggersFieldLoad(binding, ruleId, assetGuidRefs, componentInstances, methodsByClassId, classNodes, addEdge);
+        return processMethodTriggersFieldLoad(binding, ruleId, assetGuidRefs, componentInstances, methodsByClassId, containerNodes, addEdge);
     }
     if (binding.kind === 'method_triggers_scene_load') {
-        return processMethodTriggersSceneLoad(binding, ruleId, componentInstances, methodsByClassId, classNodes, sceneFilesByName, addEdge);
+        return processMethodTriggersSceneLoad(binding, ruleId, componentInstances, methodsByClassId, containerNodes, sceneFilesByName, addEdge);
     }
     if (binding.kind === 'method_triggers_method') {
-        return processMethodTriggersMethod(binding, ruleId, methodsByClassId, classNodes, addEdge);
+        return processMethodTriggersMethod(binding, ruleId, methodsByClassId, containerNodes, addEdge);
     }
     return 0;
 }
@@ -132,7 +135,7 @@ function processAssetRefLoadsComponents(binding, ruleId, assetGuidRefs, componen
     }
     return count;
 }
-function processMethodTriggersFieldLoad(binding, ruleId, assetGuidRefs, componentInstances, methodsByClassId, classNodes, addEdge) {
+function processMethodTriggersFieldLoad(binding, ruleId, assetGuidRefs, componentInstances, methodsByClassId, containerNodes, addEdge) {
     let count = 0;
     const classPattern = binding.host_class_pattern ? new RegExp(binding.host_class_pattern) : null;
     const loaderMethodNames = new Set(binding.loader_methods ?? []);
@@ -148,7 +151,7 @@ function processMethodTriggersFieldLoad(binding, ruleId, assetGuidRefs, componen
         list.push(ref);
         refsBySource.set(ref.sourceId, list);
     }
-    for (const cls of classNodes) {
+    for (const cls of containerNodes) {
         if (!classPattern.test(cls.properties.name))
             continue;
         const methods = methodsByClassId.get(cls.id) ?? [];
@@ -176,7 +179,7 @@ function processMethodTriggersFieldLoad(binding, ruleId, assetGuidRefs, componen
     }
     return count;
 }
-function processMethodTriggersSceneLoad(binding, ruleId, componentInstances, methodsByClassId, classNodes, sceneFilesByName, addEdge) {
+function processMethodTriggersSceneLoad(binding, ruleId, componentInstances, methodsByClassId, containerNodes, sceneFilesByName, addEdge) {
     const classPattern = binding.host_class_pattern ? new RegExp(binding.host_class_pattern) : null;
     const loaderMethodNames = new Set(binding.loader_methods ?? []);
     const sceneName = binding.scene_name;
@@ -190,7 +193,7 @@ function processMethodTriggersSceneLoad(binding, ruleId, componentInstances, met
     if (sceneFileIds.length === 0)
         return 0;
     let count = 0;
-    for (const cls of classNodes) {
+    for (const cls of containerNodes) {
         if (!classPattern.test(cls.properties.name))
             continue;
         const methods = methodsByClassId.get(cls.id) ?? [];
@@ -209,7 +212,7 @@ function processMethodTriggersSceneLoad(binding, ruleId, componentInstances, met
     }
     return count;
 }
-function processMethodTriggersMethod(binding, ruleId, methodsByClassId, classNodes, addEdge) {
+function processMethodTriggersMethod(binding, ruleId, methodsByClassId, containerNodes, addEdge) {
     const { source_class_pattern, source_method, target_class_pattern, target_method } = binding;
     if (!source_class_pattern || !source_method || !target_class_pattern || !target_method)
         return 0;
@@ -217,7 +220,7 @@ function processMethodTriggersMethod(binding, ruleId, methodsByClassId, classNod
     const tgtPattern = new RegExp(target_class_pattern);
     let sourceMethodId;
     let targetMethodId;
-    for (const cls of classNodes) {
+    for (const cls of containerNodes) {
         if (!sourceMethodId && srcPattern.test(cls.properties.name)) {
             const match = (methodsByClassId.get(cls.id) ?? []).find(m => m.properties.name === source_method);
             if (match)
@@ -235,7 +238,7 @@ function processMethodTriggersMethod(binding, ruleId, methodsByClassId, classNod
         return 0;
     return addEdge(sourceMethodId, targetMethodId, `unity-rule-method-bridge:${ruleId}`) ? 1 : 0;
 }
-function processLifecycleOverrides(rule, methodsByClassId, classNodes, addEdge) {
+function processLifecycleOverrides(rule, methodsByClassId, containerNodes, addEdge) {
     const overrides = rule.lifecycle_overrides;
     if (!overrides?.additional_entry_points?.length)
         return 0;
@@ -243,7 +246,7 @@ function processLifecycleOverrides(rule, methodsByClassId, classNodes, addEdge)
     const scopePattern = overrides.scope ? new RegExp(overrides.scope) : null;
     let count = 0;
     const runtimeRootId = generateId('Method', 'unity-runtime-root');
-    for (const cls of classNodes) {
+    for (const cls of containerNodes) {
         if (scopePattern && !scopePattern.test(cls.properties.filePath ?? cls.properties.name))
             continue;
         for (const method of methodsByClassId.get(cls.id) ?? []) {

package/dist/core/ingestion/workers/parse-worker.d.ts

@@ -97,10 +97,12 @@ export interface ParseWorkerResult {
     routes: ExtractedRoute[];
     constructorBindings: FileConstructorBindings[];
     skippedLanguages: Record<string, number>;
+    csharpPreprocFallbackFiles: number;
     fileCount: number;
 }
 export interface ParseWorkerInput {
     path: string;
     content: string;
+    rawContent?: string;
 }
 export {};

package/dist/core/ingestion/workers/parse-worker.js

@@ -14,7 +14,7 @@ import Ruby from 'tree-sitter-ruby';
 import { createRequire } from 'node:module';
 import { SupportedLanguages } from '../../../config/supported-languages.js';
 import { LANGUAGE_QUERIES } from '../tree-sitter-queries.js';
-import { getTreeSitterBufferSize, TREE_SITTER_MAX_BUFFER } from '../constants.js';
+import { TREE_SITTER_MAX_BUFFER } from '../constants.js';
 // tree-sitter-swift is an optionalDependency — may not be installed
 const _require = createRequire(import.meta.url);
 let Swift = null;
@@ -166,6 +166,7 @@ const processBatch = (files, onProgress) => {
         routes: [],
         constructorBindings: [],
         skippedLanguages: {},
+        csharpPreprocFallbackFiles: 0,
         fileCount: 0,
     };
     // Group by language to minimize setLanguage calls
@@ -716,14 +717,56 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
         if (file.content.length > TREE_SITTER_MAX_BUFFER)
             continue;
         let tree;
+        let usedRawContentFallback = false;
         try {
-            tree = parser.parse(file.content, undefined, { bufferSize: getTreeSitterBufferSize(file.content.length) });
+            const MAX_CHUNK = 4096;
+            tree = parser.parse((index) => {
+                if (index >= file.content.length)
+                    return null;
+                return file.content.slice(index, index + MAX_CHUNK);
+            });
         }
         catch (err) {
-            console.warn(`Failed to parse file ${file.path}: ${err instanceof Error ? err.message : String(err)}`);
-            continue;
+            if (file.rawContent && file.rawContent !== file.content) {
+                try {
+                    const MAX_CHUNK = 4096;
+                    tree = parser.parse((index) => {
+                        if (index >= file.rawContent.length)
+                            return null;
+                        return file.rawContent.slice(index, index + MAX_CHUNK);
+                    });
+                    usedRawContentFallback = true;
+                }
+                catch {
+                    console.warn(`Failed to parse file ${file.path}: ${err instanceof Error ? err.message : String(err)}`);
+                    continue;
+                }
+            }
+            else {
+                console.warn(`Failed to parse file ${file.path}: ${err instanceof Error ? err.message : String(err)}`);
+                continue;
+            }
+        }
+        if (file.rawContent && file.rawContent !== file.content && tree.rootNode?.hasError) {
+            try {
+                const MAX_CHUNK = 4096;
+                const rawTree = parser.parse((index) => {
+                    if (index >= file.rawContent.length)
+                        return null;
+                    return file.rawContent.slice(index, index + MAX_CHUNK);
+                });
+                if (!rawTree.rootNode?.hasError) {
+                    tree = rawTree;
+                    usedRawContentFallback = true;
+                }
+            }
+            catch {
+                // Keep normalized parse result when raw fallback parsing fails
+            }
         }
         result.fileCount++;
+        if (usedRawContentFallback)
+            result.csharpPreprocFallbackFiles += 1;
         onFileProcessed?.();
         // Build per-file type environment + constructor bindings in a single AST walk.
         // Constructor bindings are verified against the SymbolTable in processCallsFromExtracted.
@@ -1030,7 +1073,7 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
 /** Accumulated result across sub-batches */
 let accumulated = {
     nodes: [], relationships: [], symbols: [],
-    imports: [], calls: [], heritage: [], routes: [], constructorBindings: [], skippedLanguages: {}, fileCount: 0,
+    imports: [], calls: [], heritage: [], routes: [], constructorBindings: [], skippedLanguages: {}, csharpPreprocFallbackFiles: 0, fileCount: 0,
 };
 let cumulativeProcessed = 0;
 const mergeResult = (target, src) => {
@@ -1045,6 +1088,7 @@ const mergeResult = (target, src) => {
     for (const [lang, count] of Object.entries(src.skippedLanguages)) {
         target.skippedLanguages[lang] = (target.skippedLanguages[lang] || 0) + count;
     }
+    target.csharpPreprocFallbackFiles += src.csharpPreprocFallbackFiles;
     target.fileCount += src.fileCount;
 };
 parentPort.on('message', (msg) => {
@@ -1064,7 +1108,7 @@ parentPort.on('message', (msg) => {
         if (msg && msg.type === 'flush') {
             parentPort.postMessage({ type: 'result', data: accumulated });
             // Reset for potential reuse
-            accumulated = { nodes: [], relationships: [], symbols: [], imports: [], calls: [], heritage: [], routes: [], constructorBindings: [], skippedLanguages: {}, fileCount: 0 };
+            accumulated = { nodes: [], relationships: [], symbols: [], imports: [], calls: [], heritage: [], routes: [], constructorBindings: [], skippedLanguages: {}, csharpPreprocFallbackFiles: 0, fileCount: 0 };
             cumulativeProcessed = 0;
             return;
         }

package/dist/core/tree-sitter/csharp-define-profile.d.ts

@@ -0,0 +1,6 @@
+export interface CSharpDefineProfile {
+    symbols: Set<string>;
+    sourcePath: string;
+    rawDefineConstants: string[];
+}
+export declare function loadCSharpDefineProfileFromCsproj(csprojPath: string): Promise<CSharpDefineProfile>;

package/dist/core/tree-sitter/csharp-define-profile.js

@@ -0,0 +1,43 @@
+import path from 'node:path';
+import fs from 'node:fs/promises';
+const DEFINE_CONSTANTS_RE = /<DefineConstants>\s*([\s\S]*?)\s*<\/DefineConstants>/gi;
+const CSHARP_SYMBOL_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function parseSymbols(rawDefineConstants) {
+    const symbols = new Set();
+    for (const raw of rawDefineConstants) {
+        for (const token of raw.split(';')) {
+            const symbol = token.trim();
+            if (!symbol)
+                continue;
+            // Drop MSBuild placeholders such as $(DefineConstants)
+            if (symbol.includes('$('))
+                continue;
+            if (!CSHARP_SYMBOL_RE.test(symbol))
+                continue;
+            symbols.add(symbol);
+        }
+    }
+    return symbols;
+}
+export async function loadCSharpDefineProfileFromCsproj(csprojPath) {
+    const sourcePath = path.resolve(csprojPath);
+    let content;
+    try {
+        content = await fs.readFile(sourcePath, 'utf-8');
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to read C# csproj: ${sourcePath} (${message})`);
+    }
+    const rawDefineConstants = [];
+    for (const match of content.matchAll(DEFINE_CONSTANTS_RE)) {
+        const raw = (match[1] || '').trim();
+        if (raw)
+            rawDefineConstants.push(raw);
+    }
+    return {
+        symbols: parseSymbols(rawDefineConstants),
+        sourcePath,
+        rawDefineConstants,
+    };
+}

package/dist/core/tree-sitter/csharp-preproc-normalizer.d.ts

@@ -0,0 +1,14 @@
+export interface CSharpPreprocNormalizationDiagnostics {
+    directivesSeen: number;
+    inactiveLines: number;
+    undefinedSymbols: string[];
+    expressionErrors: number;
+    unmatchedEndif: number;
+    unterminatedIfBlocks: number;
+}
+export interface CSharpPreprocNormalizationResult {
+    normalizedText: string;
+    changed: boolean;
+    diagnostics: CSharpPreprocNormalizationDiagnostics;
+}
+export declare function normalizeCSharpPreprocessorBranches(source: string, defines: Set<string>): CSharpPreprocNormalizationResult;

package/dist/core/tree-sitter/csharp-preproc-normalizer.js

@@ -0,0 +1,261 @@
+class ExprParser {
+    tokens;
+    index = 0;
+    defines;
+    undefinedSymbols;
+    constructor(tokens, defines, undefinedSymbols) {
+        this.tokens = tokens;
+        this.defines = defines;
+        this.undefinedSymbols = undefinedSymbols;
+    }
+    parse() {
+        const value = this.parseOr();
+        this.expect('eof');
+        return value;
+    }
+    parseOr() {
+        let value = this.parseAnd();
+        while (this.match('or')) {
+            value = value || this.parseAnd();
+        }
+        return value;
+    }
+    parseAnd() {
+        let value = this.parseUnary();
+        while (this.match('and')) {
+            value = value && this.parseUnary();
+        }
+        return value;
+    }
+    parseUnary() {
+        if (this.match('not')) {
+            return !this.parseUnary();
+        }
+        return this.parsePrimary();
+    }
+    parsePrimary() {
+        if (this.match('lparen')) {
+            const value = this.parseOr();
+            this.expect('rparen');
+            return value;
+        }
+        const token = this.current();
+        if (token.type === 'bool') {
+            this.index += 1;
+            return token.value === 'true';
+        }
+        if (token.type === 'ident') {
+            this.index += 1;
+            const symbol = token.value || '';
+            if (!this.defines.has(symbol))
+                this.undefinedSymbols.add(symbol);
+            return this.defines.has(symbol);
+        }
+        throw new Error(`Unexpected token "${token.type}" in preprocessor expression`);
+    }
+    current() {
+        return this.tokens[this.index] || { type: 'eof' };
+    }
+    match(type) {
+        if (this.current().type !== type)
+            return false;
+        this.index += 1;
+        return true;
+    }
+    expect(type) {
+        if (!this.match(type)) {
+            throw new Error(`Expected token "${type}" in preprocessor expression`);
+        }
+    }
+}
+function tokenizeExpression(expression) {
+    const tokens = [];
+    let i = 0;
+    while (i < expression.length) {
+        const ch = expression[i] || '';
+        if (/\s/.test(ch)) {
+            i += 1;
+            continue;
+        }
+        if (expression.startsWith('&&', i)) {
+            tokens.push({ type: 'and' });
+            i += 2;
+            continue;
+        }
+        if (expression.startsWith('||', i)) {
+            tokens.push({ type: 'or' });
+            i += 2;
+            continue;
+        }
+        if (ch === '!') {
+            tokens.push({ type: 'not' });
+            i += 1;
+            continue;
+        }
+        if (ch === '(') {
+            tokens.push({ type: 'lparen' });
+            i += 1;
+            continue;
+        }
+        if (ch === ')') {
+            tokens.push({ type: 'rparen' });
+            i += 1;
+            continue;
+        }
+        if (/[A-Za-z_]/.test(ch)) {
+            let j = i + 1;
+            while (j < expression.length && /[A-Za-z0-9_]/.test(expression[j] || '')) {
+                j += 1;
+            }
+            const ident = expression.slice(i, j);
+            if (ident === 'true' || ident === 'false') {
+                tokens.push({ type: 'bool', value: ident });
+            }
+            else {
+                tokens.push({ type: 'ident', value: ident });
+            }
+            i = j;
+            continue;
+        }
+        throw new Error(`Unsupported token "${ch}" in preprocessor expression: ${expression}`);
+    }
+    tokens.push({ type: 'eof' });
+    return tokens;
+}
+function evaluateExpression(expression, defines, undefinedSymbols) {
+    if (!expression.trim())
+        return { value: false, ok: false };
+    try {
+        const parser = new ExprParser(tokenizeExpression(expression), defines, undefinedSymbols);
+        return { value: parser.parse(), ok: true };
+    }
+    catch {
+        return { value: false, ok: false };
+    }
+}
+function deriveLineEnding(source) {
+    return source.includes('\r\n') ? '\r\n' : '\n';
+}
+function hasTrailingLineEnding(source) {
+    return /\r?\n$/.test(source);
+}
+export function normalizeCSharpPreprocessorBranches(source, defines) {
+    if (!source.includes('#if') && !source.includes('#elif') && !source.includes('#else') && !source.includes('#endif')) {
+        return {
+            normalizedText: source,
+            changed: false,
+            diagnostics: {
+                directivesSeen: 0,
+                inactiveLines: 0,
+                undefinedSymbols: [],
+                expressionErrors: 0,
+                unmatchedEndif: 0,
+                unterminatedIfBlocks: 0,
+            },
+        };
+    }
+    const lineEnding = deriveLineEnding(source);
+    const trailingLineEnding = hasTrailingLineEnding(source);
+    const lines = source.split(/\r?\n/);
+    const outputLines = [];
+    const stack = [];
+    const undefinedSymbols = new Set();
+    let active = true;
+    let changed = false;
+    let directivesSeen = 0;
+    let inactiveLines = 0;
+    let expressionErrors = 0;
+    let unmatchedEndif = 0;
+    for (const line of lines) {
+        const directive = line.match(/^\s*#\s*(if|elif|else|endif)\b(.*)$/);
+        if (directive) {
+            directivesSeen += 1;
+            changed = true;
+            const keyword = directive[1] || '';
+            const rawExpression = (directive[2] || '').trim();
+            if (keyword === 'if') {
+                const evalResult = evaluateExpression(rawExpression, defines, undefinedSymbols);
+                if (!evalResult.ok)
+                    expressionErrors += 1;
+                const branchActive = active && evalResult.value;
+                stack.push({
+                    parentActive: active,
+                    branchTaken: branchActive,
+                    currentActive: branchActive,
+                    seenElse: false,
+                });
+                active = branchActive;
+            }
+            else if (keyword === 'elif') {
+                const frame = stack[stack.length - 1];
+                if (!frame) {
+                    unmatchedEndif += 1;
+                }
+                else if (frame.seenElse) {
+                    expressionErrors += 1;
+                    frame.currentActive = false;
+                    active = false;
+                }
+                else {
+                    const evalResult = evaluateExpression(rawExpression, defines, undefinedSymbols);
+                    if (!evalResult.ok)
+                        expressionErrors += 1;
+                    const branchActive = frame.parentActive && !frame.branchTaken && evalResult.value;
+                    frame.currentActive = branchActive;
+                    frame.branchTaken = frame.branchTaken || branchActive;
+                    active = frame.currentActive;
+                }
+            }
+            else if (keyword === 'else') {
+                const frame = stack[stack.length - 1];
+                if (!frame) {
+                    unmatchedEndif += 1;
+                }
+                else {
+                    const branchActive = frame.parentActive && !frame.branchTaken;
+                    frame.currentActive = branchActive;
+                    frame.branchTaken = true;
+                    frame.seenElse = true;
+                    active = frame.currentActive;
+                }
+            }
+            else if (keyword === 'endif') {
+                if (stack.length === 0) {
+                    unmatchedEndif += 1;
+                }
+                else {
+                    stack.pop();
+                }
+                const top = stack[stack.length - 1];
+                active = top ? top.currentActive : true;
+            }
+            outputLines.push('');
+            continue;
+        }
+        if (active) {
+            outputLines.push(line);
+            continue;
+        }
+        if (line.length > 0) {
+            changed = true;
+            inactiveLines += 1;
+        }
+        outputLines.push('');
+    }
+    let normalizedText = outputLines.join(lineEnding);
+    if (trailingLineEnding && !normalizedText.endsWith(lineEnding)) {
+        normalizedText += lineEnding;
+    }
+    return {
+        normalizedText,
+        changed,
+        diagnostics: {
+            directivesSeen,
+            inactiveLines,
+            undefinedSymbols: [...undefinedSymbols].sort(),
+            expressionErrors,
+            unmatchedEndif,
+            unterminatedIfBlocks: stack.length,
+        },
+    };
+}

package/dist/core/tree-sitter/parser-loader.d.ts

@@ -3,3 +3,13 @@ import { SupportedLanguages } from '../../config/supported-languages.js';
 export declare const isLanguageAvailable: (language: SupportedLanguages) => boolean;
 export declare const loadParser: () => Promise<Parser>;
 export declare const loadLanguage: (language: SupportedLanguages, filePath?: string) => Promise<void>;
+/**
+ * Parse source code using tree-sitter's chunked callback API.
+ * Avoids the native binding's single-buffer size limit (< 32768 bytes)
+ * that causes "Invalid argument" errors on large files.
+ *
+ * @param content - Full source file content as UTF-8 string
+ * @param oldTree - Optional previous tree for incremental parsing (must call tree.edit() first)
+ * @returns Parsed syntax tree
+ */
+export declare const parseContent: (content: string, oldTree?: any) => any;

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

@@ -61,3 +61,22 @@ export const loadLanguage = async (language, filePath) => {
     }
     parser.setLanguage(lang);
 };
+const MAX_CHUNK = 4096;
+/**
+ * Parse source code using tree-sitter's chunked callback API.
+ * Avoids the native binding's single-buffer size limit (< 32768 bytes)
+ * that causes "Invalid argument" errors on large files.
+ *
+ * @param content - Full source file content as UTF-8 string
+ * @param oldTree - Optional previous tree for incremental parsing (must call tree.edit() first)
+ * @returns Parsed syntax tree
+ */
+export const parseContent = (content, oldTree) => {
+    if (!parser)
+        throw new Error('Parser not initialized — call loadParser() first');
+    return parser.parse((index) => {
+        if (index >= content.length)
+            return null;
+        return content.slice(index, index + MAX_CHUNK);
+    }, oldTree);
+};

package/dist/types/pipeline.d.ts

@@ -18,6 +18,17 @@ export interface PipelineProgress {
 export interface PipelineRunOptions {
     includeExtensions?: string[];
     scopeRules?: string[];
+    csharpDefineCsproj?: string;
+}
+export interface CSharpPreprocDiagnostics {
+    enabled: boolean;
+    sourcePath?: string;
+    defineSymbolCount: number;
+    normalizedFiles: number;
+    fallbackFiles: number;
+    skippedFiles: number;
+    expressionErrors: number;
+    undefinedSymbols: string[];
 }
 export interface PipelineResult {
     graph: KnowledgeGraph;
@@ -29,6 +40,7 @@ export interface PipelineResult {
     processResult?: ProcessDetectionResult;
     unityResult?: UnityResourceProcessingResult;
     scopeDiagnostics?: ScopeSelectionDiagnostics;
+    csharpPreprocDiagnostics?: CSharpPreprocDiagnostics;
 }
 export interface PipelineRuntimeSummary {
     totalFileCount: number;
@@ -36,6 +48,7 @@ export interface PipelineRuntimeSummary {
     processResult?: ProcessDetectionResult;
     unityResult?: UnityResourceProcessingResult;
     scopeDiagnostics?: ScopeSelectionDiagnostics;
+    csharpPreprocDiagnostics?: CSharpPreprocDiagnostics;
 }
 export interface SerializablePipelineResult {
     nodes: GraphNode[];