@veewo/gitnexus 1.3.8 → 1.3.10

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

@@ -0,0 +1,34 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { buildSerializableTypeIndexFromSources } from './serialized-type-index.js';
+test('buildSerializableTypeIndex extracts serializable symbols and host field declared types', () => {
+    const index = buildSerializableTypeIndexFromSources([
+        {
+            filePath: 'Assets/Scripts/AssetRef.cs',
+            content: `
+        [System.Serializable]
+        public class AssetRef { public string guid; }
+      `,
+        },
+        {
+            filePath: 'Assets/Scripts/InventoryConfig.cs',
+            content: `
+        using UnityEngine;
+        using System.Collections.Generic;
+        public class InventoryConfig : ScriptableObject {
+          public AssetRef icon;
+          public AssetRef<GameObject> iconPrefab;
+          [SerializeField] private List<AssetRef> drops;
+          [SerializeField] private List<AssetRef<Sprite>> iconVariants;
+          [SerializeField] private int ignored;
+        }
+      `,
+        },
+    ]);
+    assert.equal(index.serializableSymbols.has('AssetRef'), true);
+    assert.equal(index.hostFieldTypeHints.get('InventoryConfig')?.get('icon'), 'AssetRef');
+    assert.equal(index.hostFieldTypeHints.get('InventoryConfig')?.get('iconPrefab'), 'AssetRef');
+    assert.equal(index.hostFieldTypeHints.get('InventoryConfig')?.get('drops'), 'AssetRef');
+    assert.equal(index.hostFieldTypeHints.get('InventoryConfig')?.get('iconVariants'), 'AssetRef');
+    assert.equal(index.hostFieldTypeHints.get('InventoryConfig')?.has('ignored'), false);
+});

package/dist/core/unity/u2-thresholds.test.d.ts

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

package/dist/core/unity/u2-thresholds.test.js

