@veewo/gitnexus 1.5.0 → 1.5.2

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

@@ -5,6 +5,7 @@ import { createInterface } from 'node:readline';
 import { glob } from 'glob';
 import { buildAssetMetaIndex, buildMetaIndex } from './meta-index.js';
 import { buildUnityUiMetaIndex } from './ui-meta-index.js';
+import { streamPrefabSourceRefs } from './prefab-source-scan.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 SCRIPT_GUID_IN_LINE_PATTERN = /\bm_Script\s*:\s*\{[^}]*\bguid\s*:\s*([0-9a-f]{32})\b/gi;
@@ -30,10 +31,20 @@ export async function buildUnityScanContext(input) {
         scriptPathToGuid.set(normalizeSlashes(scriptPath), guid);
     }
     const resourceFiles = await resolveResourceFiles(input.repoRoot, input.scopedPaths);
-    const guidToResourceHits = await buildGuidHitIndex(input.repoRoot, scriptPathToGuid, resourceFiles);
-    const assetMetaFiles = resolveAssetMetaFiles(input.repoRoot, input.scopedPaths, scriptFiles, resourceFiles);
+    const normalizedResourceFiles = [...new Set(resourceFiles.map((resourcePath) => normalizeSlashes(resourcePath)))]
+        .filter((resourcePath) => resourcePath.length > 0)
+        .sort((left, right) => left.localeCompare(right));
+    const guidToResourceHits = await buildGuidHitIndex(input.repoRoot, scriptPathToGuid, normalizedResourceFiles);
+    const assetMetaFiles = resolveAssetMetaFiles(input.repoRoot, input.scopedPaths, scriptFiles, normalizedResourceFiles);
     const assetGuidToPath = await buildAssetMetaIndex(input.repoRoot, { metaFiles: assetMetaFiles });
     const uiMetaIndex = await buildUnityUiMetaIndex(input.repoRoot, { scopedPaths: input.scopedPaths });
+    const streamPrefabSourceRefsFn = (options) => streamPrefabSourceRefs({
+        repoRoot: input.repoRoot,
+        resourceFiles: normalizedResourceFiles,
+        assetGuidToPath,
+        queue: options?.queue,
+        hooks: options?.hooks,
+    });
     const symbolToCanonicalScriptPath = buildCanonicalScriptPathIndex(symbolToScriptPaths, scriptPathToGuid, guidToResourceHits);
     const symbolToScriptPath = new Map(symbolToCanonicalScriptPath);
     return {
@@ -47,6 +58,9 @@ export async function buildUnityScanContext(input) {
         assetGuidToPath,
         uxmlGuidToPath: uiMetaIndex.uxmlGuidToPath,
         ussGuidToPath: uiMetaIndex.ussGuidToPath,
+        prefabSourceRefs: [],
+        streamPrefabSourceRefs: streamPrefabSourceRefsFn,
+        resourceFiles: normalizedResourceFiles,
         resourceDocCache: new Map(),
     };
 }
@@ -135,6 +149,20 @@ export function buildUnityScanContextFromSeed(input) {
             ussGuidToPath.set(guid.toLowerCase(), normalizedPath);
         }
     }
+    const resourceFiles = [
+        ...new Set(Object.values(seed.guidToResourcePaths || {})
+            .flat()
+            .map((resourcePathRaw) => normalizeSlashes(String(resourcePathRaw || '').trim()))
+            .filter((resourcePath) => resourcePath.length > 0)),
+    ].sort((left, right) => left.localeCompare(right));
+    const prefabSourceRefs = (seed.prefabSourceRefs || [])
+        .map((value) => normalizePrefabSourceRef(value))
+        .filter((value) => Boolean(value));
+    const streamPrefabSourceRefsFn = async function* () {
+        for (const row of prefabSourceRefs) {
+            yield { ...row };
+        }
+    };
     return {
         symbolToScriptPaths,
         symbolToCanonicalScriptPath,
@@ -146,6 +174,9 @@ export function buildUnityScanContextFromSeed(input) {
         assetGuidToPath,
         uxmlGuidToPath,
         ussGuidToPath,
+        prefabSourceRefs,
+        streamPrefabSourceRefs: streamPrefabSourceRefsFn,
+        resourceFiles,
         resourceDocCache: new Map(),
     };
 }
