@veewo/gitnexus 1.3.10 → 1.3.11

package/dist/core/ingestion/unity-parity-seed.test.js

@@ -0,0 +1,35 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { buildUnityParitySeed } from './unity-parity-seed.js';
+test('buildUnityParitySeed extracts canonical script/guid/resource indexes', () => {
+    const seed = buildUnityParitySeed({
+        symbolToScriptPaths: new Map([
+            ['DoorObj', ['Assets/Code/DoorObj.generated.cs', 'Assets/Code/DoorObj.cs']],
+        ]),
+        symbolToCanonicalScriptPath: new Map([
+            ['DoorObj', 'Assets/Code/DoorObj.cs'],
+        ]),
+        symbolToScriptPath: new Map([
+            ['DoorObj', 'Assets/Code/DoorObj.cs'],
+        ]),
+        scriptPathToGuid: new Map([
+            ['Assets/Code/DoorObj.cs', 'abc123abc123abc123abc123abc123ab'],
+        ]),
+        guidToResourceHits: new Map([
+            ['abc123abc123abc123abc123abc123ab', [
+                    { resourcePath: 'Assets/Prefabs/Door.prefab', resourceType: 'prefab', line: 12, lineText: 'guid: abc123' },
+                ]],
+        ]),
+        assetGuidToPath: new Map([
+            ['asset0000000000000000000000000001', 'Assets/Config/Ref.asset'],
+        ]),
+        serializableSymbols: new Set(),
+        hostFieldTypeHints: new Map(),
+        resourceDocCache: new Map(),
+    });
+    assert.equal(seed.version, 1);
+    assert.equal(seed.symbolToScriptPath.DoorObj, 'Assets/Code/DoorObj.cs');
+    assert.equal(seed.scriptPathToGuid['Assets/Code/DoorObj.cs'], 'abc123abc123abc123abc123abc123ab');
+    assert.deepEqual(seed.guidToResourcePaths['abc123abc123abc123abc123abc123ab'], ['Assets/Prefabs/Door.prefab']);
+    assert.equal(seed.assetGuidToPath?.asset0000000000000000000000000001, 'Assets/Config/Ref.asset');
+});

package/dist/core/ingestion/unity-resource-processor.d.ts

@@ -1,11 +1,13 @@
 import type { KnowledgeGraph } from '../graph/types.js';
 import { buildUnityScanContext } from '../unity/scan-context.js';
 import { resolveUnityBindings } from '../unity/resolver.js';