@@ -0,0 +1,71 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { resolveUnityBindings } from './resolver.js';
+import { buildUnityScanContext } from './scan-context.js';
+const here = path.dirname(fileURLToPath(import.meta.url));
+const fixtureRoot = path.resolve(here, '../../../src/core/unity/__fixtures__/mini-unity');
+const U2_REFERENCE_RESOLUTION_RATE_THRESHOLD = 0.8;
+const U2_LIST_REFERENCE_PARSE_RATE_THRESHOLD = 1.0;
+function countListCandidatesFromScalarFields(scalarFields) {
+    let total = 0;
+    for (const field of scalarFields) {
+        const lines = field.value.split(/\r?\n/);
+        for (const line of lines) {
+            if (/^\s*-\s*\{[^}]*fileID\s*:/.test(line)) {
+                total += 1;
+            }
+        }
+    }
+    return total;
+}
+function countResolvedSuccesses(references) {
+    return references.filter((ref) => ref.resolution === 'local-object' || ref.resolution === 'external-asset').length;
+}
+function collectU2ReferenceStats(results) {
+    let candidateRefs = 0;
+    let resolvedRefs = 0;
+    let listCandidates = 0;
+    let parsedListRefs = 0;
+    for (const result of results) {
+        for (const binding of result.resourceBindings) {
+            const listCandidatesForBinding = countListCandidatesFromScalarFields(binding.serializedFields.scalarFields);
+            const directCandidatesForBinding = binding.serializedFields.referenceFields.length;
+            candidateRefs += directCandidatesForBinding + listCandidatesForBinding;
+            listCandidates += listCandidatesForBinding;
+            resolvedRefs += countResolvedSuccesses(binding.resolvedReferences);
+            parsedListRefs += binding.resolvedReferences.filter((ref) => ref.fromList).length;
+        }
+    }
+    return { candidateRefs, resolvedRefs, listCandidates, parsedListRefs };
+}
+test('U2 threshold: reference_resolution_rate stays above baseline', async () => {
+    const scanContext = await buildUnityScanContext({
+        repoRoot: fixtureRoot,
+        scopedPaths: [
+            'Assets/Scripts/MainUIManager.cs',
+            'Assets/Scripts/MainUIManager.cs.meta',
+            'Assets/Scene/MainUIManager.unity',
+            'Assets/Config/MainUIDocument.asset.meta',
+            'Assets/Scripts/MenuScreenCarrier.cs',
+            'Assets/Scripts/MenuScreenCarrier.cs.meta',
+            'Assets/Prefabs/MenuScreenCarrier.prefab',
+        ],
+    });
+    const [mainUIManager, menuScreenCarrier] = await Promise.all([
+        resolveUnityBindings({ repoRoot: fixtureRoot, symbol: 'MainUIManager', scanContext }),
+        resolveUnityBindings({ repoRoot: fixtureRoot, symbol: 'MenuScreenCarrier', scanContext }),
+    ]);
+    const stats = collectU2ReferenceStats([mainUIManager, menuScreenCarrier]);
+    assert.ok(stats.candidateRefs > 0, 'candidate reference count must be > 0');
+    const referenceResolutionRate = stats.resolvedRefs / stats.candidateRefs;
+    assert.ok(referenceResolutionRate >= U2_REFERENCE_RESOLUTION_RATE_THRESHOLD, `reference_resolution_rate=${referenceResolutionRate.toFixed(3)} below threshold=${U2_REFERENCE_RESOLUTION_RATE_THRESHOLD.toFixed(3)} (resolved=${stats.resolvedRefs}, candidates=${stats.candidateRefs})`);
+});
+test('U2 threshold: list_reference_parse_rate stays above baseline', async () => {
+    const result = await resolveUnityBindings({ repoRoot: fixtureRoot, symbol: 'MenuScreenCarrier' });
+    const stats = collectU2ReferenceStats([result]);
+    assert.ok(stats.listCandidates > 0, 'list reference candidate count must be > 0');
+    const listReferenceParseRate = stats.parsedListRefs / stats.listCandidates;
+    assert.ok(listReferenceParseRate >= U2_LIST_REFERENCE_PARSE_RATE_THRESHOLD, `list_reference_parse_rate=${listReferenceParseRate.toFixed(3)} below threshold=${U2_LIST_REFERENCE_PARSE_RATE_THRESHOLD.toFixed(3)} (parsed=${stats.parsedListRefs}, candidates=${stats.listCandidates})`);
+});

package/dist/core/unity/yaml-object-graph.d.ts

@@ -0,0 +1,9 @@
+export type UnityObjectType = 'MonoBehaviour' | 'PrefabInstance' | 'GameObject';
+export interface UnityObjectBlock {
+    objectId: string;
+    objectType: UnityObjectType;
+    stripped: boolean;
+    fields: Record<string, string>;
+    rawBody: string;
+}
+export declare function parseUnityYamlObjects(text: string): UnityObjectBlock[];

package/dist/core/unity/yaml-object-graph.js

