@veewo/gitnexus 1.3.10 → 1.3.11

package/dist/core/unity/scan-context.js

@@ -1,11 +1,13 @@
 import fs from 'node:fs/promises';
+import { createReadStream } from 'node:fs';
 import path from 'node:path';
+import { createInterface } from 'node:readline';
 import { glob } from 'glob';
 import { buildAssetMetaIndex, buildMetaIndex } from './meta-index.js';
-import { buildSerializableTypeIndexFromSources } from './serialized-type-index.js';
+import { buildSerializableTypeIndexFromFiles } from './serialized-type-index.js';
 const DECLARATION_PATTERN = /\b(?:class|struct|interface)\s+([A-Za-z_][A-Za-z0-9_]*)\b/g;
-const GUID_IN_LINE_PATTERN = /\bguid:\s*([0-9a-f]{32})\b/gi;
-const RESOURCE_HIT_SCAN_CONCURRENCY = 16;
+const SCRIPT_GUID_IN_LINE_PATTERN = /\bm_Script\s*:\s*\{[^}]*\bguid\s*:\s*([0-9a-f]{32})\b/gi;
+const RESOURCE_HIT_SCAN_CONCURRENCY = 4;
 export async function buildUnityScanContext(input) {
     const scriptFiles = input.symbolDeclarations && input.symbolDeclarations.length > 0
         ? resolveScriptFilesFromSymbolDeclarations(input.repoRoot, input.symbolDeclarations, input.scopedPaths)
@@ -13,8 +15,13 @@ export async function buildUnityScanContext(input) {
     const symbolToScriptPaths = input.symbolDeclarations && input.symbolDeclarations.length > 0
         ? buildSymbolScriptPathIndexFromDeclarations(input.repoRoot, input.symbolDeclarations, input.scopedPaths)
         : await buildSymbolScriptPathIndex(input.repoRoot, scriptFiles);
-    const scriptSources = await loadScriptSources(input.repoRoot, scriptFiles);
-    const serializableTypeIndex = buildSerializableTypeIndexFromSources(scriptSources);
+    const serializableTypeIndex = await buildSerializableTypeIndexFromFiles(scriptFiles.map((scriptPath) => {
+        const normalizedPath = normalizeSlashes(scriptPath);
+        return {
+            filePath: normalizedPath,
+            read: async () => fs.readFile(path.join(input.repoRoot, normalizedPath), 'utf-8'),
+        };
+    }));
     const metaFiles = scriptFiles.map((scriptPath) => `${scriptPath}.meta`);
     const guidToScriptPath = await buildMetaIndex(input.repoRoot, { metaFiles });
     const scriptPathToGuid = new Map();
@@ -39,21 +46,91 @@ export async function buildUnityScanContext(input) {
         resourceDocCache: new Map(),
     };
 }
-async function loadScriptSources(repoRoot, scriptFiles) {
-    const sources = [];
-    for (const scriptPath of scriptFiles) {
+export function buildUnityScanContextFromSeed(input) {
+    const seed = input.seed;
+    const requestedSymbols = new Set((input.symbolDeclarations || [])
+        .map((entry) => String(entry.symbol || '').trim())
+        .filter((value) => value.length > 0));
+    const requestedScripts = new Set((input.symbolDeclarations || [])
+        .map((entry) => normalizeSlashes(String(entry.scriptPath || '').trim()))
+        .filter((value) => value.length > 0));
+    const symbolToScriptPath = new Map();
+    for (const [symbol, scriptPath] of Object.entries(seed.symbolToScriptPath || {})) {
         const normalizedPath = normalizeSlashes(scriptPath);
-        try {
-            const content = await fs.readFile(path.join(repoRoot, normalizedPath), 'utf-8');
-            sources.push({ filePath: normalizedPath, content });
+        if (!normalizedPath)
+            continue;
+        if (requestedSymbols.size > 0 && !requestedSymbols.has(symbol))
+            continue;
+        symbolToScriptPath.set(symbol, normalizedPath);
+        requestedScripts.add(normalizedPath);
+    }
+    if (symbolToScriptPath.size === 0 && requestedSymbols.size > 0) {
+        for (const declaration of input.symbolDeclarations || []) {
+            const symbol = String(declaration.symbol || '').trim();
+            const scriptPath = normalizeSlashes(String(declaration.scriptPath || '').trim());
+            if (!symbol || !scriptPath)
+                continue;
+            symbolToScriptPath.set(symbol, scriptPath);
+            requestedScripts.add(scriptPath);
         }
-        catch (error) {
-            if (error.code === 'ENOENT')
+    }
+    const symbolToCanonicalScriptPath = new Map(symbolToScriptPath);
+    const symbolToScriptPaths = new Map();
+    for (const [symbol, scriptPath] of symbolToScriptPath.entries()) {
+        symbolToScriptPaths.set(symbol, [scriptPath]);
+    }
+    const scriptPathToGuid = new Map();
+    const normalizedScriptPathToGuidEntries = Object.entries(seed.scriptPathToGuid || {})
+        .map(([scriptPath, guid]) => [normalizeSlashes(scriptPath), String(guid || '').trim()])
+        .filter(([scriptPath, guid]) => scriptPath.length > 0 && guid.length > 0);
+    for (const [scriptPath, guid] of normalizedScriptPathToGuidEntries) {
+        if (requestedScripts.size > 0 && !requestedScripts.has(scriptPath))
+            continue;
+        scriptPathToGuid.set(scriptPath, guid);
+    }
+    if (scriptPathToGuid.size === 0 && requestedScripts.size > 0) {
+        for (const [scriptPath, guid] of normalizedScriptPathToGuidEntries) {
+            if (!requestedScripts.has(scriptPath))
                 continue;
-            throw error;
+            scriptPathToGuid.set(scriptPath, guid);
+        }
+    }
+    const selectedGuids = new Set(scriptPathToGuid.values());
+    const guidToResourceHits = new Map();
+    for (const [guid, resourcePaths] of Object.entries(seed.guidToResourcePaths || {})) {
+        if (selectedGuids.size > 0 && !selectedGuids.has(guid))
+            continue;
+        const hits = (resourcePaths || [])
+            .map((resourcePathRaw) => normalizeSlashes(String(resourcePathRaw || '').trim()))
+            .filter((resourcePath) => resourcePath.length > 0)
+            .map((resourcePath) => ({
+            resourcePath,
+            resourceType: inferResourceType(resourcePath),
+            line: 0,
+            lineText: 'seed',
+        }));
+        if (hits.length > 0) {
+            guidToResourceHits.set(guid, hits);
         }
     }
-    return sources;
+    const assetGuidToPath = new Map();
+    for (const [guid, assetPath] of Object.entries(seed.assetGuidToPath || {})) {
+        const normalizedPath = normalizeSlashes(String(assetPath || '').trim());
+        if (!guid || !normalizedPath)
+            continue;
+        assetGuidToPath.set(guid, normalizedPath);
+    }
+    return {
+        symbolToScriptPaths,
+        symbolToCanonicalScriptPath,
+        symbolToScriptPath,
+        scriptPathToGuid,
+        guidToResourceHits,
+        serializableSymbols: new Set(),
+        hostFieldTypeHints: new Map(),
+        assetGuidToPath,
+        resourceDocCache: new Map(),
+    };
 }
 async function buildSymbolScriptPathIndex(repoRoot, scriptFiles) {
     const candidates = new Map();
@@ -93,53 +170,65 @@ async function buildGuidHitIndex(repoRoot, scriptPathToGuid, resourceFiles) {
     }
     const perResourceHits = await mapWithConcurrency(resourceFiles, RESOURCE_HIT_SCAN_CONCURRENCY, async (resourcePathRaw) => {
         const resourcePath = normalizeSlashes(resourcePathRaw);
-        const absolutePath = path.join(repoRoot, resourcePath);
-        let content = '';
-        try {
-            content = await fs.readFile(absolutePath, 'utf-8');
-        }
-        catch (error) {
-            const code = error.code;
-            if (code === 'ENOENT' || code === 'EISDIR') {
-                return new Map();
-            }
-            throw error;
-        }
         const resourceType = inferResourceType(resourcePath);
-        const lines = content.split(/\r?\n/);
         const hits = new Map();
-        for (let index = 0; index < lines.length; index += 1) {
-            const line = lines[index];
+        await scanGuidHitsInResourceFile(repoRoot, resourcePath, resourceType, guidLookup, hits);
+        return hits;
+    });
+    const guidToResourceHits = new Map();
+    for (const hitMap of perResourceHits) {
+        for (const [guid, hits] of hitMap.entries()) {
+            const existing = guidToResourceHits.get(guid) || [];
+            existing.push(...hits);
+            guidToResourceHits.set(guid, existing);
+        }
+    }
+    return guidToResourceHits;
+}
+async function scanGuidHitsInResourceFile(repoRoot, resourcePath, resourceType, guidLookup, hits) {
+    const absolutePath = path.join(repoRoot, resourcePath);
+    const stream = createReadStream(absolutePath, { encoding: 'utf-8' });
+    const reader = createInterface({
+        input: stream,
+        crlfDelay: Infinity,
+    });
+    const seenGuidInResource = new Set();
+    let lineNumber = 0;
+    try {
+        for await (const line of reader) {
+            lineNumber += 1;
             const seenCanonical = new Set();
-            GUID_IN_LINE_PATTERN.lastIndex = 0;
-            let match = GUID_IN_LINE_PATTERN.exec(line);
+            SCRIPT_GUID_IN_LINE_PATTERN.lastIndex = 0;
+            let match = SCRIPT_GUID_IN_LINE_PATTERN.exec(line);
             while (match) {
                 const canonicalGuid = guidLookup.get(match[1].toLowerCase());
-                if (canonicalGuid && !seenCanonical.has(canonicalGuid)) {
+                if (canonicalGuid && !seenCanonical.has(canonicalGuid) && !seenGuidInResource.has(canonicalGuid)) {
                     seenCanonical.add(canonicalGuid);
+                    seenGuidInResource.add(canonicalGuid);
                     const existing = hits.get(canonicalGuid) || [];
                     existing.push({
                         resourcePath,
                         resourceType,
-                        line: index + 1,
+                        line: lineNumber,
                         lineText: line,
                     });
                     hits.set(canonicalGuid, existing);
                 }
-                match = GUID_IN_LINE_PATTERN.exec(line);
+                match = SCRIPT_GUID_IN_LINE_PATTERN.exec(line);
             }
         }
-        return hits;
-    });
-    const guidToResourceHits = new Map();
-    for (const hitMap of perResourceHits) {
-        for (const [guid, hits] of hitMap.entries()) {
-            const existing = guidToResourceHits.get(guid) || [];
-            existing.push(...hits);
-            guidToResourceHits.set(guid, existing);
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === 'ENOENT' || code === 'EISDIR') {
+            return;
         }
+        throw error;
+    }
+    finally {
+        reader.close();
+        stream.destroy();
     }
-    return guidToResourceHits;
 }
 async function resolveScriptFiles(repoRoot, scopedPaths) {
     if (!scopedPaths || scopedPaths.length === 0) {

package/dist/core/unity/scan-context.test.js

@@ -4,7 +4,7 @@ import path from 'node:path';
 import os from 'node:os';
 import fs from 'node:fs/promises';
 import { fileURLToPath } from 'node:url';
-import { buildUnityScanContext } from './scan-context.js';
+import { buildUnityScanContext, buildUnityScanContextFromSeed } from './scan-context.js';
 import { resolveUnityBindings } from './resolver.js';
 const here = path.dirname(fileURLToPath(import.meta.url));
 const fixtureRoot = path.resolve(here, '../../../src/core/unity/__fixtures__/mini-unity');
@@ -74,7 +74,7 @@ test('buildUnityScanContext selects canonical script for duplicated symbol decla
         await fs.writeFile(path.join(scriptsDir, 'PlayerActor.Visual.cs'), 'public partial class PlayerActor {}', 'utf-8');
         await fs.writeFile(path.join(scriptsDir, 'PlayerActor.cs.meta'), 'guid: 11111111111111111111111111111111\n', 'utf-8');
         await fs.writeFile(path.join(scriptsDir, 'PlayerActor.Visual.cs.meta'), 'guid: 22222222222222222222222222222222\n', 'utf-8');
-        await fs.writeFile(path.join(sceneDir, 'Test.unity'), '--- !u!1 &1\nguid: 11111111111111111111111111111111\n', 'utf-8');
+        await fs.writeFile(path.join(sceneDir, 'Test.unity'), '--- !u!114 &1\nMonoBehaviour:\n  m_Script: {fileID: 11500000, guid: 11111111111111111111111111111111, type: 3}\n', 'utf-8');
         const context = await buildUnityScanContext({
             repoRoot: tempRoot,
             symbolDeclarations: [
@@ -116,3 +116,42 @@ test('buildUnityScanContext exposes serializable symbol index and host field typ
         await fs.rm(tempRoot, { recursive: true, force: true });
     }
 });
+test('buildUnityScanContext builds serializable index from files without preloading source array', async () => {
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-serializable-streaming-'));
+    const scriptsDir = path.join(tempRoot, 'Assets/Scripts');
+    await fs.mkdir(scriptsDir, { recursive: true });
+    try {
+        await fs.writeFile(path.join(scriptsDir, 'AssetRef.cs'), '[Serializable] class AssetRef {}', 'utf-8');
+        await fs.writeFile(path.join(scriptsDir, 'Host.cs'), 'class Host { AssetRef icon; }', 'utf-8');
+        const context = await buildUnityScanContext({ repoRoot: tempRoot });
+        assert.equal(context.serializableSymbols.has('AssetRef'), true);
+        assert.equal(context.hostFieldTypeHints.get('Host')?.get('icon'), 'AssetRef');
+    }
+    finally {
+        await fs.rm(tempRoot, { recursive: true, force: true });
+    }
+});
+test('buildUnityScanContextFromSeed reconstructs lookup maps for resolver fast path', async () => {
+    const context = buildUnityScanContextFromSeed({
+        seed: {
+            version: 1,
+            symbolToScriptPath: {
+                MainUIManager: 'Assets/Scripts/MainUIManager.cs',
+            },
+            scriptPathToGuid: {
+                'Assets/Scripts/MainUIManager.cs': '11111111111111111111111111111111',
+            },
+            guidToResourcePaths: {
+                '11111111111111111111111111111111': ['Assets/Scene/MainUIManager.unity'],
+            },
+            assetGuidToPath: {
+                '44444444444444444444444444444444': 'Assets/Config/MainUIDocument.asset',
+            },
+        },
+        symbolDeclarations: [{ symbol: 'MainUIManager', scriptPath: 'Assets/Scripts/MainUIManager.cs' }],
+    });
+    assert.equal(context.symbolToScriptPath.get('MainUIManager'), 'Assets/Scripts/MainUIManager.cs');
+    assert.equal(context.scriptPathToGuid.get('Assets/Scripts/MainUIManager.cs'), '11111111111111111111111111111111');
+    assert.equal(context.guidToResourceHits.get('11111111111111111111111111111111')?.length, 1);
+    assert.equal(context.assetGuidToPath?.get('44444444444444444444444444444444'), 'Assets/Config/MainUIDocument.asset');
+});

package/dist/core/unity/serialized-type-index.d.ts

@@ -6,5 +6,10 @@ interface SourceFile {
     filePath: string;
     content: string;
 }
+interface SourceFileReader {
+    filePath: string;
+    read: () => Promise<string>;
+}
 export declare function buildSerializableTypeIndexFromSources(sources: SourceFile[]): SerializableTypeIndex;
+export declare function buildSerializableTypeIndexFromFiles(files: SourceFileReader[]): Promise<SerializableTypeIndex>;
 export {};

package/dist/core/unity/serialized-type-index.js

@@ -4,25 +4,56 @@ const FIELD_DECLARATION_PATTERN = /(?:\[[^\]]+\]\s*)*(?:(?:public|private|protec
 export function buildSerializableTypeIndexFromSources(sources) {
     const serializableSymbols = new Set();
     for (const source of sources) {
-        SERIALIZABLE_DECLARATION_PATTERN.lastIndex = 0;
-        let match = SERIALIZABLE_DECLARATION_PATTERN.exec(source.content);
-        while (match) {
-            serializableSymbols.add(match[1]);
-            match = SERIALIZABLE_DECLARATION_PATTERN.exec(source.content);
-        }
+        collectSerializableDeclarations(source.content, serializableSymbols);
     }
     const hostFieldTypeHints = new Map();
     for (const source of sources) {
-        const classBodies = extractClassBodies(source.content);
-        for (const classBody of classBodies) {
-            const fieldHints = extractHostFieldHints(classBody.body, serializableSymbols);
-            if (fieldHints.size > 0) {
-                hostFieldTypeHints.set(classBody.name, fieldHints);
-            }
-        }
+        collectHostFieldTypeHints(source.content, serializableSymbols, hostFieldTypeHints);
+    }
+    return { serializableSymbols, hostFieldTypeHints };
+}
+export async function buildSerializableTypeIndexFromFiles(files) {
+    const serializableSymbols = new Set();
+    for (const file of files) {
+        const content = await safeReadFileContent(file);
+        collectSerializableDeclarations(content, serializableSymbols);
+    }
+    const hostFieldTypeHints = new Map();
+    for (const file of files) {
+        const content = await safeReadFileContent(file);
+        collectHostFieldTypeHints(content, serializableSymbols, hostFieldTypeHints);
     }
     return { serializableSymbols, hostFieldTypeHints };
 }
+function collectSerializableDeclarations(content, serializableSymbols) {
+    SERIALIZABLE_DECLARATION_PATTERN.lastIndex = 0;
+    let match = SERIALIZABLE_DECLARATION_PATTERN.exec(content);
+    while (match) {
+        serializableSymbols.add(match[1]);
+        match = SERIALIZABLE_DECLARATION_PATTERN.exec(content);
+    }
+}
+function collectHostFieldTypeHints(content, serializableSymbols, hostFieldTypeHints) {
+    const classBodies = extractClassBodies(content);
+    for (const classBody of classBodies) {
+        const fieldHints = extractHostFieldHints(classBody.body, serializableSymbols);
+        if (fieldHints.size > 0) {
+            hostFieldTypeHints.set(classBody.name, fieldHints);
+        }
+    }
+}
+async function safeReadFileContent(file) {
+    try {
+        return await file.read();
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === 'ENOENT' || code === 'EISDIR') {
+            return '';
+        }
+        throw error;
+    }
+}
 function extractClassBodies(content) {
     const result = [];
     CLASS_DECLARATION_PATTERN.lastIndex = 0;

package/dist/core/unity/serialized-type-index.test.js

@@ -1,6 +1,6 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
-import { buildSerializableTypeIndexFromSources } from './serialized-type-index.js';
+import { buildSerializableTypeIndexFromFiles, buildSerializableTypeIndexFromSources } from './serialized-type-index.js';
 test('buildSerializableTypeIndex extracts serializable symbols and host field declared types', () => {
     const index = buildSerializableTypeIndexFromSources([
         {
@@ -32,3 +32,11 @@ test('buildSerializableTypeIndex extracts serializable symbols and host field de
     assert.equal(index.hostFieldTypeHints.get('InventoryConfig')?.get('iconVariants'), 'AssetRef');
     assert.equal(index.hostFieldTypeHints.get('InventoryConfig')?.has('ignored'), false);
 });
+test('buildSerializableTypeIndexFromFiles does not require preloaded source array', async () => {
+    const out = await buildSerializableTypeIndexFromFiles([
+        { filePath: 'Assets/A.cs', read: async () => '[Serializable] class AssetRef {}' },
+        { filePath: 'Assets/B.cs', read: async () => 'class Host { AssetRef icon; }' },
+    ]);
+    assert.equal(out.serializableSymbols.has('AssetRef'), true);
+    assert.equal(out.hostFieldTypeHints.get('Host')?.get('icon'), 'AssetRef');
+});

package/dist/mcp/local/local-backend.d.ts

@@ -5,7 +5,14 @@
  * Supports multiple indexed repositories via a global registry.
  * KuzuDB connections are opened lazily per repo on first query.
  */
+import { type ResolvedUnityBinding } from '../../core/unity/resolver.js';
+import { type UnityContextPayload, type UnityHydrationMeta } from './unity-enrichment.js';
 import { type RegistryEntry } from '../../storage/repo-manager.js';
+export declare function mergeUnityBindings(baseBindings: ResolvedUnityBinding[], resolvedByPath: Map<string, ResolvedUnityBinding[]>): ResolvedUnityBinding[];
+export declare function mergeParityUnityBindings(baseNonLightweightBindings: ResolvedUnityBinding[], resolvedBindings: ResolvedUnityBinding[]): ResolvedUnityBinding[];
+export declare function attachUnityHydrationMeta(payload: UnityContextPayload, input: Pick<UnityHydrationMeta, 'requestedMode' | 'effectiveMode' | 'elapsedMs' | 'fallbackToCompact'> & {
+    hasExpandableBindings: boolean;
+}): UnityContextPayload;
 export interface CodebaseContext {
     projectName: string;
     stats: {
@@ -119,6 +126,15 @@ export declare class LocalBackend {
      * Routes cluster/process types to direct graph queries.
      */
     private explore;
+    private hydrateUnityContext;
+    private buildParityWarmupKey;
+    private scheduleParityWarmup;
+    private shouldEnableParityWarmup;
+    private getOrRunParityHydration;
+    private computeParityPayload;
+    private hydrateUnityContextParity;
+    private hydrateUnityContextCompact;
+    private toUnityContextPayload;
     /**
      * Detect changes — git-diff based impact analysis.
      * Maps changed lines to indexed symbols, then finds affected processes.