+import { type UnityParitySeed } from './unity-parity-seed.js';
 export interface UnityResourceProcessingResult {
     processedSymbols: number;
     bindingCount: number;
     componentCount: number;
     diagnostics: string[];
+    paritySeed?: UnityParitySeed;
     timingsMs: {
         scanContext: number;
         resolve: number;

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

@@ -1,8 +1,8 @@
-import path from 'node:path';
 import { performance } from 'node:perf_hooks';
 import { generateId } from '../../lib/utils.js';
 import { buildUnityScanContext } from '../unity/scan-context.js';
 import { resolveUnityBindings } from '../unity/resolver.js';
+import { buildUnityParitySeed } from './unity-parity-seed.js';
 const UNITY_DIAGNOSTIC_SAMPLE_LIMIT = 3;
 export async function processUnityResources(graph, options, deps) {
     const tStart = performance.now();
@@ -98,37 +98,53 @@ export async function processUnityResources(graph, options, deps) {
                 continue;
             }
             processedSymbols += 1;
+            const tWriteStart = performance.now();
+            const summaryBySource = new Map();
+            const appendSummary = (sourceNodeId, binding) => {
+                const normalizedPath = normalizePath(binding.resourcePath);
+                const perPath = summaryBySource.get(sourceNodeId) || new Map();
+                const existing = perPath.get(normalizedPath) || {
+                    resourceType: binding.resourceType,
+                    bindingKinds: new Set(),
+                    lightweight: true,
+                };
+                existing.resourceType = binding.resourceType || existing.resourceType;
+                existing.bindingKinds.add(binding.bindingKind);
+                existing.lightweight = existing.lightweight && Boolean(binding.lightweight);
+                perPath.set(normalizedPath, existing);
+                summaryBySource.set(sourceNodeId, perPath);
+            };
             for (const binding of resolved.resourceBindings) {
-                const tWriteStart = performance.now();
                 bindingCount += 1;
-                componentCount += 1;
-                const resourceFileNode = ensureResourceFileNode(graph, binding.resourcePath);
-                const componentNode = createComponentNode(symbol, binding, payloadMode);
-                graph.addNode(componentNode);
-                graph.addRelationship({
-                    id: generateId('UNITY_COMPONENT_IN', `${classNode.id}:${binding.componentObjectId}->${resourceFileNode.id}`),
-                    type: 'UNITY_COMPONENT_IN',
-                    sourceId: classNode.id,
-                    targetId: resourceFileNode.id,
-                    confidence: 1.0,
-                    reason: binding.bindingKind,
-                });
-                graph.addRelationship({
-                    id: generateId('UNITY_COMPONENT_INSTANCE', `${classNode.id}->${componentNode.id}`),
-                    type: 'UNITY_COMPONENT_INSTANCE',
-                    sourceId: classNode.id,
-                    targetId: componentNode.id,
-                    confidence: 1.0,
-                    reason: binding.bindingKind,
-                });
-                const serializableTypeLinking = linkSerializableTypeEdges(graph, componentNode, symbol, binding, scanContext, canonicalClassNodeBySymbol);
+                appendSummary(classNode.id, binding);
+                const serializableTypeLinking = collectSerializableTypeTargetsForBinding(symbol, binding, scanContext, canonicalClassNodeBySymbol);
                 serializedTypeEdgeCount += serializableTypeLinking.edgeCount;
                 serializedTypeMissCount += serializableTypeLinking.missCount;
                 for (const hitSymbol of serializableTypeLinking.symbols) {
                     serializedTypeSymbols.add(hitSymbol);
                 }
-                graphWriteMs += performance.now() - tWriteStart;
+                for (const targetClassId of serializableTypeLinking.targetClassIds) {
+                    appendSummary(targetClassId, binding);
+                }
+            }
+            for (const [sourceNodeId, perPath] of summaryBySource.entries()) {
+                for (const [resourcePath, summary] of perPath.entries()) {
+                    const resourceFileId = generateId('File', resourcePath);
+                    graph.addRelationship({
+                        id: generateId('UNITY_RESOURCE_SUMMARY', `${sourceNodeId}->${resourceFileId}`),
+                        type: 'UNITY_RESOURCE_SUMMARY',
+                        sourceId: sourceNodeId,
+                        targetId: resourceFileId,
+                        confidence: 1.0,
+                        reason: JSON.stringify({
+                            resourceType: summary.resourceType,
+                            bindingKinds: [...summary.bindingKinds.values()].sort(),
+                            lightweight: true,
+                        }),
+                    });
+                }
             }
+            graphWriteMs += performance.now() - tWriteStart;
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
@@ -150,6 +166,7 @@ export async function processUnityResources(graph, options, deps) {
         bindingCount,
         componentCount,
         diagnostics,
+        paritySeed: scanContext ? buildUnityParitySeed(scanContext) : undefined,
         timingsMs: {
             scanContext: roundMs(scanContextMs),
             resolve: roundMs(resolveMs),
@@ -193,24 +210,6 @@ function resolveUnityPayloadMode(explicit) {
         return 'full';
     return 'compact';
 }
-function ensureResourceFileNode(graph, resourcePath) {
-    const normalizedResourcePath = resourcePath.replace(/\\/g, '/');
-    const fileId = generateId('File', normalizedResourcePath);
-    const existing = graph.getNode(fileId);
-    if (existing) {
-        return existing;
-    }
-    const node = {
-        id: fileId,
-        label: 'File',
-        properties: {
-            name: path.basename(normalizedResourcePath),
-            filePath: normalizedResourcePath,
-        },
-    };
-    graph.addNode(node);
-    return node;
-}
 function createComponentNode(symbol, binding, payloadMode) {
     const payload = buildUnityPayload(binding, payloadMode);
     return {
@@ -230,8 +229,12 @@ function buildUnityPayload(binding, mode) {
         bindingKind: binding.bindingKind,
         componentObjectId: binding.componentObjectId,
     };
-    if (binding.serializedFields.scalarFields.length > 0 || binding.serializedFields.referenceFields.length > 0) {
-        payload.serializedFields = binding.serializedFields;
+    if (binding.lightweight) {
+        payload.lightweight = true;
+    }
+    const serializedFields = compactSerializedFieldsForStorage(binding.serializedFields);
+    if (serializedFields.scalarFields.length > 0 || serializedFields.referenceFields.length > 0) {
+        payload.serializedFields = serializedFields;
     }
     if (binding.resolvedReferences && binding.resolvedReferences.length > 0) {
         payload.resolvedReferences = binding.resolvedReferences;
@@ -246,6 +249,22 @@ function buildUnityPayload(binding, mode) {
     }
     return payload;
 }
+function compactSerializedFieldsForStorage(input) {
+    return {
+        scalarFields: input.scalarFields.map((field) => ({
+            name: field.name,
+            sourceLayer: field.sourceLayer,
+            value: field.value,
+            valueType: field.valueType,
+        })),
+        referenceFields: input.referenceFields.map((field) => ({
+            name: field.name,
+            guid: field.guid,
+            fileId: field.fileId,
+            sourceLayer: field.sourceLayer,
+        })),
+    };
+}
 function buildCanonicalClassNodeIndex(classNodes, scanContext) {
     const index = new Map();
     for (const classNode of classNodes) {
@@ -261,11 +280,12 @@ function buildCanonicalClassNodeIndex(classNodes, scanContext) {
     }
     return index;
 }
-function linkSerializableTypeEdges(graph, componentNode, hostSymbol, binding, scanContext, canonicalClassNodeBySymbol) {
+function collectSerializableTypeTargetsForBinding(hostSymbol, binding, scanContext, canonicalClassNodeBySymbol) {
     const stats = {
         edgeCount: 0,
         missCount: 0,
         symbols: new Set(),
+        targetClassIds: new Set(),
     };
     if (!scanContext)
         return stats;
@@ -290,14 +310,7 @@ function linkSerializableTypeEdges(graph, componentNode, hostSymbol, binding, sc
             stats.missCount += 1;
             continue;
         }
-        graph.addRelationship({
-            id: generateId('UNITY_SERIALIZED_TYPE_IN', `${serializableNode.id}->${componentNode.id}:${fieldName}`),
-            type: 'UNITY_SERIALIZED_TYPE_IN',
-            sourceId: serializableNode.id,
-            targetId: componentNode.id,
-            confidence: 1.0,
-            reason: JSON.stringify({ hostSymbol, fieldName, declaredType, sourceLayer }),
-        });
+        stats.targetClassIds.add(serializableNode.id);
         stats.edgeCount += 1;
         stats.symbols.add(declaredType);
     }
@@ -317,6 +330,27 @@ function collectBindingFieldSources(binding) {
     }
     return fieldSources;
 }
+function collectResourceSummaryRows(bindings) {
+    const summaryByPath = new Map();
+    for (const binding of bindings) {
+        const resourcePath = normalizePath(binding.resourcePath);
+        const row = summaryByPath.get(resourcePath) || {
+            resourceType: binding.resourceType,
+            bindingKinds: new Set(),
+            lightweight: true,
+        };
+        row.resourceType = binding.resourceType || row.resourceType;
+        row.bindingKinds.add(binding.bindingKind);
+        row.lightweight = row.lightweight && Boolean(binding.lightweight);
+        summaryByPath.set(resourcePath, row);
+    }
+    return [...summaryByPath.entries()].map(([resourcePath, value]) => ({
+        resourcePath,
+        resourceType: value.resourceType,
+        bindingKinds: [...value.bindingKinds.values()].sort(),
+        lightweight: value.lightweight,
+    }));
+}
 function roundMs(value) {
     return Number(value.toFixed(1));
 }

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

@@ -8,7 +8,7 @@ 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');
 const symbols = ['Global', 'BattleMode', 'PlayerActor', 'MainUIManager'];
-test('processUnityResources adds Unity resource relationships and component payload nodes', async () => {
+test('processUnityResources does not emit UNITY_COMPONENT_IN or synthetic resource File nodes', async () => {
     const graph = createKnowledgeGraph();
     for (const symbol of symbols) {
         const filePath = `Assets/Scripts/${symbol}.cs`;
@@ -41,13 +41,17 @@ test('processUnityResources adds Unity resource relationships and component payl
     }
     const result = await processUnityResources(graph, { repoPath: fixtureRoot });
     const unityFileRelations = [...graph.iterRelationships()].filter((rel) => rel.type === 'UNITY_COMPONENT_IN');
-    const unityInstanceRelations = [...graph.iterRelationships()].filter((rel) => rel.type === 'UNITY_COMPONENT_INSTANCE');
-    const componentNodes = [...graph.iterNodes()].filter((node) => node.label === 'CodeElement' && /\.(unity|prefab)$/.test(String(node.properties.filePath)));
-    assert.ok(unityFileRelations.length > 0);
-    assert.ok(unityInstanceRelations.length > 0);
-    assert.ok(componentNodes.length > 0);
-    assert.ok(componentNodes.some((node) => String(node.properties.description).includes('mainUIDocument')));
+    const unitySummaryRelations = [...graph.iterRelationships()].filter((rel) => rel.type === 'UNITY_RESOURCE_SUMMARY');
+    const syntheticResourceFiles = [...graph.iterNodes()].filter((node) => node.label === 'File' && /\.(prefab|unity|asset)$/.test(String(node.properties.filePath)));
+    const componentNodes = [...graph.iterNodes()].filter((node) => node.label === 'CodeElement');
+    assert.equal(result.bindingCount > 0, true);
+    assert.equal(unityFileRelations.length, 0);
+    assert.equal(syntheticResourceFiles.length, 0);
+    assert.ok(unitySummaryRelations.length > 0);
+    assert.equal(componentNodes.length, 0);
     assert.ok(result.bindingCount >= symbols.length);
+    assert.equal(result.paritySeed?.version, 1);
+    assert.ok((result.paritySeed?.scriptPathToGuid || {})['Assets/Scripts/MainUIManager.cs']);
     assert.ok(result.timingsMs.scanContext >= 0);
     assert.ok(result.timingsMs.resolve >= 0);
     assert.ok(result.timingsMs.graphWrite > 0);
@@ -248,7 +252,7 @@ test('processUnityResources memoizes resolve results by symbol within one run',
     assert.equal(result.bindingCount, 1);
     assert.ok(result.diagnostics.some((line) => line.includes('skip-non-canonical=1')));
 });
-test('processUnityResources writes UNITY_COMPONENT_INSTANCE only for canonical class node', async () => {
+test('processUnityResources writes UNITY_RESOURCE_SUMMARY only for canonical class node', async () => {
     const graph = createKnowledgeGraph();
     const canonicalPath = 'Assets/Scripts/PlayerActor.cs';
     const partialPath = 'Assets/Scripts/PlayerActor.Visual.cs';
@@ -294,15 +298,15 @@ test('processUnityResources writes UNITY_COMPONENT_INSTANCE only for canonical c
             unityDiagnostics: [],
         }),
     });
-    const instanceRelations = [...graph.iterRelationships()].filter((rel) => rel.type === 'UNITY_COMPONENT_INSTANCE');
-    assert.equal(instanceRelations.length, 1);
-    assert.equal(instanceRelations[0]?.sourceId, canonicalClassId);
+    const summaryRelations = [...graph.iterRelationships()].filter((rel) => rel.type === 'UNITY_RESOURCE_SUMMARY');
+    assert.equal(summaryRelations.length, 1);
+    assert.equal(summaryRelations[0]?.sourceId, canonicalClassId);
     assert.equal(result.processedSymbols, 1);
     assert.equal(result.bindingCount, 1);
     assert.ok(result.diagnostics.some((line) => line.includes('selected=1')));
     assert.ok(result.diagnostics.some((line) => line.includes('skip-non-canonical=1')));
 });
-test('processUnityResources writes UNITY_SERIALIZED_TYPE_IN for serializable class field matches', async () => {
+test('processUnityResources writes UNITY_RESOURCE_SUMMARY for serializable class field matches', async () => {
     const graph = createKnowledgeGraph();
     const hostPath = 'Assets/Scripts/HostClass.cs';
     const serializablePath = 'Assets/Scripts/AssetRef.cs';
@@ -364,11 +368,11 @@ test('processUnityResources writes UNITY_SERIALIZED_TYPE_IN for serializable cla
             unityDiagnostics: [],
         }),
     });
-    const serializedTypeEdges = [...graph.iterRelationships()].filter((rel) => rel.type === 'UNITY_SERIALIZED_TYPE_IN');
-    assert.equal(serializedTypeEdges.length, 1);
-    assert.equal(serializedTypeEdges[0]?.sourceId, serializableClassId);
+    const summaryRelations = [...graph.iterRelationships()].filter((rel) => rel.type === 'UNITY_RESOURCE_SUMMARY');
+    const serializableSummary = summaryRelations.filter((rel) => rel.sourceId === serializableClassId);
+    assert.equal(serializableSummary.length, 1);
 });
-test('processUnityResources writes compact unity payload by default', async () => {
+test('processUnityResources writes compact UNITY_RESOURCE_SUMMARY reason by default', async () => {
     const graph = createKnowledgeGraph();
     const classId = generateId('Class', 'Assets/Scripts/Compact.cs:CompactSymbol');
     graph.addNode({
@@ -407,17 +411,14 @@ test('processUnityResources writes compact unity payload by default', async () =
             unityDiagnostics: [],
         }),
     });
-    const component = [...graph.iterNodes()].find((node) => node.label === 'CodeElement');
-    assert.ok(component);
-    const payload = JSON.parse(String(component.properties.description));
-    assert.equal(payload.bindingKind, 'scene-override');
-    assert.equal(payload.componentObjectId, '11400000');
-    assert.ok(Array.isArray(payload.serializedFields.scalarFields));
-    assert.equal(payload.resourcePath, undefined);
-    assert.equal(payload.resourceType, undefined);
-    assert.equal(payload.evidence, undefined);
+    const summary = [...graph.iterRelationships()].find((rel) => rel.type === 'UNITY_RESOURCE_SUMMARY');
+    assert.ok(summary);
+    const reason = JSON.parse(String(summary.reason || '{}'));
+    assert.deepEqual(reason.bindingKinds, ['scene-override']);
+    assert.equal(reason.lightweight, true);
+    assert.equal(reason.resourceType, 'scene');
 });
-test('processUnityResources includes structured assetRefPaths in component payload', async () => {
+test('processUnityResources keeps UNITY_RESOURCE_SUMMARY reason compact when bindings include assetRefPaths', async () => {
     const graph = createKnowledgeGraph();
     const classId = generateId('Class', 'Assets/Scripts/CharacterList.cs:CharacterList');
     graph.addNode({
@@ -464,14 +465,11 @@ test('processUnityResources includes structured assetRefPaths in component paylo
             unityDiagnostics: [],
         }),
     });
-    const component = [...graph.iterNodes()].find((node) => node.label === 'CodeElement');
-    assert.ok(component);
-    const payload = JSON.parse(String(component.properties.description));
-    assert.equal(payload.assetRefPaths?.length, 1);
-    assert.equal(payload.assetRefPaths?.[0]?.fieldName, '_Head_Ref');
-    assert.equal(payload.assetRefPaths?.[0]?.isSprite, true);
+    const summary = [...graph.iterRelationships()].find((rel) => rel.type === 'UNITY_RESOURCE_SUMMARY');
+    assert.ok(summary);
+    assert.equal(String(summary.reason).includes('assetRefPaths'), false);
 });
-test('processUnityResources writes full unity payload when payloadMode=full', async () => {
+test('processUnityResources summary-only persistence ignores full payload mode and keeps summary reason', async () => {
     const graph = createKnowledgeGraph();
     const classId = generateId('Class', 'Assets/Scripts/Full.cs:FullSymbol');
     graph.addNode({
@@ -507,12 +505,12 @@ test('processUnityResources writes full unity payload when payloadMode=full', as
             unityDiagnostics: [],
         }),
     });
-    const component = [...graph.iterNodes()].find((node) => node.label === 'CodeElement');
-    assert.ok(component);
-    const payload = JSON.parse(String(component.properties.description));
-    assert.equal(payload.resourcePath, 'Assets/Scene/Test.unity');
-    assert.equal(payload.resourceType, 'scene');
-    assert.equal(payload.evidence?.line, 9);
+    const summary = [...graph.iterRelationships()].find((rel) => rel.type === 'UNITY_RESOURCE_SUMMARY');
+    assert.ok(summary);
+    const reason = JSON.parse(String(summary.reason || '{}'));
+    assert.equal(reason.resourceType, 'scene');
+    assert.deepEqual(reason.bindingKinds, ['scene-override']);
+    assert.equal(String(summary.reason).includes('evidence'), false);
 });
 test('processUnityResources aggregates repetitive diagnostics with capped samples', async () => {
     const graph = createKnowledgeGraph();

package/dist/core/kuzu/csv-generator.d.ts

@@ -11,8 +11,27 @@
  * - Double quotes within fields are escaped by doubling them ("")
  * - All fields are consistently quoted for safety with code content
  */
-import { KnowledgeGraph } from '../graph/types.js';
+import { KnowledgeGraph, GraphNode } from '../graph/types.js';
 import { NodeTableName } from './schema.js';
+/**
+ * LRU content cache — avoids re-reading the same source file for every
+ * symbol defined in it. Sized generously so most files stay cached during
+ * the single-pass node iteration.
+ */
+export declare class FileContentCache {
+    private repoPath;
+    private maxBytes;
+    private cache;
+    private currentBytes;
+    constructor(repoPath: string, maxBytes?: number);
+    get(relativePath: string): Promise<string>;
+    setForTest(key: string, value: string): void;
+    hasForTest(key: string): boolean;
+    private touch;
+    private set;
+    private evictIfNeeded;
+}
+export declare function toCodeElementCsvRow(node: GraphNode, contentCache?: FileContentCache): Promise<string>;
 export interface StreamedCSVResult {
     nodeFiles: Map<NodeTableName, {
         csvPath: string;

package/dist/core/kuzu/csv-generator.js

@@ -39,6 +39,7 @@ const escapeCSVNumber = (value, defaultValue = -1) => {
         return String(defaultValue);
     return String(value);
 };
+const UNITY_RESOURCE_PATH_PATTERN = /\.(prefab|unity|asset)$/i;
 // ============================================================================
 // CONTENT EXTRACTION (lazy — reads from disk on demand)
 // ============================================================================
@@ -59,21 +60,23 @@ const isBinaryContent = (content) => {
  * symbol defined in it. Sized generously so most files stay cached during
  * the single-pass node iteration.
  */
-class FileContentCache {
-    cache = new Map();
-    accessOrder = [];
-    maxSize;
+export class FileContentCache {
     repoPath;
-    constructor(repoPath, maxSize = 3000) {
+    maxBytes;
+    cache = new Map();
+    currentBytes = 0;
+    constructor(repoPath, maxBytes = 128 * 1024 * 1024) {
         this.repoPath = repoPath;
-        this.maxSize = maxSize;
+        this.maxBytes = maxBytes;
     }
     async get(relativePath) {
         if (!relativePath)
             return '';
         const cached = this.cache.get(relativePath);
-        if (cached !== undefined)
-            return cached;
+        if (cached !== undefined) {
+            this.touch(relativePath, cached);
+            return cached.content;
+        }
         try {
             const fullPath = path.join(this.repoPath, relativePath);
             const content = await fs.readFile(fullPath, 'utf-8');
@@ -85,14 +88,38 @@ class FileContentCache {
             return '';
         }
     }
+    setForTest(key, value) {
+        this.set(key, value);
+    }
+    hasForTest(key) {
+        return this.cache.has(key);
+    }
+    touch(key, value) {
+        this.cache.delete(key);
+        this.cache.set(key, value);
+    }
     set(key, value) {
-        if (this.cache.size >= this.maxSize) {
-            const oldest = this.accessOrder.shift();
-            if (oldest)
-                this.cache.delete(oldest);
+        const prev = this.cache.get(key);
+        if (prev) {
+            this.currentBytes -= prev.sizeBytes;
+            this.cache.delete(key);
+        }
+        const sizeBytes = Buffer.byteLength(value, 'utf-8');
+        this.cache.set(key, { content: value, sizeBytes });
+        this.currentBytes += sizeBytes;
+        this.evictIfNeeded();
+    }
+    evictIfNeeded() {
+        while (this.currentBytes > this.maxBytes && this.cache.size > 0) {
+            const oldestKey = this.cache.keys().next().value;
+            if (!oldestKey)
+                break;
+            const oldest = this.cache.get(oldestKey);
+            this.cache.delete(oldestKey);
+            if (oldest) {
+                this.currentBytes -= oldest.sizeBytes;
+            }
         }
-        this.cache.set(key, value);
-        this.accessOrder.push(key);
     }
 }
 const extractContent = async (node, contentCache) => {
@@ -123,6 +150,56 @@ const extractContent = async (node, contentCache) => {
         ? snippet.slice(0, MAX_SNIPPET) + '\n... [truncated]'
         : snippet;
 };
+function compactUnityComponentDescription(description) {
+    const raw = typeof description === 'string' ? description : '';
+    if (!raw)
+        return '';
+    try {
+        const parsed = JSON.parse(raw);
+        const compact = {};
+        if (parsed.bindingKind)
+            compact.bindingKind = parsed.bindingKind;
+        if (parsed.componentObjectId)
+            compact.componentObjectId = parsed.componentObjectId;
+        if (parsed.lightweight)
+            compact.lightweight = true;
+        const scalarFields = parsed.serializedFields?.scalarFields || [];
+        const referenceFields = parsed.serializedFields?.referenceFields || [];
+        if (scalarFields.length > 0 || referenceFields.length > 0) {
+            compact.serializedFields = { scalarFields, referenceFields };
+        }
+        if (Array.isArray(parsed.resolvedReferences) && parsed.resolvedReferences.length > 0) {
+            compact.resolvedReferences = parsed.resolvedReferences;
+        }
+        if (Array.isArray(parsed.assetRefPaths) && parsed.assetRefPaths.length > 0) {
+            compact.assetRefPaths = parsed.assetRefPaths;
+        }
+        return JSON.stringify(Object.keys(compact).length > 0 ? compact : parsed);
+    }
+    catch {
+        return raw;
+    }
+}
+export async function toCodeElementCsvRow(node, contentCache) {
+    const filePath = String(node.properties.filePath || '');
+    const isUnityComponentRow = node.label === 'CodeElement' && UNITY_RESOURCE_PATH_PATTERN.test(filePath);
+    const content = isUnityComponentRow
+        ? ''
+        : (contentCache ? await extractContent(node, contentCache) : '');
+    const description = isUnityComponentRow
+        ? compactUnityComponentDescription(node.properties.description || '')
+        : String(node.properties.description || '');
+    return [
+        escapeCSVField(node.id),
+        escapeCSVField(node.properties.name || ''),
+        escapeCSVField(filePath),
+        escapeCSVNumber(node.properties.startLine, -1),
+        escapeCSVNumber(node.properties.endLine, -1),
+        node.properties.isExported ? 'true' : 'false',
+        escapeCSVField(content),
+        escapeCSVField(description),
+    ].join(',');
+}
 // ============================================================================
 // BUFFERED CSV WRITER
 // ============================================================================
@@ -266,17 +343,7 @@ export const streamAllCSVsToDisk = async (graph, repoPath, csvDir) => {
                 // Code element nodes (Function, Class, Interface, Method, CodeElement)
                 const writer = codeWriterMap[node.label];
                 if (writer) {
-                    const content = await extractContent(node, contentCache);
-                    await writer.addRow([
-                        escapeCSVField(node.id),
-                        escapeCSVField(node.properties.name || ''),
-                        escapeCSVField(node.properties.filePath || ''),
-                        escapeCSVNumber(node.properties.startLine, -1),
-                        escapeCSVNumber(node.properties.endLine, -1),
-                        node.properties.isExported ? 'true' : 'false',
-                        escapeCSVField(content),
-                        escapeCSVField(node.properties.description || ''),
-                    ].join(','));
+                    await writer.addRow(await toCodeElementCsvRow(node, contentCache));
                 }
                 else {
                     // Multi-language node types (Struct, Impl, Trait, Macro, etc.)

package/dist/core/kuzu/csv-generator.test.d.ts

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

package/dist/core/kuzu/csv-generator.test.js

@@ -0,0 +1,28 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { FileContentCache, toCodeElementCsvRow } from './csv-generator.js';
+test('FileContentCache evicts oldest entries when byte budget is exceeded', async () => {
+    const cache = new FileContentCache('/tmp/repo', 10);
+    cache.setForTest('a.cs', '123456');
+    cache.setForTest('b.cs', '123456');
+    assert.equal(cache.hasForTest('a.cs'), false);
+    assert.equal(cache.hasForTest('b.cs'), true);
+});
+test('Unity component CodeElement rows store compact description and empty content', async () => {
+    const row = await toCodeElementCsvRow({
+        id: 'CodeElement:Assets/A.prefab:114',
+        label: 'CodeElement',
+        properties: {
+            name: 'DoorObj@114',
+            filePath: 'Assets/A.prefab',
+            startLine: 12,
+            endLine: 12,
+            description: JSON.stringify({
+                bindingKind: 'direct',
+                componentObjectId: '114',
+                serializedFields: { scalarFields: [], referenceFields: [] },
+            }),
+        },
+    });
+    assert.match(row, /,\"\"\,\"\{/);
+});