@veewo/gitnexus 1.5.0-rc.4 → 1.5.1

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/core/unity/doc-contract.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/unity/doc-contract.test.js

@@ -0,0 +1,30 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const here = path.dirname(fileURLToPath(import.meta.url));
+const gitnexusRoot = path.resolve(here, '../../..');
+const repoRoot = path.resolve(gitnexusRoot, '..');
+test('scan-context carrier contract matches code and docs', async () => {
+    const bindingDoc = await fs.readFile(path.join(repoRoot, 'UNITY_RESOURCE_BINDING.md'), 'utf-8');
+    const ssot = await fs.readFile(path.join(repoRoot, 'docs/unity-runtime-process-source-of-truth.md'), 'utf-8');
+    const design = await fs.readFile(path.join(repoRoot, 'docs/plans/2026-04-10-prefab-source-streaming-consumption-memory-optimization-design.md'), 'utf-8');
+    const scanContextCode = await fs.readFile(path.join(gitnexusRoot, 'src/core/unity/scan-context.ts'), 'utf-8');
+    const processorCode = await fs.readFile(path.join(gitnexusRoot, 'src/core/ingestion/unity-resource-processor.ts'), 'utf-8');
+    const pipelineCode = await fs.readFile(path.join(gitnexusRoot, 'src/core/ingestion/pipeline.ts'), 'utf-8');
+    assert.match(bindingDoc, /scan-context.*承载器|resource signal carrier|scan-context.*carrier/i);
+    assert.match(bindingDoc, /streaming delivery|incremental consumption/i);
+    assert.match(ssot, /As-Built[\s\S]*Design Direction/i);
+    assert.match(ssot, /scan-context[\s\S]*does not write graph/i);
+    assert.match(ssot, /统一消费点契约/i);
+    assert.match(design, /scan-context[\s\S]*(统一消费|unified consumer)/i);
+    assert.match(scanContextCode, /streamPrefabSourceRefs/);
+    assert.match(processorCode, /streamPrefabSourceRefs\(/);
+    assert.match(processorCode, /emitPrefabSourceGuidRefsFromScanContext/);
+    assert.doesNotMatch(processorCode, /emitPrefabSourceGuidRefs\(/);
+    assert.doesNotMatch(scanContextCode, /addRelationship\(/);
+    assert.ok(pipelineCode.indexOf('processUnityResources(') >= 0
+        && pipelineCode.indexOf('applyUnityLifecycleSyntheticCalls(') >= 0
+        && pipelineCode.indexOf('processUnityResources(') < pipelineCode.indexOf('applyUnityLifecycleSyntheticCalls('));
+});

package/dist/core/unity/prefab-source-scan.d.ts

@@ -0,0 +1,25 @@
+export interface PrefabSourceScanRow {
+    sourceResourcePath: string;
+    targetGuid: string;
+    targetResourcePath?: string;
+    fileId?: string;
+    fieldName: 'm_SourcePrefab';
+    sourceLayer: 'scene' | 'prefab';
+}
+export interface StreamPrefabSourceRefsInput {
+    repoRoot: string;
+    resourceFiles: string[];
+    assetGuidToPath: Map<string, string>;
+    queue?: {
+        enabled?: boolean;
+        maxDepth?: number;
+    };
+    hooks?: {
+        onFileOpen?: (resourcePath: string) => void;
+        onYield?: (row: PrefabSourceScanRow) => void;
+        onQueueDepth?: (depth: number) => void;
+        onFileError?: (resourcePath: string, error: unknown) => void;
+    };
+}
+export declare function collectPrefabSourceRefs(args: StreamPrefabSourceRefsInput): Promise<PrefabSourceScanRow[]>;
+export declare function streamPrefabSourceRefs(args: StreamPrefabSourceRefsInput): AsyncGenerator<PrefabSourceScanRow>;

package/dist/core/unity/prefab-source-scan.js

@@ -0,0 +1,152 @@
+import { createReadStream } from 'node:fs';
+import path from 'node:path';
+import { createInterface } from 'node:readline';
+const PREFAB_INSTANCE_PATTERN = /^\s*PrefabInstance:\s*$/;
+const YAML_OBJECT_BOUNDARY_PATTERN = /^\s*---\s*!u!\d+\s+&/;
+const SOURCE_PREFAB_LINE_PATTERN = /m_SourcePrefab\s*:\s*\{[^}]*fileID\s*:\s*([^,\s}]+)[^}]*guid\s*:\s*([0-9a-fA-F]{32})[^}]*\}/;
+const ZERO_GUID = '00000000000000000000000000000000';
+export async function collectPrefabSourceRefs(args) {
+    const rows = [];
+    for await (const row of streamPrefabSourceRefs(args)) {
+        rows.push(row);
+    }
+    return rows;
+}
+export async function* streamPrefabSourceRefs(args) {
+    const resources = [...new Set((args.resourceFiles || []).map((value) => normalizePath(value)))]
+        .filter((value) => value.endsWith('.unity') || value.endsWith('.prefab'));
+    if (!args.queue?.enabled) {
+        for await (const row of streamPrefabSourceRefsSequential(resources, args)) {
+            yield row;
+        }
+        return;
+    }
+    const maxDepth = Math.max(1, Number(args.queue.maxDepth || 64));
+    const queue = [];
+    const waitingReaders = [];
+    const waitingWriters = [];
+    let producerDone = false;
+    let producerError;
+    const notifyDepth = () => args.hooks?.onQueueDepth?.(queue.length);
+    const push = async (row) => {
+        while (queue.length >= maxDepth) {
+            await new Promise((resolve) => waitingWriters.push(resolve));
+        }
+        if (waitingReaders.length > 0) {
+            const resolveReader = waitingReaders.shift();
+            resolveReader(row);
+            return;
+        }
+        queue.push(row);
+        notifyDepth();
+    };
+    const shift = async () => {
+        if (queue.length > 0) {
+            const value = queue.shift();
+            notifyDepth();
+            const resolveWriter = waitingWriters.shift();
+            if (resolveWriter)
+                resolveWriter();
+            return value;
+        }
+        if (producerDone) {
+            return null;
+        }
+        return await new Promise((resolve) => waitingReaders.push(resolve));
+    };
+    const finishReaders = () => {
+        while (waitingReaders.length > 0) {
+            const resolveReader = waitingReaders.shift();
+            resolveReader(null);
+        }
+    };
+    const finishWriters = () => {
+        while (waitingWriters.length > 0) {
+            const resolveWriter = waitingWriters.shift();
+            resolveWriter();
+        }
+    };
+    const producer = (async () => {
+        try {
+            for await (const row of streamPrefabSourceRefsSequential(resources, args)) {
+                await push(row);
+            }
+        }
+        catch (error) {
+            producerError = error;
+        }
+        finally {
+            producerDone = true;
+            finishReaders();
+            finishWriters();
+        }
+    })();
+    while (true) {
+        const row = await shift();
+        if (!row)
+            break;
+        yield row;
+    }
+    await producer;
+    if (producerError) {
+        throw producerError;
+    }
+}
+async function* streamPrefabSourceRefsSequential(resources, args) {
+    const hooks = args.hooks;
+    for (const resourcePath of resources) {
+        hooks?.onFileOpen?.(resourcePath);
+        const absolutePath = path.join(args.repoRoot, resourcePath);
+        const stream = createReadStream(absolutePath, { encoding: 'utf-8' });
+        const reader = createInterface({
+            input: stream,
+            crlfDelay: Infinity,
+        });
+        try {
+            let inPrefabInstance = false;
+            for await (const line of reader) {
+                if (YAML_OBJECT_BOUNDARY_PATTERN.test(line)) {
+                    inPrefabInstance = false;
+                }
+                if (PREFAB_INSTANCE_PATTERN.test(line)) {
+                    inPrefabInstance = true;
+                    continue;
+                }
+                if (!inPrefabInstance)
+                    continue;
+                const match = line.match(SOURCE_PREFAB_LINE_PATTERN);
+                if (!match)
+                    continue;
+                const fileId = String(match[1] || '').trim();
+                const guid = String(match[2] || '').trim().toLowerCase();
+                if (!guid || guid === ZERO_GUID)
+                    continue;
+                const targetResourcePath = normalizePath(args.assetGuidToPath.get(guid) || args.assetGuidToPath.get(guid.toLowerCase()) || '');
+                if (!targetResourcePath || !targetResourcePath.endsWith('.prefab'))
+                    continue;
+                const row = {
+                    sourceResourcePath: resourcePath,
+                    targetGuid: guid,
+                    targetResourcePath,
+                    fileId: fileId || undefined,
+                    fieldName: 'm_SourcePrefab',
+                    sourceLayer: resourcePath.endsWith('.unity') ? 'scene' : 'prefab',
+                };
+                hooks?.onYield?.(row);
+                yield row;
+                inPrefabInstance = false;
+            }
+        }
+        catch (error) {
+            hooks?.onFileError?.(resourcePath, error);
+            continue;
+        }
+        finally {
+            reader.close();
+            stream.destroy();
+        }
+    }
+}
+function normalizePath(value) {
+    return String(value || '').replace(/\\/g, '/').trim();
+}

