@veewo/gitnexus 1.3.8 → 1.3.10

package/dist/core/graph/types.d.ts

@@ -20,7 +20,7 @@ export type NodeProperties = {
     entryPointScore?: number;
     entryPointReason?: string;
 };
-export type RelationshipType = 'CONTAINS' | 'CALLS' | 'INHERITS' | 'OVERRIDES' | 'IMPORTS' | 'USES' | 'DEFINES' | 'DECORATES' | 'IMPLEMENTS' | 'EXTENDS' | 'MEMBER_OF' | 'STEP_IN_PROCESS';
+export type RelationshipType = 'CONTAINS' | 'CALLS' | 'INHERITS' | 'OVERRIDES' | 'IMPORTS' | 'USES' | 'DEFINES' | 'DECORATES' | 'IMPLEMENTS' | 'EXTENDS' | 'MEMBER_OF' | 'STEP_IN_PROCESS' | 'UNITY_COMPONENT_IN' | 'UNITY_COMPONENT_INSTANCE' | 'UNITY_SERIALIZED_TYPE_IN';
 export interface GraphNode {
     id: string;
     label: NodeLabel;

package/dist/core/ingestion/pipeline.d.ts

@@ -1,5 +1,3 @@
 import { PipelineProgress, PipelineResult } from '../../types/pipeline.js';
-export declare const runPipelineFromRepo: (repoPath: string, onProgress: (progress: PipelineProgress) => void, options?: {
-    includeExtensions?: string[];
-    scopeRules?: string[];
-}) => Promise<PipelineResult>;
+import type { PipelineRunOptions } from '../../types/pipeline.js';
+export declare const runPipelineFromRepo: (repoPath: string, onProgress: (progress: PipelineProgress) => void, options?: PipelineRunOptions) => Promise<PipelineResult>;

package/dist/core/ingestion/pipeline.js

@@ -6,6 +6,7 @@ import { processCalls, processCallsFromExtracted } from './call-processor.js';
 import { processHeritage, processHeritageFromExtracted } from './heritage-processor.js';
 import { processCommunities } from './community-processor.js';
 import { processProcesses } from './process-processor.js';
+import { processUnityResources } from './unity-resource-processor.js';
 import { createSymbolTable } from './symbol-table.js';
 import { createASTCache } from './ast-cache.js';
 import { walkRepositoryPaths, readFileContents } from './filesystem-walker.js';
@@ -74,6 +75,9 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
             stats: { filesProcessed: 0, totalFiles, nodesCreated: graph.nodeCount },
         });
         const allPaths = extensionFiltered.map(f => f.path);
+        const unityScopedPaths = (options?.scopeRules && options.scopeRules.length > 0)
+            ? scopedFiles.map(f => f.path)
+            : allPaths;
         processStructure(graph, allPaths);
         onProgress({
             phase: 'structure',
@@ -296,6 +300,13 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
                 step: step.step,
             });
         });
+        onProgress({
+            phase: 'enriching',
+            percent: 99,
+            message: 'Extracting Unity resource bindings...',
+            stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: graph.nodeCount },
+        });
+        const unityResult = await processUnityResources(graph, { repoPath, scopedPaths: unityScopedPaths });
         onProgress({
             phase: 'complete',
             percent: 100,
@@ -313,6 +324,7 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
             totalFileCount: totalFiles,
             communityResult,
             processResult,
+            unityResult,
             scopeDiagnostics: scopeSelection.diagnostics,
         };
     }

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

@@ -0,0 +1,26 @@
+import type { KnowledgeGraph } from '../graph/types.js';
+import { buildUnityScanContext } from '../unity/scan-context.js';
+import { resolveUnityBindings } from '../unity/resolver.js';
+export interface UnityResourceProcessingResult {
+    processedSymbols: number;
+    bindingCount: number;
+    componentCount: number;
+    diagnostics: string[];
+    timingsMs: {
+        scanContext: number;
+        resolve: number;
+        graphWrite: number;
+        total: number;
+    };
+}
+export type UnityPayloadMode = 'compact' | 'full';
+export interface UnityResourceProcessingOptions {
+    repoPath: string;
+    scopedPaths?: string[];
+    payloadMode?: UnityPayloadMode;
+}
+export interface UnityResourceProcessingDeps {
+    buildScanContext?: typeof buildUnityScanContext;
+    resolveBindings?: typeof resolveUnityBindings;
+}
+export declare function processUnityResources(graph: KnowledgeGraph, options: UnityResourceProcessingOptions, deps?: UnityResourceProcessingDeps): Promise<UnityResourceProcessingResult>;

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