@@ -0,0 +1,92 @@
+const SUPPORTED_TYPES = new Set(['MonoBehaviour', 'PrefabInstance', 'GameObject']);
+export function parseUnityYamlObjects(text) {
+    const lines = text.replace(/\r\n/g, '\n').split('\n');
+    const blocks = [];
+    let currentHeader = null;
+    let currentBody = [];
+    const flush = () => {
+        if (!currentHeader)
+            return;
+        const objectType = findObjectType(currentBody);
+        if (!objectType) {
+            currentHeader = null;
+            currentBody = [];
+            return;
+        }
+        blocks.push({
+            objectId: currentHeader.objectId,
+            objectType,
+            stripped: currentHeader.stripped,
+            fields: parseFields(currentBody),
+            rawBody: currentBody.join('\n'),
+        });
+        currentHeader = null;
+        currentBody = [];
+    };
+    for (const line of lines) {
+        const header = line.match(/^--- !u!\d+ &(\d+)(?:\s+(\w+))?\s*$/);
+        if (header) {
+            flush();
+            currentHeader = {
+                objectId: header[1],
+                stripped: header[2] === 'stripped',
+            };
+            continue;
+        }
+        if (currentHeader) {
+            currentBody.push(line);
+        }
+    }
+    flush();
+    return blocks;
+}
+function findObjectType(lines) {
+    for (const line of lines) {
+        const match = line.match(/^(MonoBehaviour|PrefabInstance|GameObject):\s*$/);
+        if (match && SUPPORTED_TYPES.has(match[1])) {
+            return match[1];
+        }
+    }
+    return null;
+}
+function parseFields(lines) {
+    const fields = {};
+    const rootIndex = lines.findIndex((line) => /^(MonoBehaviour|PrefabInstance|GameObject):\s*$/.test(line));
+    if (rootIndex === -1)
+        return fields;
+    let currentKey = null;
+    let currentValue = [];
+    const flush = () => {
+        if (!currentKey)
+            return;
+        fields[currentKey] = currentValue.join('\n').trim();
+        currentKey = null;
+        currentValue = [];
+    };
+    for (const line of lines.slice(rootIndex + 1)) {
+        if (!line.trim()) {
+            if (currentKey)
+                currentValue.push('');
+            continue;
+        }
+        const topLevelMatch = line.match(/^ {2}(?!-)([^ ][^:]*):(.*)$/);
+        if (topLevelMatch) {
+            flush();
+            currentKey = topLevelMatch[1].trim();
+            const inlineValue = topLevelMatch[2].trim();
+            if (inlineValue)
+                currentValue.push(inlineValue);
+            continue;
+        }
+        if (currentKey) {
+            currentValue.push(stripCommonIndent(line));
+        }
+    }
+    flush();
+    return fields;
+}
+function stripCommonIndent(line) {
+    if (line.startsWith('    '))
+        return line.slice(4);
+    return line.trimStart();
+}

package/dist/core/unity/yaml-object-graph.test.d.ts

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

package/dist/core/unity/yaml-object-graph.test.js

@@ -0,0 +1,49 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { parseUnityYamlObjects } from './yaml-object-graph.js';
+const sampleYaml = `--- !u!1 &1000
+GameObject:
+  m_Name: MainUIRoot
+--- !u!114 &11400000 stripped
+MonoBehaviour:
+  m_CorrespondingSourceObject: {fileID: 11400000, guid: abcdef0123456789abcdef0123456789, type: 3}
+  m_PrefabInstance: {fileID: 2000}
+  needPause: 0
+  mainUIDocument: {fileID: 11400000, guid: fedcba9876543210fedcba9876543210, type: 2}
+--- !u!1001 &2000
+PrefabInstance:
+  m_Modification:
+    m_Modifications:
+    - target: {fileID: 11400000}
+      propertyPath: needPause
+      value: 1
+      objectReference: {fileID: 0}
+`;
+test('parseUnityYamlObjects parses stripped MonoBehaviour and PrefabInstance blocks', () => {
+    const blocks = parseUnityYamlObjects(sampleYaml);
+    assert.equal(blocks.length, 3);
+    assert.deepEqual(blocks.map((block) => ({ id: block.objectId, type: block.objectType, stripped: block.stripped })), [
+        { id: '1000', type: 'GameObject', stripped: false },
+        { id: '11400000', type: 'MonoBehaviour', stripped: true },
+        { id: '2000', type: 'PrefabInstance', stripped: false },
+    ]);
+    assert.equal(blocks[1].fields.needPause, '0');
+    assert.match(blocks[1].fields.mainUIDocument, /fileID: 11400000/);
+    assert.match(blocks[2].fields.m_Modification, /propertyPath: needPause/);
+});
+test('parseUnityYamlObjects keeps inline list entries under their parent field', () => {
+    const yamlWithInlineList = `--- !u!114 &11400001
+MonoBehaviour:
+  buttonMappings:
+  - {fileID: 11400000, guid: fedcba9876543210fedcba9876543210, type: 2}
+  - {fileID: 0}
+  needPause: 0
+`;
+    const blocks = parseUnityYamlObjects(yamlWithInlineList);
+    assert.equal(blocks.length, 1);
+    const mono = blocks[0];
+    assert.equal(mono.objectType, 'MonoBehaviour');
+    assert.ok(mono.fields.buttonMappings.includes('- {fileID: 11400000'));
+    assert.equal(mono.fields['- {fileID'], undefined);
+    assert.equal(mono.fields.needPause, '0');
+});