package/dist/core/unity/prefab-source-scan.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/unity/prefab-source-scan.test.js

@@ -0,0 +1,70 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { streamPrefabSourceRefs } from './prefab-source-scan.js';
+const here = path.dirname(fileURLToPath(import.meta.url));
+const fixtureRoot = path.resolve(here, '../../../src/core/unity/__fixtures__/mini-unity');
+const assetGuidToPath = new Map([['99999999999999999999999999999999', 'Assets/Prefabs/BattleMode.prefab']]);
+const scopedFiles = ['Assets/Scene/MainUIManager.unity', 'Assets/Prefabs/BattleMode.prefab'];
+test('same source can yield prefab-source rows while script-guid flow remains independent', async () => {
+    const rows = [];
+    for await (const row of streamPrefabSourceRefs({
+        repoRoot: fixtureRoot,
+        resourceFiles: ['Assets/Scene/MainUIManager.unity'],
+        assetGuidToPath,
+    })) {
+        rows.push(row);
+    }
+    assert.ok(rows.length > 0);
+    assert.equal(rows.every((r) => r.fieldName === 'm_SourcePrefab'), true);
+});
+test('streamPrefabSourceRefs does not open second file before first row is yielded', async () => {
+    const probe = [];
+    const iterator = streamPrefabSourceRefs({
+        repoRoot: fixtureRoot,
+        resourceFiles: scopedFiles,
+        assetGuidToPath,
+        hooks: {
+            onFileOpen: (filePath) => probe.push(`open:${filePath}`),
+            onYield: () => probe.push('yield'),
+        },
+    })[Symbol.asyncIterator]();
+    const first = await iterator.next();
+    assert.equal(first.done, false);
+    assert.equal(first.value.fieldName, 'm_SourcePrefab');
+    assert.equal(probe.includes('open:Assets/Prefabs/BattleMode.prefab'), false);
+    await iterator.return?.(undefined);
+});
+test('producer rows are immutable snapshots (consumer mutation does not backflow)', async () => {
+    for await (const row of streamPrefabSourceRefs({
+        repoRoot: fixtureRoot,
+        resourceFiles: scopedFiles,
+        assetGuidToPath,
+    })) {
+        const copy = { ...row };
+        copy.targetResourcePath = '__PLACEHOLDER__';
+    }
+    const again = [];
+    for await (const row of streamPrefabSourceRefs({
+        repoRoot: fixtureRoot,
+        resourceFiles: scopedFiles,
+        assetGuidToPath,
+    })) {
+        again.push(row);
+    }
+    assert.equal(again.some((r) => r.targetResourcePath === '__PLACEHOLDER__'), false);
+});
+test('bounded queue backpressure never exceeds configured depth when decoupled mode is enabled', async () => {
+    const depthSamples = [];
+    for await (const _row of streamPrefabSourceRefs({
+        repoRoot: fixtureRoot,
+        resourceFiles: scopedFiles,
+        assetGuidToPath,
+        queue: { enabled: true, maxDepth: 64 },
+        hooks: { onQueueDepth: (depth) => depthSamples.push(depth) },
+    })) {
+        await new Promise((resolve) => setTimeout(resolve, 1));
+    }
+    assert.equal(depthSamples.every((depth) => depth <= 64), true);
+});