@@ -0,0 +1,363 @@
+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';
+const UNITY_DIAGNOSTIC_SAMPLE_LIMIT = 3;
+export async function processUnityResources(graph, options, deps) {
+    const tStart = performance.now();
+    const buildScanContextFn = deps?.buildScanContext || buildUnityScanContext;
+    const resolveBindingsFn = deps?.resolveBindings || resolveUnityBindings;
+    const payloadMode = resolveUnityPayloadMode(options.payloadMode);
+    const classNodes = [...graph.iterNodes()].filter((node) => node.label === 'Class' && String(node.properties.filePath || '').endsWith('.cs'));
+    const symbolDeclarations = classNodes
+        .map((node) => ({
+        symbol: String(node.properties.name || '').trim(),
+        scriptPath: String(node.properties.filePath || '').trim(),
+    }))
+        .filter((entry) => entry.symbol.length > 0 && entry.scriptPath.length > 0);
+    let processedSymbols = 0;
+    let bindingCount = 0;
+    let componentCount = 0;
+    const diagnostics = [];
+    const issueDiagnostics = [];
+    let scanContext;
+    let symbolsWithResourceHits = new Set();
+    let skippedNoGuidHit = 0;
+    let skippedMissingCanonical = 0;
+    let skippedNonCanonical = 0;
+    let canonicalSelected = 0;
+    let serializedTypeEdgeCount = 0;
+    let serializedTypeMissCount = 0;
+    const serializedTypeSymbols = new Set();
+    const resolvedBySymbol = new Map();
+    const resolveErrorBySymbol = new Map();
+    let scanContextMs = 0;
+    let resolveMs = 0;
+    let graphWriteMs = 0;
+    try {
+        const tScanContextStart = performance.now();
+        scanContext = await buildScanContextFn({
+            repoRoot: options.repoPath,
+            scopedPaths: options.scopedPaths,
+            symbolDeclarations,
+        });
+        scanContextMs += performance.now() - tScanContextStart;
+        const uniqueResourcePaths = new Set();
+        for (const hits of scanContext.guidToResourceHits.values()) {
+            for (const hit of hits) {
+                uniqueResourcePaths.add(hit.resourcePath);
+            }
+        }
+        diagnostics.push(`scanContext: scripts=${scanContext.symbolToScriptPath.size}, guids=${scanContext.scriptPathToGuid.size}, resources=${uniqueResourcePaths.size}`);
+        symbolsWithResourceHits = collectSymbolsWithResourceHits(scanContext);
+    }
+    catch (error) {
+        if (scanContextMs === 0) {
+            scanContextMs = performance.now() - tStart;
+        }
+        diagnostics.push(error instanceof Error ? error.message : String(error));
+    }
+    const canonicalClassNodeBySymbol = buildCanonicalClassNodeIndex(classNodes, scanContext);
+    for (const classNode of classNodes) {
+        const symbol = String(classNode.properties.name || '').trim();
+        if (!symbol)
+            continue;
+        if (scanContext) {
+            const canonicalScriptPath = getCanonicalScriptPath(scanContext, symbol);
+            if (!canonicalScriptPath) {
+                skippedMissingCanonical += 1;
+                continue;
+            }
+            const classNodePath = normalizePath(String(classNode.properties.filePath || '').trim());
+            if (classNodePath !== canonicalScriptPath) {
+                skippedNonCanonical += 1;
+                continue;
+            }
+            canonicalSelected += 1;
+            if (!symbolsWithResourceHits.has(symbol)) {
+                skippedNoGuidHit += 1;
+                continue;
+            }
+        }
+        try {
+            const resolveError = resolveErrorBySymbol.get(symbol);
+            if (resolveError) {
+                issueDiagnostics.push(resolveError);
+                continue;
+            }
+            let resolved = resolvedBySymbol.get(symbol);
+            if (!resolved) {
+                const tResolveStart = performance.now();
+                resolved = await resolveBindingsFn({ repoRoot: options.repoPath, symbol, scanContext });
+                resolveMs += performance.now() - tResolveStart;
+                resolvedBySymbol.set(symbol, resolved);
+            }
+            issueDiagnostics.push(...resolved.unityDiagnostics);
+            if (resolved.resourceBindings.length === 0) {
+                continue;
+            }
+            processedSymbols += 1;
+            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);
+                serializedTypeEdgeCount += serializableTypeLinking.edgeCount;
+                serializedTypeMissCount += serializableTypeLinking.missCount;
+                for (const hitSymbol of serializableTypeLinking.symbols) {
+                    serializedTypeSymbols.add(hitSymbol);
+                }
+                graphWriteMs += performance.now() - tWriteStart;
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            resolveErrorBySymbol.set(symbol, message);
+            issueDiagnostics.push(message);
+        }
+    }
+    if (skippedNoGuidHit > 0) {
+        diagnostics.push(`prefilter: skipped ${skippedNoGuidHit} symbol(s) without guid resource hits`);
+    }
+    diagnostics.push(`canonical: selected=${canonicalSelected}, skip-non-canonical=${skippedNonCanonical}, missing-canonical=${skippedMissingCanonical}`);
+    diagnostics.push(`serialized-type: edges=${serializedTypeEdgeCount}, symbols=${serializedTypeSymbols.size}, misses=${serializedTypeMissCount}`);
+    if (skippedMissingCanonical > 0) {
+        diagnostics.push(`prefilter: skipped ${skippedMissingCanonical} symbol(s) missing canonical script mapping`);
+    }
+    diagnostics.push(...aggregateUnityDiagnostics(issueDiagnostics));
+    return {
+        processedSymbols,
+        bindingCount,
+        componentCount,
+        diagnostics,
+        timingsMs: {
+            scanContext: roundMs(scanContextMs),
+            resolve: roundMs(resolveMs),
+            graphWrite: roundMs(graphWriteMs),
+            total: roundMs(performance.now() - tStart),
+        },
+    };
+}
+function collectSymbolsWithResourceHits(scanContext) {
+    const symbols = new Set();
+    const canonicalEntries = scanContext.symbolToCanonicalScriptPath?.entries() || scanContext.symbolToScriptPath.entries();
+    for (const [symbol, scriptPath] of canonicalEntries) {
+        const guid = scanContext.scriptPathToGuid.get(scriptPath);
+        if (!guid)
+            continue;
+        if ((scanContext.guidToResourceHits.get(guid) || []).length === 0)
+            continue;
+        symbols.add(symbol);
+    }
+    return symbols;
+}
+function getCanonicalScriptPath(scanContext, symbol) {
+    const canonicalPath = scanContext.symbolToCanonicalScriptPath?.get(symbol);
+    if (canonicalPath) {
+        return normalizePath(canonicalPath);
+    }
+    const fallbackPath = scanContext.symbolToScriptPath.get(symbol);
+    if (fallbackPath) {
+        return normalizePath(fallbackPath);
+    }
+    return undefined;
+}
+function normalizePath(filePath) {
+    return filePath.replace(/\\/g, '/');
+}
+function resolveUnityPayloadMode(explicit) {
+    if (explicit)
+        return explicit;
+    const envMode = String(process.env.GITNEXUS_UNITY_PAYLOAD_MODE || '').trim().toLowerCase();
+    if (envMode === 'full')
+        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 {
+        id: generateId('CodeElement', `${binding.resourcePath}:${binding.componentObjectId}`),
+        label: 'CodeElement',
+        properties: {
+            name: `${symbol}@${binding.componentObjectId}`,
+            filePath: binding.resourcePath,
+            startLine: binding.evidence.line,
+            endLine: binding.evidence.line,
+            description: JSON.stringify(payload),
+        },
+    };
+}
+function buildUnityPayload(binding, mode) {
+    const payload = {
+        bindingKind: binding.bindingKind,
+        componentObjectId: binding.componentObjectId,
+    };
+    if (binding.serializedFields.scalarFields.length > 0 || binding.serializedFields.referenceFields.length > 0) {
+        payload.serializedFields = binding.serializedFields;
+    }
+    if (binding.resolvedReferences && binding.resolvedReferences.length > 0) {
+        payload.resolvedReferences = binding.resolvedReferences;
+    }
+    if (binding.assetRefPaths && binding.assetRefPaths.length > 0) {
+        payload.assetRefPaths = binding.assetRefPaths;
+    }
+    if (mode === 'full') {
+        payload.resourcePath = binding.resourcePath;
+        payload.resourceType = binding.resourceType;
+        payload.evidence = binding.evidence;
+    }
+    return payload;
+}
+function buildCanonicalClassNodeIndex(classNodes, scanContext) {
+    const index = new Map();
+    for (const classNode of classNodes) {
+        const symbol = String(classNode.properties.name || '').trim();
+        if (!symbol || index.has(symbol))
+            continue;
+        const classPath = normalizePath(String(classNode.properties.filePath || '').trim());
+        const canonicalPath = scanContext ? getCanonicalScriptPath(scanContext, symbol) : undefined;
+        if (canonicalPath && classPath !== canonicalPath) {
+            continue;
+        }
+        index.set(symbol, classNode);
+    }
+    return index;
+}
+function linkSerializableTypeEdges(graph, componentNode, hostSymbol, binding, scanContext, canonicalClassNodeBySymbol) {
+    const stats = {
+        edgeCount: 0,
+        missCount: 0,
+        symbols: new Set(),
+    };
+    if (!scanContext)
+        return stats;
+    const serializableSymbols = scanContext.serializableSymbols;
+    const hostFieldTypeHints = scanContext.hostFieldTypeHints;
+    if (!serializableSymbols || !hostFieldTypeHints)
+        return stats;
+    const hostHints = hostFieldTypeHints.get(hostSymbol);
+    if (!hostHints || hostHints.size === 0)
+        return stats;
+    const fieldSourceLayer = collectBindingFieldSources(binding);
+    if (fieldSourceLayer.size === 0)
+        return stats;
+    for (const [fieldName, declaredType] of hostHints.entries()) {
+        if (!serializableSymbols.has(declaredType))
+            continue;
+        const sourceLayer = fieldSourceLayer.get(fieldName);
+        if (!sourceLayer)
+            continue;
+        const serializableNode = canonicalClassNodeBySymbol.get(declaredType);
+        if (!serializableNode) {
+            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.edgeCount += 1;
+        stats.symbols.add(declaredType);
+    }
+    return stats;
+}
+function collectBindingFieldSources(binding) {
+    const fieldSources = new Map();
+    for (const field of binding.serializedFields.scalarFields) {
+        if (!fieldSources.has(field.name)) {
+            fieldSources.set(field.name, field.sourceLayer || 'unknown');
+        }
+    }
+    for (const field of binding.serializedFields.referenceFields) {
+        if (!fieldSources.has(field.name)) {
+            fieldSources.set(field.name, field.sourceLayer || 'unknown');
+        }
+    }
+    return fieldSources;
+}
+function roundMs(value) {
+    return Number(value.toFixed(1));
+}
+function aggregateUnityDiagnostics(messages) {
+    if (messages.length === 0) {
+        return [];
+    }
+    const buckets = new Map();
+    for (const message of messages) {
+        const category = classifyUnityDiagnostic(message);
+        const bucket = buckets.get(category) || { count: 0, samples: [] };
+        bucket.count += 1;
+        if (bucket.samples.length < UNITY_DIAGNOSTIC_SAMPLE_LIMIT && !bucket.samples.includes(message)) {
+            bucket.samples.push(message);
+        }
+        buckets.set(category, bucket);
+    }
+    const ordered = [...buckets.entries()].sort((left, right) => right[1].count - left[1].count);
+    const lines = [
+        `diagnostics: aggregated ${messages.length} issue(s) across ${ordered.length} category(ies); sampleLimit=${UNITY_DIAGNOSTIC_SAMPLE_LIMIT}`,
+    ];
+    for (const [category, bucket] of ordered) {
+        lines.push(`diagnostics: category=${category} count=${bucket.count} sampleCount=${bucket.samples.length}`);
+        for (const sample of bucket.samples) {
+            lines.push(`diagnostics: sample[${category}] ${sample}`);
+        }
+    }
+    return lines;
+}
+function classifyUnityDiagnostic(message) {
+    if (message.startsWith('No MonoBehaviour block matched script guid ')) {
+        return 'no-monobehaviour-match';
+    }
+    if (message.startsWith('Unity symbol "') && message.endsWith('" is ambiguous.')) {
+        return 'ambiguous-symbol';
+    }
+    if (message.startsWith('Unity symbol "') && message.includes('" was not found under ')) {
+        return 'symbol-not-found';
+    }
+    if (message.startsWith('No .meta guid found for ')) {
+        return 'missing-meta-guid';
+    }
+    return 'other';
+}

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

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