@veewo/gitnexus 1.5.0-rc.4 → 1.5.1

package/dist/core/ingestion/unity-resource-processor.test.js

@@ -7,6 +7,8 @@ import { fileURLToPath } from 'node:url';
 import { generateId } from '../../lib/utils.js';
 import { createKnowledgeGraph } from '../graph/graph.js';
 import { closeLbug, executeQuery, initLbug, loadGraphToLbug } from '../lbug/lbug-adapter.js';
+import { buildUnityScanContext } from '../unity/scan-context.js';
+import { streamPrefabSourceRefs } from '../unity/prefab-source-scan.js';
 import { processUnityResources } from './unity-resource-processor.js';
 const here = path.dirname(fileURLToPath(import.meta.url));
 const fixtureRoot = path.resolve(here, '../../../src/core/unity/__fixtures__/mini-unity');
@@ -82,6 +84,49 @@ test('processUnityResources emits schema-compatible component-instance edges and
     assert.ok(result.timingsMs.resolve >= 0);
     assert.ok(result.timingsMs.graphWrite > 0);
 });
+test('fixture run emits scene->prefab UNITY_ASSET_GUID_REF and keeps script ref edges', async () => {
+    const graph = createKnowledgeGraph();
+    for (const symbol of symbols) {
+        const filePath = `Assets/Scripts/${symbol}.cs`;
+        const fileId = generateId('File', filePath);
+        const classId = generateId('Class', `${filePath}:${symbol}`);
+        graph.addNode({
+            id: fileId,
+            label: 'File',
+            properties: {
+                name: `${symbol}.cs`,
+                filePath,
+            },
+        });
+        graph.addNode({
+            id: classId,
+            label: 'Class',
+            properties: {
+                name: symbol,
+                filePath,
+            },
+        });
+        graph.addRelationship({
+            id: generateId('DEFINES', `${fileId}->${classId}`),
+            type: 'DEFINES',
+            sourceId: fileId,
+            targetId: classId,
+            confidence: 1.0,
+            reason: '',
+        });
+    }
+    await processUnityResources(graph, { repoPath: fixtureRoot });
+    const guidRefs = [...graph.iterRelationships()].filter((rel) => rel.type === 'UNITY_ASSET_GUID_REF');
+    const scenePrefabRef = guidRefs.find((rel) => {
+        const reason = JSON.parse(String(rel.reason || '{}'));
+        return (reason.resourcePath === 'Assets/Scene/MainUIManager.unity'
+            && reason.targetResourcePath === 'Assets/Prefabs/BattleMode.prefab'
+            && reason.fieldName === 'm_SourcePrefab');
+    });
+    assert.ok(scenePrefabRef);
+    const scriptRefs = [...graph.iterRelationships()].filter((rel) => rel.type === 'UNITY_GRAPH_NODE_SCRIPT_REF');
+    assert.ok(scriptRefs.length > 0);
+});
 test('processUnityResources persists UNITY_RESOURCE_SUMMARY in LadybugDB', async () => {
     const graph = createKnowledgeGraph();
     for (const symbol of symbols) {
@@ -518,6 +563,410 @@ test('processUnityResources writes asset-guid and graph-node reference edges fro
     assert.equal(guidReason.targetResourcePath, 'Assets/Graphs/Weapon.asset');
     assert.equal(guidReason.fieldName, 'gungraph');
 });
+test('processUnityResources emits prefab-source edges from scanContext.prefabSourceRefs only', async () => {
+    const graph = createKnowledgeGraph();
+    const fakeScanContext = {
+        symbolToScriptPath: new Map(),
+        scriptPathToGuid: new Map(),
+        guidToResourceHits: new Map(),
+        prefabSourceRefs: [
+            {
+                sourceResourcePath: 'Assets/Scene/MainUIManager.unity',
+                targetGuid: '99999999999999999999999999999999',
+                targetResourcePath: 'Assets/Prefabs/BattleMode.prefab',
+                fileId: '100100000',
+                fieldName: 'm_SourcePrefab',
+                sourceLayer: 'scene',
+            },
+        ],
+        resourceDocCache: new Map(),
+    };
+    const result = await processUnityResources(graph, { repoPath: fixtureRoot }, {
+        buildScanContext: async () => fakeScanContext,
+        resolveBindings: async () => ({ resourceBindings: [], unityDiagnostics: [] }),
+    });
+    const guidRefs = [...graph.iterRelationships()].filter((rel) => rel.type === 'UNITY_ASSET_GUID_REF');
+    assert.equal(guidRefs.length, 1);
+    const reason = JSON.parse(String(guidRefs[0]?.reason || '{}'));
+    assert.equal(reason.fieldName, 'm_SourcePrefab');
+    assert.equal(reason.sourceLayer, 'scene');
+    assert.ok(result.diagnostics.some((line) => line.includes('prefab-source: emitted=1')));
+});
+test('processUnityResources consumes prefab-source stream incrementally and emits edges', async () => {
+    const graph = createKnowledgeGraph();
+    const fakeScanContext = {
+        symbolToScriptPath: new Map(),
+        scriptPathToGuid: new Map(),
+        guidToResourceHits: new Map(),
+        assetGuidToPath: new Map([['99999999999999999999999999999999', 'Assets/Prefabs/BattleMode.prefab']]),
+        streamPrefabSourceRefs: async function* () {
+            yield {
+                sourceResourcePath: 'Assets/Scene/MainUIManager.unity',
+                targetGuid: '99999999999999999999999999999999',
+                targetResourcePath: 'Assets/Prefabs/BattleMode.prefab',
+                fileId: '100100000',
+                fieldName: 'm_SourcePrefab',
+                sourceLayer: 'scene',
+            };
+            await new Promise((resolve) => setTimeout(resolve, 1));
+            yield {
+                sourceResourcePath: 'Assets/Scene/Global.unity',
+                targetGuid: '99999999999999999999999999999999',
+                targetResourcePath: 'Assets/Prefabs/BattleMode.prefab',
+                fileId: '100100001',
+                fieldName: 'm_SourcePrefab',
+                sourceLayer: 'scene',
+            };
+        },
+        prefabSourceRefs: [],
+        resourceDocCache: new Map(),
+    };
+    const result = await processUnityResources(graph, { repoPath: fixtureRoot }, {
+        buildScanContext: async () => fakeScanContext,
+        resolveBindings: async () => ({ resourceBindings: [], unityDiagnostics: [] }),
+    });
+    assert.ok(result.diagnostics.some((line) => line.includes('prefab-source: emitted=2')));
+    assert.ok(result.diagnostics.some((line) => line.includes('prefab_source.rows_emitted=2')));
+    assert.ok(result.diagnostics.some((line) => line.includes('prefab_source.rows_parsed=')));
+});
+test('prefab-source accounting invariant closes', async () => {
+    const graph = createKnowledgeGraph();
+    const fakeScanContext = {
+        symbolToScriptPath: new Map(),
+        scriptPathToGuid: new Map(),
+        guidToResourceHits: new Map(),
+        assetGuidToPath: new Map([['99999999999999999999999999999999', 'Assets/Prefabs/BattleMode.prefab']]),
+        streamPrefabSourceRefs: async function* () {
+            yield {
+                sourceResourcePath: 'Assets/Scene/MainUIManager.unity',
+                targetGuid: '99999999999999999999999999999999',
+                targetResourcePath: 'Assets/Prefabs/BattleMode.prefab',
+                fileId: '100100000',
+                fieldName: 'm_SourcePrefab',
+                sourceLayer: 'scene',
+            };
+            yield {
+                sourceResourcePath: 'Assets/Scene/MainUIManager.unity',
+                targetGuid: '00000000000000000000000000000000',
+                targetResourcePath: 'Assets/Prefabs/BattleMode.prefab',
+                fileId: '100100001',
+                fieldName: 'm_SourcePrefab',
+                sourceLayer: 'scene',
+            };
+            yield {
+                sourceResourcePath: 'Assets/Scene/MainUIManager.unity',
+                targetGuid: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+                targetResourcePath: '__PLACEHOLDER__',
+                fileId: '100100002',
+                fieldName: 'm_SourcePrefab',
+                sourceLayer: 'scene',
+            };
+            yield {
+                sourceResourcePath: 'Assets/Scene/MainUIManager.unity',
+                targetGuid: 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb',
+                targetResourcePath: '',
+                fileId: '100100003',
+                fieldName: 'm_SourcePrefab',
+                sourceLayer: 'scene',
+            };
+            yield {
+                sourceResourcePath: 'Assets/Scene/MainUIManager.unity',
+                targetGuid: '99999999999999999999999999999999',
+                targetResourcePath: 'Assets/Prefabs/BattleMode.prefab',
+                fileId: '100100000',
+                fieldName: 'm_SourcePrefab',
+                sourceLayer: 'scene',
+            };
+        },
+        prefabSourceRefs: [],
+        resourceDocCache: new Map(),
+    };
+    const result = await processUnityResources(graph, { repoPath: fixtureRoot }, {
+        buildScanContext: async () => fakeScanContext,
+        resolveBindings: async () => ({ resourceBindings: [], unityDiagnostics: [] }),
+    });
+    assert.equal(result.prefabSourceStats.rowsParsed, result.prefabSourceStats.rowsFilteredZeroGuid
+        + result.prefabSourceStats.rowsFilteredPlaceholder
+        + result.prefabSourceStats.rowsFilteredUnresolved
+        + result.prefabSourceStats.rowsDeduped
+        + result.prefabSourceStats.rowsEmitted);
+});
+test('no cross-signal dedupe collision when same source has script-guid and prefab-source refs', async () => {
+    const graph = createKnowledgeGraph();
+    const filePath = 'Assets/Scripts/MainUIManager.cs';
+    const classId = generateId('Class', `${filePath}:MainUIManager`);
+    graph.addNode({
+        id: classId,
+        label: 'Class',
+        properties: { name: 'MainUIManager', filePath },
+    });
+    const fakeScanContext = {
+        symbolToScriptPath: new Map([['MainUIManager', filePath]]),
+        scriptPathToGuid: new Map([[filePath, 'dddddddddddddddddddddddddddddddd']]),
+        guidToResourceHits: new Map([
+            ['dddddddddddddddddddddddddddddddd', [{ resourcePath: 'Assets/Scene/MainUIManager.unity', resourceType: 'scene', line: 1, lineText: 'guid' }]],
+        ]),
+        assetGuidToPath: new Map([['99999999999999999999999999999999', 'Assets/Prefabs/BattleMode.prefab']]),
+        streamPrefabSourceRefs: async function* () {
+            yield {
+                sourceResourcePath: 'Assets/Scene/MainUIManager.unity',
+                targetGuid: '99999999999999999999999999999999',
+                targetResourcePath: 'Assets/Prefabs/BattleMode.prefab',
+                fileId: '100100000',
+                fieldName: 'm_SourcePrefab',
+                sourceLayer: 'scene',
+            };
+        },
+        prefabSourceRefs: [],
+        resourceDocCache: new Map(),
+    };
+    await processUnityResources(graph, { repoPath: fixtureRoot }, {
+        buildScanContext: async () => fakeScanContext,
+        resolveBindings: async () => ({
+            symbol: 'MainUIManager',
+            scriptPath: filePath,
+            scriptGuid: 'dddddddddddddddddddddddddddddddd',
+            resourceBindings: [
+                {
+                    resourcePath: 'Assets/Scene/MainUIManager.unity',
+                    resourceType: 'scene',
+                    bindingKind: 'direct',
+                    componentObjectId: '11400000',
+                    evidence: { line: 1, lineText: 'guid' },
+                    serializedFields: { scalarFields: [], referenceFields: [] },
+                    resolvedReferences: [
+                        {
+                            fieldName: 'gungraph',
+                            sourceLayer: 'scene',
+                            fileId: '11400000',
+                            guid: '99999999999999999999999999999999',
+                            fromList: false,
+                            resolution: 'external-asset',
+                            target: { assetPath: 'Assets/Prefabs/BattleMode.prefab' },
+                        },
+                    ],
+                },
+            ],
+            serializedFields: { scalarFields: [], referenceFields: [] },
+            unityDiagnostics: [],
+        }),
+    });
+    const refs = [...graph.iterRelationships()]
+        .filter((rel) => rel.type === 'UNITY_ASSET_GUID_REF')
+        .map((rel) => JSON.parse(String(rel.reason || '{}')));
+    assert.ok(refs.some((reason) => reason.fieldName === 'm_SourcePrefab'));
+    assert.ok(refs.some((reason) => reason.fieldName === 'gungraph'));
+});
+test('scan-context does not write graph edges directly; processor remains sole writer', async () => {
+    const graph = createKnowledgeGraph();
+    const context = await buildUnityScanContext({ repoRoot: fixtureRoot });
+    assert.equal([...graph.iterRelationships()].length, 0);
+    await processUnityResources(graph, { repoPath: fixtureRoot }, {
+        buildScanContext: async () => context,
+        resolveBindings: async () => ({ resourceBindings: [], unityDiagnostics: [] }),
+    });
+    assert.ok([...graph.iterRelationships()].some((rel) => rel.type === 'UNITY_ASSET_GUID_REF'));
+});
+test('prefab source pass can be disabled via env toggle', async () => {
+    const graph = createKnowledgeGraph();
+    const fakeScanContext = {
+        symbolToScriptPath: new Map(),
+        scriptPathToGuid: new Map(),
+        guidToResourceHits: new Map(),
+        prefabSourceRefs: [
+            {
+                sourceResourcePath: 'Assets/Scene/MainUIManager.unity',
+                targetGuid: '99999999999999999999999999999999',
+                targetResourcePath: 'Assets/Prefabs/BattleMode.prefab',
+                fileId: '100100000',
+                fieldName: 'm_SourcePrefab',
+                sourceLayer: 'scene',
+            },
+        ],
+        resourceDocCache: new Map(),
+    };
+    const originalValue = process.env.GITNEXUS_DISABLE_PREFAB_SOURCE_PASS;
+    process.env.GITNEXUS_DISABLE_PREFAB_SOURCE_PASS = '1';
+    try {
+        const result = await processUnityResources(graph, { repoPath: fixtureRoot }, {
+            buildScanContext: async () => fakeScanContext,
+            resolveBindings: async () => ({ resourceBindings: [], unityDiagnostics: [] }),
+        });
+        const guidRefs = [...graph.iterRelationships()].filter((rel) => rel.type === 'UNITY_ASSET_GUID_REF');
+        assert.equal(guidRefs.length, 0);
+        assert.ok(result.diagnostics.some((line) => line.includes('prefab-source: skipped')));
+    }
+    finally {
+        if (typeof originalValue === 'undefined') {
+            delete process.env.GITNEXUS_DISABLE_PREFAB_SOURCE_PASS;
+        }
+        else {
+            process.env.GITNEXUS_DISABLE_PREFAB_SOURCE_PASS = originalValue;
+        }
+    }
+});
+test('prefab nested source dedupes duplicate PrefabInstance rows', async () => {
+    const graph = createKnowledgeGraph();
+    const fakeScanContext = {
+        symbolToScriptPath: new Map(),
+        scriptPathToGuid: new Map(),
+        guidToResourceHits: new Map(),
+        prefabSourceRefs: [
+            {
+                sourceResourcePath: 'Assets/Prefabs/BattleMode.prefab',
+                targetGuid: '99999999999999999999999999999999',
+                targetResourcePath: 'Assets/Prefabs/Nested.prefab',
+                fileId: '100100000',
+                fieldName: 'm_SourcePrefab',
+                sourceLayer: 'prefab',
+            },
+            {
+                sourceResourcePath: 'Assets/Prefabs/BattleMode.prefab',
+                targetGuid: '99999999999999999999999999999999',
+                targetResourcePath: 'Assets/Prefabs/Nested.prefab',
+                fileId: '100100000',
+                fieldName: 'm_SourcePrefab',
+                sourceLayer: 'prefab',
+            },
+        ],
+        resourceDocCache: new Map(),
+    };
+    await processUnityResources(graph, { repoPath: fixtureRoot }, {
+        buildScanContext: async () => fakeScanContext,
+        resolveBindings: async () => ({ resourceBindings: [], unityDiagnostics: [] }),
+    });
+    const guidRefs = [...graph.iterRelationships()].filter((rel) => rel.type === 'UNITY_ASSET_GUID_REF');
+    assert.equal(guidRefs.length, 1);
+    const reason = JSON.parse(String(guidRefs[0]?.reason || '{}'));
+    assert.equal(reason.guid, '99999999999999999999999999999999');
+});
+test('drops placeholder unresolved and zero-guid prefab-source rows and reports filtered counters', async () => {
+    const graph = createKnowledgeGraph();
+    const fakeScanContext = {
+        symbolToScriptPath: new Map(),
+        scriptPathToGuid: new Map(),
+        guidToResourceHits: new Map(),
+        prefabSourceRefs: [
+            {
+                sourceResourcePath: 'Assets/Scene/MainUIManager.unity',
+                targetGuid: '00000000000000000000000000000000',
+                targetResourcePath: 'Assets/Prefabs/BattleMode.prefab',
+                fileId: '1',
+                fieldName: 'm_SourcePrefab',
+                sourceLayer: 'scene',
+            },
+            {
+                sourceResourcePath: 'Assets/Scene/MainUIManager.unity',
+                targetGuid: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+                targetResourcePath: '__PLACEHOLDER__',
+                fileId: '2',
+                fieldName: 'm_SourcePrefab',
+                sourceLayer: 'scene',
+            },
+            {
+                sourceResourcePath: 'Assets/Scene/MainUIManager.unity',
+                targetGuid: 'cccccccccccccccccccccccccccccccc',
+                targetResourcePath: '',
+                fileId: '3',
+                fieldName: 'm_SourcePrefab',
+                sourceLayer: 'scene',
+            },
+            {
+                sourceResourcePath: 'Assets/Scene/MainUIManager.unity',
+                targetGuid: 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb',
+                targetResourcePath: 'Assets/Prefabs/BattleMode.prefab',
+                fileId: '4',
+                fieldName: 'm_SourcePrefab',
+                sourceLayer: 'scene',
+            },
+        ],
+        resourceDocCache: new Map(),
+    };
+    const result = await processUnityResources(graph, { repoPath: fixtureRoot }, {
+        buildScanContext: async () => fakeScanContext,
+        resolveBindings: async () => ({ resourceBindings: [], unityDiagnostics: [] }),
+    });
+    const guidRefs = [...graph.iterRelationships()].filter((rel) => rel.type === 'UNITY_ASSET_GUID_REF');
+    assert.equal(guidRefs.length, 1);
+    const reason = JSON.parse(String(guidRefs[0]?.reason || '{}'));
+    assert.equal(reason.targetResourcePath, 'Assets/Prefabs/BattleMode.prefab');
+    assert.notEqual(reason.guid, '00000000000000000000000000000000');
+    assert.ok(result.prefabSourceStats.rowsFilteredZeroGuid > 0);
+    assert.ok(result.prefabSourceStats.rowsFilteredPlaceholder > 0);
+    assert.ok(result.prefabSourceStats.rowsFilteredUnresolved > 0);
+    assert.ok(result.diagnostics.some((line) => line.includes('prefab_source.rows_filtered_zero_guid=')));
+    assert.ok(result.diagnostics.some((line) => line.includes('prefab_source.rows_filtered_placeholder=')));
+    assert.ok(result.diagnostics.some((line) => line.includes('prefab_source.rows_filtered_unresolved=')));
+});
+test('per-file scan failure is isolated and does not abort subsequent file emission', async () => {
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-prefab-source-file-error-'));
+    const graph = createKnowledgeGraph();
+    try {
+        const sceneDir = path.join(tempRoot, 'Assets/Scene');
+        const prefabDir = path.join(tempRoot, 'Assets/Prefabs');
+        await fs.mkdir(path.join(sceneDir, 'Broken.unity'), { recursive: true });
+        await fs.mkdir(prefabDir, { recursive: true });
+        await fs.writeFile(path.join(sceneDir, 'Good.unity'), [
+            '--- !u!1001 &100100000',
+            'PrefabInstance:',
+            '  m_SourcePrefab: {fileID: 100100000, guid: 99999999999999999999999999999999, type: 3}',
+        ].join('\n'), 'utf-8');
+        await fs.writeFile(path.join(prefabDir, 'BattleMode.prefab'), '--- !u!1 &1\nGameObject:\n', 'utf-8');
+        const fakeScanContext = {
+            symbolToScriptPath: new Map(),
+            scriptPathToGuid: new Map(),
+            guidToResourceHits: new Map(),
+            assetGuidToPath: new Map([['99999999999999999999999999999999', 'Assets/Prefabs/BattleMode.prefab']]),
+            streamPrefabSourceRefs: (options) => streamPrefabSourceRefs({
+                repoRoot: tempRoot,
+                resourceFiles: ['Assets/Scene/Broken.unity', 'Assets/Scene/Good.unity'],
+                assetGuidToPath: new Map([['99999999999999999999999999999999', 'Assets/Prefabs/BattleMode.prefab']]),
+                hooks: options?.hooks,
+            }),
+            prefabSourceRefs: [],
+            resourceDocCache: new Map(),
+        };
+        const result = await processUnityResources(graph, { repoPath: tempRoot }, {
+            buildScanContext: async () => fakeScanContext,
+            resolveBindings: async () => ({ resourceBindings: [], unityDiagnostics: [] }),
+        });
+        assert.ok(result.prefabSourceStats.rowsEmitted > 0);
+        assert.ok(result.diagnostics.some((line) => line.includes('prefab_source.file_errors=1')));
+    }
+    finally {
+        await fs.rm(tempRoot, { recursive: true, force: true });
+    }
+});
+test('extracts prefab source refs without class binding resolve', async () => {
+    const graph = createKnowledgeGraph();
+    let resolveBindingsCallCount = 0;
+    const fakeScanContext = {
+        symbolToScriptPath: new Map(),
+        scriptPathToGuid: new Map(),
+        guidToResourceHits: new Map(),
+        prefabSourceRefs: [
+            {
+                sourceResourcePath: 'Assets/Scene/MainUIManager.unity',
+                targetGuid: '99999999999999999999999999999999',
+                targetResourcePath: 'Assets/Prefabs/BattleMode.prefab',
+                fileId: '100100000',
+                fieldName: 'm_SourcePrefab',
+                sourceLayer: 'scene',
+            },
+        ],
+        resourceDocCache: new Map(),
+    };
+    await processUnityResources(graph, { repoPath: fixtureRoot }, {
+        buildScanContext: async () => fakeScanContext,
+        resolveBindings: async () => {
+            resolveBindingsCallCount += 1;
+            return ({ resourceBindings: [], unityDiagnostics: [] });
+        },
+    });
+    const guidRefs = [...graph.iterRelationships()].filter((rel) => rel.type === 'UNITY_ASSET_GUID_REF');
+    assert.equal(resolveBindingsCallCount, 0);
+    assert.equal(guidRefs.length, 1);
+});
 test('processUnityResources writes compact UNITY_RESOURCE_SUMMARY reason by default', async () => {
     const graph = createKnowledgeGraph();
     const classId = generateId('Class', 'Assets/Scripts/Compact.cs:CompactSymbol');

package/dist/core/ingestion/unity-runtime-binding-rules.d.ts

@@ -7,5 +7,20 @@ export interface UnityRuntimeBindingResult {
         ruleId: string;
         edgesInjected: number;
     }>;
+    diagnostics: UnityRuntimeBindingDiagnostics;
 }
-export declare function applyUnityRuntimeBindingRules(graph: KnowledgeGraph, rules: RuntimeClaimRule[], _config: UnityConfig): UnityRuntimeBindingResult;
+export interface UnityRuntimeBindingDiagnostics {
+    rulesEvaluated: number;
+    bindingsEvaluated: number;
+    bindingsByKind: Record<string, number>;
+    methodLookupCalls: number;
+    methodLookupCacheHits: number;
+    sceneRuntimeTraversalCalls: number;
+    sceneRuntimeTraversalCacheHits: number;
+    sceneRuntimeResourcesVisited: number;
+    anomalies: string[];
+    shouldAgentReport: boolean;
+    agentReportReason: string;
+    summary: string[];
+}
+export declare function applyUnityRuntimeBindingRules(graph: KnowledgeGraph, rules: RuntimeClaimRule[], config: UnityConfig): UnityRuntimeBindingResult;