package/dist/core/unity/scan-context.d.ts

@@ -1,3 +1,4 @@
+import type { StreamPrefabSourceRefsInput } from './prefab-source-scan.js';
 import type { UnityResourceGuidHit } from './resource-hit-scanner.js';
 import type { UnityObjectBlock } from './yaml-object-graph.js';
 import type { UnityParitySeed } from '../ingestion/unity-parity-seed.js';
@@ -10,6 +11,14 @@ export interface UnitySymbolDeclaration {
     symbol: string;
     scriptPath: string;
 }
+export interface UnityPrefabSourceRef {
+    sourceResourcePath: string;
+    targetGuid: string;
+    targetResourcePath?: string;
+    fileId?: string;
+    fieldName: 'm_SourcePrefab';
+    sourceLayer: 'scene' | 'prefab';
+}
 export interface UnityScanContext {
     symbolToScriptPaths: Map<string, string[]>;
     symbolToCanonicalScriptPath: Map<string, string>;
@@ -21,6 +30,9 @@ export interface UnityScanContext {
     assetGuidToPath?: Map<string, string>;
     uxmlGuidToPath?: Map<string, string>;
     ussGuidToPath?: Map<string, string>;
+    prefabSourceRefs: UnityPrefabSourceRef[];
+    streamPrefabSourceRefs: (options?: Pick<StreamPrefabSourceRefsInput, 'queue' | 'hooks'>) => AsyncIterable<UnityPrefabSourceRef>;
+    resourceFiles: string[];
     resourceDocCache: Map<string, UnityObjectBlock[]>;
 }
 export declare function buildUnityScanContext(input: BuildScanContextInput): Promise<UnityScanContext>;