package/dist/mcp/local/local-backend.js

@@ -8,6 +8,8 @@
 import fs from 'fs/promises';
 import path from 'path';
 import { initKuzu, executeQuery, closeKuzu, isKuzuReady } from '../core/kuzu-adapter.js';
+import { parseUnityResourcesMode } from '../../core/unity/options.js';
+import { loadUnityContext } from './unity-enrichment.js';
 // Embedding imports are lazy (dynamic import) to avoid loading onnxruntime-node
 // at MCP server startup — crashes on unsupported Node ABI versions (#89)
 // git utilities available if needed
@@ -285,6 +287,7 @@ export class LocalBackend {
         const processLimit = params.limit || 5;
         const maxSymbolsPerProcess = params.max_symbols || 10;
         const includeContent = params.include_content ?? false;
+        const unityResourcesMode = parseUnityResourcesMode(params.unity_resources);
         const searchQuery = params.query.trim();
         // Step 1: Run hybrid search to get matching symbols
         const searchLimit = processLimit * maxSymbolsPerProcess; // fetch enough raw results
@@ -383,6 +386,9 @@ export class LocalBackend {
                 endLine: sym.endLine,
                 ...(module ? { module } : {}),
                 ...(includeContent && content ? { content } : {}),
+                ...((unityResourcesMode !== 'off' && sym.nodeId && sym.type === 'Class')
+                    ? await loadUnityContext(repo.id, sym.nodeId, (query) => executeQuery(repo.id, query))
+                    : {}),
             };
             if (processRows.length === 0) {
                 // Symbol not in any process — goes to definitions
@@ -796,6 +802,7 @@ export class LocalBackend {
     async context(repo, params) {
         await this.ensureInitialized(repo.id);
         const { name, uid, file_path, include_content } = params;
+        const unityResourcesMode = parseUnityResourcesMode(params.unity_resources);
         if (!name && !uid) {
             return { error: 'Either "name" or "uid" parameter is required.' };
         }
@@ -948,7 +955,7 @@ export class LocalBackend {
             }
             return cats;
         };
-        return {
+        const result = {
             status: 'found',
             symbol: {
                 uid: getRowValue(sym, 'id', 0),
@@ -968,6 +975,10 @@ export class LocalBackend {
                 step_count: getRowValue(r, 'stepCount', 3),
             })),
         };
+        if (unityResourcesMode !== 'off' && symNodeId && symKind === 'Class') {
+            Object.assign(result, await loadUnityContext(repo.id, symNodeId, (query) => executeQuery(repo.id, query)));
+        }
+        return result;
     }
     /**
      * Legacy explore — kept for backwards compatibility with resources.ts.

package/dist/mcp/local/unity-enrichment.d.ts

@@ -0,0 +1,6 @@
+import type { ResolveOutput } from '../../core/unity/resolver.js';
+export interface UnityContextPayload extends Pick<ResolveOutput, 'resourceBindings' | 'serializedFields' | 'unityDiagnostics'> {
+}
+export type ExecuteQuery = (query: string) => Promise<any[]>;
+export declare function loadUnityContext(_repoId: string, symbolId: string, execute: ExecuteQuery): Promise<UnityContextPayload>;
+export declare function projectUnityBindings(rows: any[]): UnityContextPayload;

package/dist/mcp/local/unity-enrichment.js

@@ -0,0 +1,91 @@
+import { extractAssetRefPathReferences } from '../../core/unity/resolver.js';
+export async function loadUnityContext(_repoId, symbolId, execute) {
+    const escapedSymbolId = symbolId.replace(/'/g, "''");
+    const rows = await execute(`
+    MATCH (symbol {id: '${escapedSymbolId}'})-[r:CodeRelation]->(component:CodeElement)
+    WHERE r.type IN ['UNITY_COMPONENT_INSTANCE', 'UNITY_SERIALIZED_TYPE_IN']
+    RETURN component.filePath AS resourcePath, component.description AS payload, r.type AS relationType, r.reason AS relationReason
+    ORDER BY component.filePath, component.id
+  `);
+    return projectUnityBindings(rows);
+}
+export function projectUnityBindings(rows) {
+    const resourceBindings = [];
+    const scalarFields = [];
+    const referenceFields = [];
+    const unityDiagnostics = [];
+    for (const row of rows) {
+        const rawPayload = row?.payload ?? row?.description ?? row?.[1];
+        if (typeof rawPayload !== 'string' || rawPayload.length === 0) {
+            continue;
+        }
+        try {
+            const parsed = JSON.parse(rawPayload);
+            const binding = {
+                resourcePath: parsed.resourcePath || row?.resourcePath || row?.[0] || '',
+                resourceType: parsed.resourceType || inferResourceType(parsed.resourcePath || row?.resourcePath || row?.[0] || ''),
+                bindingKind: parsed.bindingKind || 'direct',
+                componentObjectId: parsed.componentObjectId || '',
+                evidence: parsed.evidence || buildSyntheticEvidence(row),
+                serializedFields: parsed.serializedFields || { scalarFields: [], referenceFields: [] },
+                resolvedReferences: parsed.resolvedReferences || [],
+                assetRefPaths: normalizeAssetRefPaths(parsed.assetRefPaths) || extractAssetRefPathReferences(parsed.serializedFields || { scalarFields: [], referenceFields: [] }),
+            };
+            resourceBindings.push(binding);
+            scalarFields.push(...binding.serializedFields.scalarFields);
+            referenceFields.push(...binding.serializedFields.referenceFields);
+        }
+        catch (error) {
+            unityDiagnostics.push(error instanceof Error ? error.message : String(error));
+        }
+    }
+    return {
+        resourceBindings,
+        serializedFields: {
+            scalarFields,
+            referenceFields,
+        },
+        unityDiagnostics,
+    };
+}
+function inferResourceType(resourcePath) {
+    if (resourcePath.endsWith('.prefab'))
+        return 'prefab';
+    if (resourcePath.endsWith('.asset'))
+        return 'asset';
+    return 'scene';
+}
+function buildSyntheticEvidence(row) {
+    const relationType = String(row?.relationType || '').trim();
+    const relationReason = String(row?.relationReason || '').trim();
+    if (!relationType && !relationReason) {
+        return { line: 0, lineText: '' };
+    }
+    return {
+        line: 0,
+        lineText: relationReason ? `${relationType}:${relationReason}` : relationType,
+    };
+}
+function normalizeAssetRefPaths(input) {
+    if (!Array.isArray(input) || input.length === 0) {
+        return undefined;
+    }
+    const rows = [];
+    for (const row of input) {
+        if (!row || typeof row !== 'object')
+            continue;
+        const parentFieldName = String(row.parentFieldName || '').trim();
+        const fieldName = String(row.fieldName || '').trim();
+        const relativePath = String(row.relativePath || '');
+        const sourceLayer = String(row.sourceLayer || 'unknown');
+        rows.push({
+            parentFieldName: parentFieldName || fieldName || 'unknown',
+            fieldName: fieldName || parentFieldName || 'unknown',
+            relativePath,
+            sourceLayer,
+            isEmpty: Boolean(row.isEmpty ?? relativePath.length === 0),
+            isSprite: Boolean(row.isSprite),
+        });
+    }
+    return rows.length > 0 ? rows : undefined;
+}

package/dist/mcp/local/unity-enrichment.test.d.ts

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

package/dist/mcp/local/unity-enrichment.test.js

@@ -0,0 +1,130 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { loadUnityContext, projectUnityBindings } from './unity-enrichment.js';
+test('projectUnityBindings restores graph-native Unity payload rows', () => {
+    const out = projectUnityBindings([
+        {
+            resourcePath: 'Assets/Scene/MainUIManager.unity',
+            payload: JSON.stringify({
+                resourcePath: 'Assets/Scene/MainUIManager.unity',
+                resourceType: 'scene',
+                bindingKind: 'nested',
+                componentObjectId: '11400000',
+                evidence: { line: 9, lineText: '  m_Script: {...}' },
+                serializedFields: {
+                    scalarFields: [{ name: 'needPause', value: '1', valueType: 'number', sourceLayer: 'scene' }],
+                    referenceFields: [{ name: 'mainUIDocument', guid: 'abc', sourceLayer: 'scene' }],
+                },
+            }),
+        },
+    ]);
+    assert.equal(out.resourceBindings[0].bindingKind, 'nested');
+    assert.ok(out.serializedFields.scalarFields.length >= 1);
+    assert.ok(out.serializedFields.referenceFields.length >= 1);
+});
+test('loadUnityContext queries component payload rows and projects stable output', async () => {
+    const out = await loadUnityContext('repo-id', 'Class:Assets/Scripts/MainUIManager.cs:MainUIManager', async (query) => {
+        assert.match(query, /UNITY_COMPONENT_INSTANCE/);
+        assert.match(query, /UNITY_SERIALIZED_TYPE_IN/);
+        return [
+            {
+                resourcePath: 'Assets/Scene/MainUIManager.unity',
+                payload: JSON.stringify({
+                    resourcePath: 'Assets/Scene/MainUIManager.unity',
+                    resourceType: 'scene',
+                    bindingKind: 'scene-override',
+                    componentObjectId: '11400000',
+                    evidence: { line: 9, lineText: '  m_Script: {...}' },
+                    serializedFields: {
+                        scalarFields: [{ name: 'needPause', value: '1', valueType: 'number', sourceLayer: 'scene' }],
+                        referenceFields: [],
+                    },
+                }),
+            },
+        ];
+    });
+    assert.equal(out.resourceBindings[0]?.bindingKind, 'scene-override');
+    assert.equal(out.serializedFields.scalarFields[0]?.name, 'needPause');
+    assert.deepEqual(out.unityDiagnostics, []);
+});
+test('loadUnityContext returns resourceBindings for UNITY_SERIALIZED_TYPE_IN relations', async () => {
+    const out = await loadUnityContext('repo-id', 'Class:Assets/Scripts/AssetRef.cs:AssetRef', async () => [
+        {
+            relationType: 'UNITY_SERIALIZED_TYPE_IN',
+            relationReason: '{"hostSymbol":"InventoryConfig","fieldName":"icon","declaredType":"AssetRef"}',
+            resourcePath: 'Assets/Config/Inventory.asset',
+            payload: JSON.stringify({
+                resourceType: 'asset',
+                serializedFields: { scalarFields: [], referenceFields: [] },
+            }),
+        },
+    ]);
+    assert.equal(out.resourceBindings.length, 1);
+    assert.equal(out.resourceBindings[0]?.resourcePath, 'Assets/Config/Inventory.asset');
+    assert.equal(out.resourceBindings[0]?.resourceType, 'asset');
+});
+test('projectUnityBindings preserves structured assetRefPaths from payload', () => {
+    const out = projectUnityBindings([
+        {
+            resourcePath: 'Assets/NEON/DataAssets/CharacterList.asset',
+            payload: JSON.stringify({
+                resourcePath: 'Assets/NEON/DataAssets/CharacterList.asset',
+                resourceType: 'asset',
+                bindingKind: 'prefab-instance',
+                componentObjectId: '11400000',
+                assetRefPaths: [
+                    {
+                        parentFieldName: 'Values',
+                        fieldName: '_Head_Ref',
+                        relativePath: 'Assets/NEON/Art/Sprites/UI/0_pixle/ui_character_head/hero_head_Nik.png',
+                        sourceLayer: 'asset',
+                        isEmpty: false,
+                        isSprite: true,
+                    },
+                ],
+                serializedFields: {
+                    scalarFields: [],
+                    referenceFields: [],
+                },
+            }),
+        },
+    ]);
+    assert.equal(out.resourceBindings.length, 1);
+    assert.equal(out.resourceBindings[0]?.assetRefPaths?.length, 1);
+    assert.equal(out.resourceBindings[0]?.assetRefPaths?.[0]?.fieldName, '_Head_Ref');
+    assert.equal(out.resourceBindings[0]?.assetRefPaths?.[0]?.isSprite, true);
+});
+test('projectUnityBindings derives assetRefPaths from serialized scalar fields when payload lacks structured rows', () => {
+    const out = projectUnityBindings([
+        {
+            resourcePath: 'Assets/NEON/DataAssets/CharacterList.asset',
+            payload: JSON.stringify({
+                resourcePath: 'Assets/NEON/DataAssets/CharacterList.asset',
+                resourceType: 'asset',
+                bindingKind: 'prefab-instance',
+                componentObjectId: '11400000',
+                serializedFields: {
+                    scalarFields: [
+                        {
+                            name: 'Values',
+                            sourceLayer: 'asset',
+                            value: `
+_Head_Ref:
+  _relativePath: Assets/NEON/Art/Sprites/UI/0_pixle/ui_character_head/hero_head_Nik.png
+_actorPrefabRef:
+  _relativePath: Assets/ActorPrefab/Actor_Nik/V_Actor_Nik.prefab
+`,
+                        },
+                    ],
+                    referenceFields: [],
+                },
+            }),
+        },
+    ]);
+    const refs = out.resourceBindings[0]?.assetRefPaths || [];
+    assert.equal(refs.length, 2);
+    assert.equal(refs[0]?.fieldName, '_Head_Ref');
+    assert.equal(refs[0]?.isSprite, true);
+    assert.equal(refs[1]?.fieldName, '_actorPrefabRef');
+    assert.equal(refs[1]?.isSprite, false);
+});

package/dist/mcp/resources.js

@@ -186,7 +186,7 @@ async function getContextResource(backend, repoName) {
     lines.push('  - cypher: Raw graph queries');
     lines.push('  - list_repos: Discover all indexed repositories');
     lines.push('');
-    lines.push('re_index: Run `npx gitnexus analyze` in terminal if data is stale');
+    lines.push('re_index: If data is stale, ask user whether to run `npx -y gitnexus analyze` (reuses previous analyze scope/options unless `--no-reuse-options` is passed). If user declines, clearly state retrieval may not reflect current code. For build/analyze/test commands, use 10-30 minute timeout; on failure/timeout, report exact tool output and do not auto-retry or silently switch to glob/grep fallback.');
     lines.push('');
     lines.push('resources_available:');
     lines.push('  - gitnexus://repos: All indexed repositories');

package/dist/mcp/staleness.js

@@ -17,7 +17,7 @@ export function checkStaleness(repoPath, lastCommit) {
             return {
                 isStale: true,
                 commitsBehind,
-                hint: `⚠️ Index is ${commitsBehind} commit${commitsBehind > 1 ? 's' : ''} behind HEAD. Run analyze tool to update.`,
+                hint: `⚠️ Index is ${commitsBehind} commit${commitsBehind > 1 ? 's' : ''} behind HEAD. Ask user whether to run analyze to rebuild index; if not rebuilt, retrieval may not match current code.`,
             };
         }
         return { isStale: false, commitsBehind: 0 };

package/dist/mcp/tools.js

@@ -45,6 +45,12 @@ Hybrid ranking: BM25 keyword + semantic vector search, ranked by Reciprocal Rank
                 limit: { type: 'number', description: 'Max processes to return (default: 5)', default: 5 },
                 max_symbols: { type: 'number', description: 'Max symbols per process (default: 10)', default: 10 },
                 include_content: { type: 'boolean', description: 'Include full symbol source code (default: false)', default: false },
+                unity_resources: {
+                    type: 'string',
+                    enum: ['off', 'on', 'auto'],
+                    description: 'Unity resource retrieval mode (default: off)',
+                    default: 'off',
+                },
                 repo: { type: 'string', description: 'Repository name or path. Omit if only one repo is indexed.' },
             },
             required: ['query'],
@@ -106,6 +112,12 @@ Handles disambiguation: if multiple symbols share the same name, returns candida
                 uid: { type: 'string', description: 'Direct symbol UID from prior tool results (zero-ambiguity lookup)' },
                 file_path: { type: 'string', description: 'File path to disambiguate common names' },
                 include_content: { type: 'boolean', description: 'Include full symbol source code (default: false)', default: false },
+                unity_resources: {
+                    type: 'string',
+                    enum: ['off', 'on', 'auto'],
+                    description: 'Unity resource retrieval mode (default: off)',
+                    default: 'off',
+                },
                 repo: { type: 'string', description: 'Repository name or path. Omit if only one repo is indexed.' },
             },
             required: [],

package/dist/storage/repo-manager.d.ts

@@ -9,6 +9,12 @@ export interface RepoMeta {
     repoPath: string;
     lastCommit: string;
     indexedAt: string;
+    analyzeOptions?: {
+        includeExtensions?: string[];
+        scopeRules?: string[];
+        repoAlias?: string;
+        embeddings?: boolean;
+    };
     stats?: {
         files?: number;
         nodes?: number;

package/dist/types/pipeline.d.ts

@@ -1,6 +1,7 @@
 import { GraphNode, GraphRelationship, KnowledgeGraph } from '../core/graph/types.js';
 import { CommunityDetectionResult } from '../core/ingestion/community-processor.js';
 import { ProcessDetectionResult } from '../core/ingestion/process-processor.js';
+import type { UnityResourceProcessingResult } from '../core/ingestion/unity-resource-processor.js';
 import type { ScopeSelectionDiagnostics } from '../core/ingestion/scope-filter.js';
 export type PipelinePhase = 'idle' | 'extracting' | 'structure' | 'parsing' | 'imports' | 'calls' | 'heritage' | 'communities' | 'processes' | 'enriching' | 'complete' | 'error';
 export interface PipelineProgress {
@@ -14,6 +15,10 @@ export interface PipelineProgress {
         nodesCreated: number;
     };
 }
+export interface PipelineRunOptions {
+    includeExtensions?: string[];
+    scopeRules?: string[];
+}
 export interface PipelineResult {
     graph: KnowledgeGraph;
     /** Absolute path to the repo root — used for lazy file reads during KuzuDB loading */
@@ -22,6 +27,7 @@ export interface PipelineResult {
     totalFileCount: number;
     communityResult?: CommunityDetectionResult;
     processResult?: ProcessDetectionResult;
+    unityResult?: UnityResourceProcessingResult;
     scopeDiagnostics?: ScopeSelectionDiagnostics;
 }
 export interface SerializablePipelineResult {
@@ -29,6 +35,7 @@ export interface SerializablePipelineResult {
     relationships: GraphRelationship[];
     repoPath: string;
     totalFileCount: number;
+    unityResult?: UnityResourceProcessingResult;
 }
 export declare const serializePipelineResult: (result: PipelineResult) => SerializablePipelineResult;
 export declare const deserializePipelineResult: (serialized: SerializablePipelineResult, createGraph: () => KnowledgeGraph) => PipelineResult;

package/dist/types/pipeline.js

@@ -4,6 +4,7 @@ export const serializePipelineResult = (result) => ({
     relationships: [...result.graph.iterRelationships()],
     repoPath: result.repoPath,
     totalFileCount: result.totalFileCount,
+    unityResult: result.unityResult,
 });
 // Helper to reconstruct from serializable format (used in main thread)
 export const deserializePipelineResult = (serialized, createGraph) => {
@@ -14,5 +15,6 @@ export const deserializePipelineResult = (serialized, createGraph) => {
         graph,
         repoPath: serialized.repoPath,
         totalFileCount: serialized.totalFileCount,
+        unityResult: serialized.unityResult,
     };
 };