@@ -376,6 +407,23 @@ function normalizeRelativePath(repoRoot, filePath) {
 function normalizeSlashes(filePath) {
     return filePath.replace(/\\/g, '/');
 }
+function normalizePrefabSourceRef(value) {
+    const sourceResourcePath = normalizeSlashes(String(value?.sourceResourcePath || '').trim());
+    const targetGuid = String(value?.targetGuid || '').trim().toLowerCase();
+    const targetResourcePath = normalizeSlashes(String(value?.targetResourcePath || '').trim());
+    const fileId = String(value?.fileId || '').trim();
+    if (!sourceResourcePath || !targetGuid)
+        return undefined;
+    const sourceLayer = value?.sourceLayer === 'scene' ? 'scene' : value?.sourceLayer === 'prefab' ? 'prefab' : (sourceResourcePath.endsWith('.unity') ? 'scene' : 'prefab');
+    return {
+        sourceResourcePath,
+        targetGuid,
+        targetResourcePath: targetResourcePath || undefined,
+        fileId: fileId || undefined,
+        fieldName: 'm_SourcePrefab',
+        sourceLayer,
+    };
+}
 function inferResourceType(resourcePath) {
     if (resourcePath.endsWith('.prefab'))
         return 'prefab';

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

@@ -23,6 +23,80 @@ test('buildUnityScanContext exposes reusable resourceDocCache for repeated resol
     assert.equal(context.resourceDocCache.size, cacheSizeAfterFirst);
     assert.ok(cacheSizeAfterFirst > 0);
 });
+test('buildUnityScanContext exposes resourceFiles for scene/prefab scan pass', async () => {
+    const context = await buildUnityScanContext({
+        repoRoot: fixtureRoot,
+        scopedPaths: ['Assets/Scene/MainUIManager.unity', 'Assets/Prefabs/BattleMode.prefab'],
+    });
+    assert.ok(context.resourceFiles.includes('Assets/Scene/MainUIManager.unity'));
+    assert.ok(context.resourceFiles.includes('Assets/Prefabs/BattleMode.prefab'));
+    assert.equal(context.resourceFiles.includes('Assets\\Scene\\MainUIManager.unity'), false);
+    assert.equal(new Set(context.resourceFiles).size, context.resourceFiles.length);
+});
+test('buildUnityScanContext exposes prefab-source producer from scoped unity/prefab resources', async () => {
+    const context = await buildUnityScanContext({
+        repoRoot: fixtureRoot,
+        scopedPaths: ['Assets/Scene/MainUIManager.unity', 'Assets/Prefabs/BattleMode.prefab'],
+    });
+    assert.equal(typeof context.streamPrefabSourceRefs, 'function');
+    const rows = [];
+    for await (const row of context.streamPrefabSourceRefs()) {
+        rows.push(row);
+    }
+    assert.ok(rows.length > 0);
+    const sample = rows[0];
+    assert.equal(sample.fieldName, 'm_SourcePrefab');
+    assert.equal(sample.sourceLayer === 'scene' || sample.sourceLayer === 'prefab', true);
+});
+test('buildUnityScanContext keeps script-guid hits while exposing prefab-source producer', async () => {
+    const context = await buildUnityScanContext({ repoRoot: fixtureRoot });
+    assert.ok(context.guidToResourceHits.size > 0);
+    assert.equal(typeof context.streamPrefabSourceRefs, 'function');
+});
+test('buildUnityScanContextFromSeed rebuilds resourceFiles from guidToResourcePaths', () => {
+    const context = buildUnityScanContextFromSeed({
+        seed: {
+            version: 1,
+            symbolToScriptPath: {},
+            scriptPathToGuid: {},
+            guidToResourcePaths: {
+                '11111111111111111111111111111111': ['Assets/Scene/MainUIManager.unity', 'Assets/Prefabs/BattleMode.prefab'],
+            },
+        },
+    });
+    assert.deepEqual(context.resourceFiles.sort(), [
+        'Assets/Prefabs/BattleMode.prefab',
+        'Assets/Scene/MainUIManager.unity',
+    ]);
+});
+test('buildUnityScanContextFromSeed reconstructs prefabSourceRefs', () => {
+    const context = buildUnityScanContextFromSeed({
+        seed: {
+            version: 1,
+            symbolToScriptPath: {},
+            scriptPathToGuid: {},
+            guidToResourcePaths: {},
+            prefabSourceRefs: [
+                {
+                    sourceResourcePath: 'Assets/Scene/MainUIManager.unity',
+                    targetGuid: '99999999999999999999999999999999',
+                    targetResourcePath: 'Assets/Prefabs/BattleMode.prefab',
+                    fileId: '100100000',
+                    fieldName: 'm_SourcePrefab',
+                    sourceLayer: 'scene',
+                },
+            ],
+        },
+    });
+    assert.equal(context.prefabSourceRefs.length, 1);
+});
+test('scan-context prefab-source producer drops unresolved and zero-guid entries', async () => {
+    const context = await buildUnityScanContext({ repoRoot: fixtureRoot });
+    for await (const row of context.streamPrefabSourceRefs()) {
+        assert.notEqual(row.targetGuid, '00000000000000000000000000000000');
+        assert.ok(String(row.targetResourcePath || '').length > 0);
+    }
+});
 test('buildUnityScanContext accepts symbol declarations as hint source', async () => {
     const context = await buildUnityScanContext({
         repoRoot: fixtureRoot,

package/dist/mcp/local/agent-safe-response.d.ts

@@ -0,0 +1,10 @@
+export type ResponseProfile = 'slim' | 'full';
+export declare function resolveResponseProfile(value: unknown): ResponseProfile;
+export declare function buildSlimQueryResult(full: Record<string, any>, input: {
+    repoName?: string;
+    queryText: string;
+}): Record<string, unknown>;
+export declare function buildSlimContextResult(full: Record<string, any>, input: {
+    repoName?: string;
+    symbolName: string;
+}): Record<string, unknown>;