@veewo/gitnexus 1.4.10-rc → 1.4.11-rc.2

package/dist/core/ingestion/process-processor.js

@@ -12,6 +12,8 @@
 import { calculateEntryPointScore, isTestFile } from './entry-point-scoring.js';
 import { SupportedLanguages } from '../../config/supported-languages.js';
 const isDev = process.env.NODE_ENV === 'development';
+const SYNTHETIC_RUNTIME_ROOT_MARKER = 'unity-runtime-root';
+const SYNTHETIC_RUNTIME_ROOT_TRACE_LIMIT = 8;
 const DEFAULT_CONFIG = {
     maxTraceDepth: 10,
     maxBranching: 4,
@@ -33,6 +35,7 @@ export const processProcesses = async (knowledgeGraph, memberships, onProgress,
     const membershipMap = new Map();
     memberships.forEach(m => membershipMap.set(m.nodeId, m.communityId));
     const callsEdges = buildCallsGraph(knowledgeGraph);
+    const callsEvidenceMap = buildCallsEvidenceMap(knowledgeGraph);
     const reverseCallsEdges = buildReverseCallsGraph(knowledgeGraph);
     const nodeMap = new Map();
     for (const n of knowledgeGraph.iterNodes())
@@ -57,11 +60,23 @@ export const processProcesses = async (knowledgeGraph, memberships, onProgress,
     const uniqueTraces = deduplicateTraces(allTraces);
     // Step 3b: Deduplicate by entry+terminal pair (keep longest path per pair)
     const endpointDeduped = deduplicateByEndpoints(uniqueTraces);
-    onProgress?.(`Deduped ${uniqueTraces.length} → ${endpointDeduped.length} unique endpoint pairs`, 70);
+    const syntheticRootBounded = capSyntheticRuntimeRootTraces(endpointDeduped);
+    onProgress?.(`Deduped ${uniqueTraces.length} → ${syntheticRootBounded.length} unique endpoint pairs`, 70);
     // Step 4: Limit to max processes (prioritize longer traces)
-    const limitedTraces = endpointDeduped
-        .sort((a, b) => b.length - a.length)
-        .slice(0, cfg.maxProcesses);
+    const sortedTraces = syntheticRootBounded.sort((a, b) => {
+        const runtimeScore = scoreSyntheticRuntimeTrace(b) - scoreSyntheticRuntimeTrace(a);
+        if (runtimeScore !== 0)
+            return runtimeScore;
+        return b.length - a.length;
+    });
+    const prioritizedRuntimeTraces = sortedTraces
+        .filter(isSyntheticRuntimeRootTrace)
+        .slice(0, SYNTHETIC_RUNTIME_ROOT_TRACE_LIMIT);
+    const prioritizedRuntimeKeys = new Set(prioritizedRuntimeTraces.map((trace) => trace.join('->')));
+    const limitedTraces = [
+        ...prioritizedRuntimeTraces,
+        ...sortedTraces.filter((trace) => !prioritizedRuntimeKeys.has(trace.join('->'))),
+    ].slice(0, cfg.maxProcesses);
     onProgress?.(`Creating ${limitedTraces.length} process nodes...`, 80);
     // Step 5: Create process nodes
     const processes = [];
@@ -69,6 +84,7 @@ export const processProcesses = async (knowledgeGraph, memberships, onProgress,
     limitedTraces.forEach((trace, idx) => {
         const entryPointId = trace[0];
         const terminalId = trace[trace.length - 1];
+        const traceEvidence = collectTraceEvidence(trace, callsEvidenceMap);
         // Get communities touched
         const communitiesSet = new Set();
         trace.forEach(nodeId => {
@@ -79,6 +95,14 @@ export const processProcesses = async (knowledgeGraph, memberships, onProgress,
         const communities = Array.from(communitiesSet);
         // Determine process type
         const processType = communities.length > 1 ? 'cross_community' : 'intra_community';
+        const processSubtype = isSyntheticRuntimeRootTrace(trace) ? 'unity_lifecycle' : 'static_calls';
+        const sourceReasons = Array.from(new Set(traceEvidence
+            .map((edge) => edge.reason?.trim())
+            .filter((reason) => Boolean(reason) && !/TODO|TBD|placeholder/i.test(reason))));
+        const sourceConfidences = Array.from(new Set(traceEvidence
+            .map((edge) => edge.confidence)
+            .filter((confidence) => Number.isFinite(confidence))));
+        const runtimeChainConfidence = sourceReasons.some(isSyntheticLifecycleReason) ? 'medium' : 'high';
         // Generate label
         const entryNode = nodeMap.get(entryPointId);
         const terminalNode = nodeMap.get(terminalId);
@@ -91,6 +115,10 @@ export const processProcesses = async (knowledgeGraph, memberships, onProgress,
             label: heuristicLabel,
             heuristicLabel,
             processType,
+            processSubtype,
+            runtimeChainConfidence,
+            sourceReasons,
+            sourceConfidences,
             stepCount: trace.length,
             communities,
             entryPointId,
@@ -99,10 +127,13 @@ export const processProcesses = async (knowledgeGraph, memberships, onProgress,
         });
         // Create step relationships
         trace.forEach((nodeId, stepIdx) => {
+            const edgeEvidence = resolveStepEvidence(trace, stepIdx, callsEvidenceMap);
             steps.push({
                 nodeId,
                 processId,
                 step: stepIdx + 1, // 1-indexed
+                reason: edgeEvidence?.reason,
+                confidence: edgeEvidence?.confidence,
             });
         });
     });
@@ -153,6 +184,45 @@ const buildReverseCallsGraph = (graph) => {
     }
     return adj;
 };
+const buildCallsEvidenceMap = (graph) => {
+    const evidenceMap = new Map();
+    for (const rel of graph.iterRelationships()) {
+        if (rel.type !== 'CALLS' || rel.confidence < MIN_TRACE_CONFIDENCE)
+            continue;
+        const key = `${rel.sourceId}->${rel.targetId}`;
+        const existing = evidenceMap.get(key);
+        if (!existing || rel.confidence >= existing.confidence) {
+            evidenceMap.set(key, {
+                reason: rel.reason,
+                confidence: rel.confidence,
+            });
+        }
+    }
+    return evidenceMap;
+};
+const collectTraceEvidence = (trace, callsEvidenceMap) => {
+    const evidence = [];
+    for (let i = 0; i < trace.length - 1; i++) {
+        const edge = callsEvidenceMap.get(`${trace[i]}->${trace[i + 1]}`);
+        if (edge)
+            evidence.push(edge);
+    }
+    return evidence;
+};
+const resolveStepEvidence = (trace, stepIdx, callsEvidenceMap) => {
+    const current = trace[stepIdx];
+    const next = trace[stepIdx + 1];
+    if (next) {
+        const outgoing = callsEvidenceMap.get(`${current}->${next}`);
+        if (outgoing)
+            return outgoing;
+    }
+    const prev = trace[stepIdx - 1];
+    if (!prev)
+        return undefined;
+    return callsEvidenceMap.get(`${prev}->${current}`);
+};
+const isSyntheticLifecycleReason = (reason) => reason.includes('unity-lifecycle-synthetic') || reason.includes('unity-runtime-loader-synthetic');
 /**
  * Find functions/methods that are good entry points for tracing.
  *
@@ -178,6 +248,14 @@ const findEntryPoints = (graph, reverseCallsEdges, callsEdges) => {
         // Must have at least 1 outgoing call to trace forward
         if (callees.length === 0)
             continue;
+        if (node.id.includes(SYNTHETIC_RUNTIME_ROOT_MARKER) || String(node.properties.name || '').includes(SYNTHETIC_RUNTIME_ROOT_MARKER)) {
+            entryPointCandidates.push({
+                id: node.id,
+                score: 10_000 + callees.length,
+                reasons: ['synthetic-runtime-root'],
+            });
+            continue;
+        }
         // Calculate entry point score using new scoring system
         const { score: baseScore, reasons } = calculateEntryPointScore(node.properties.name, node.properties.language ?? SupportedLanguages.JavaScript, node.properties.isExported ?? false, callers.length, callees.length, filePath // Pass filePath for framework detection
         );
@@ -217,10 +295,12 @@ const findEntryPoints = (graph, reverseCallsEdges, callsEdges) => {
  */
 const traceFromEntryPoint = (entryId, callsEdges, config) => {
     const traces = [];
+    const isRuntimeRootEntry = entryId.includes(SYNTHETIC_RUNTIME_ROOT_MARKER);
+    const maxTraceCount = isRuntimeRootEntry ? SYNTHETIC_RUNTIME_ROOT_TRACE_LIMIT * 6 : config.maxBranching * 3;
     // BFS with path tracking
     // Each queue item: [currentNodeId, pathSoFar]
     const queue = [[entryId, [entryId]]];
-    while (queue.length > 0 && traces.length < config.maxBranching * 3) {
+    while (queue.length > 0 && traces.length < maxTraceCount) {
         const [currentId, path] = queue.shift();
         // Get outgoing calls
         const callees = callsEdges.get(currentId) || [];
@@ -238,7 +318,13 @@ const traceFromEntryPoint = (entryId, callsEdges, config) => {
         }
         else {
             // Continue tracing - limit branching
-            const limitedCallees = callees.slice(0, config.maxBranching);
+            const branchingLimit = path.length === 1 && currentId.includes(SYNTHETIC_RUNTIME_ROOT_MARKER)
+                ? Math.min(callees.length, Math.max(config.maxBranching * 8, SYNTHETIC_RUNTIME_ROOT_TRACE_LIMIT * 4))
+                : config.maxBranching;
+            const orderedCallees = isRuntimeRootEntry
+                ? [...callees].sort((left, right) => scoreRuntimeTraceTarget(right) - scoreRuntimeTraceTarget(left))
+                : callees;
+            const limitedCallees = orderedCallees.slice(0, branchingLimit);
             let addedBranch = false;
             for (const calleeId of limitedCallees) {
                 // Avoid cycles
@@ -295,13 +381,108 @@ const deduplicateByEndpoints = (traces) => {
     // Sort longest first so the first seen per key is the longest
     const sorted = [...traces].sort((a, b) => b.length - a.length);
     for (const trace of sorted) {
-        const key = `${trace[0]}::${trace[trace.length - 1]}`;
+        const key = isSyntheticRuntimeRootTrace(trace)
+            ? `${trace[0]}::${trace[1] ?? ''}::${trace[trace.length - 1]}`
+            : `${trace[0]}::${trace[trace.length - 1]}`;
         if (!byEndpoints.has(key)) {
             byEndpoints.set(key, trace);
         }
     }
     return Array.from(byEndpoints.values());
 };
+/**
+ * Keep synthetic runtime-root traces useful but bounded.
+ * Preserve a small set of distinct lifecycle/runtime traces instead of collapsing to one.
+ */
+const capSyntheticRuntimeRootTraces = (traces) => {
+    if (traces.length === 0)
+        return [];
+    const runtimeRootTraces = traces
+        .filter(isSyntheticRuntimeRootTrace)
+        .sort((a, b) => scoreSyntheticRuntimeTrace(b) - scoreSyntheticRuntimeTrace(a));
+    if (runtimeRootTraces.length <= SYNTHETIC_RUNTIME_ROOT_TRACE_LIMIT)
+        return traces;
+    const keep = runtimeRootTraces.slice(0, SYNTHETIC_RUNTIME_ROOT_TRACE_LIMIT);
+    const filtered = traces.filter((trace) => !isSyntheticRuntimeRootTrace(trace));
+    filtered.push(...keep);
+    return filtered;
+};
+const isSyntheticRuntimeRootTrace = (trace) => Boolean(trace[0]?.includes(SYNTHETIC_RUNTIME_ROOT_MARKER));
+const scoreSyntheticRuntimeTrace = (trace) => {
+    let score = trace.length * 100;
+    const joined = trace.join(' ');
+    if (joined.includes('RegisterGraphEvents'))
+        score += 80;
+    if (joined.includes('RegisterEvents'))
+        score += 60;
+    if (joined.includes('StartRoutineWithEvents'))
+        score += 60;
+    if (joined.includes('GetValue'))
+        score += 70;
+    if (joined.includes('CheckReload'))
+        score += 60;
+    if (joined.includes('ReloadRoutine'))
+        score += 60;
+    if (joined.includes('EquipWithEvent'))
+        score += 40;
+    if (joined.includes('Equip'))
+        score += 30;
+    return score;
+};
+const scoreRuntimeRootTarget = (nodeId) => {
+    let score = 0;
+    const text = String(nodeId || '');
+    if (text.includes('GunGraphMB'))
+        score += 200;
+    if (text.includes('MeleeGraphMB'))
+        score += 120;
+    if (text.includes('/Reload'))
+        score += 180;
+    if (text.includes('/Graph/'))
+        score += 100;
+    if (text.includes('/PowerUps/'))
+        score += 70;
+    if (text.includes('/Core/'))
+        score += 40;
+    if (text.includes(':OnEnable'))
+        score += 30;
+    if (text.includes(':Awake'))
+        score += 20;
+    if (text.includes(':Start'))
+        score += 10;
+    return score;
+};
+const scoreRuntimeTraceTarget = (nodeId) => {
+    const text = String(nodeId || '');
+    let score = scoreRuntimeRootTarget(text);
+    if (text.includes('RegisterGraphEvents'))
+        score += 220;
+    if (text.includes('RegisterEvents'))
+        score += 180;
+    if (text.includes('StartRoutineWithEvents'))
+        score += 260;
+    if (text.includes('GetValue'))
+        score += 200;
+    if (text.includes('CheckReload'))
+        score += 180;
+    if (text.includes('ReloadRoutine'))
+        score += 170;
+    if (text.includes('AttackRoutineWithEvents'))
+        score -= 80;
+    if (text.includes('IGraphEvent.cs:Register'))
+        score -= 140;
+    if (text.includes('WaitForHelper.cs:EndOfFrame'))
+        score -= 160;
+    if (text.includes('/Graph/Graphs/GunGraph.cs'))
+        score += 120;
+    if (text.includes('/Graph/Nodes/Reloads/ReloadBase.cs'))
+        score += 220;
+    if (text.includes('/Graph/Nodes/Reloads/Reload.cs'))
+        score += 180;
+    if (text.includes('/Graph/Nodes/Reloads/'))
+        score += 120;
+    return score;
+};
 // ============================================================================
 // HELPER: String utilities
 // ============================================================================

package/dist/core/ingestion/unity-lifecycle-config.d.ts

@@ -0,0 +1,5 @@
+import { type UnityLifecycleSyntheticConfig } from './unity-lifecycle-synthetic-calls.js';
+export interface UnityLifecycleConfig extends UnityLifecycleSyntheticConfig {
+    persistLifecycleProcessMetadata: boolean;
+}
+export declare const resolveUnityLifecycleConfig: (env: NodeJS.ProcessEnv) => UnityLifecycleConfig;

package/dist/core/ingestion/unity-lifecycle-config.js

@@ -0,0 +1,25 @@
+import { DEFAULT_UNITY_LIFECYCLE_SYNTHETIC_CONFIG, } from './unity-lifecycle-synthetic-calls.js';
+const TRUE_VALUES = new Set(['1', 'true', 'on', 'yes']);
+const parsePositiveInt = (raw, fallback) => {
+    const value = Number.parseInt(String(raw || '').trim(), 10);
+    if (!Number.isFinite(value) || value <= 0)
+        return fallback;
+    return value;
+};
+const parseBool = (raw) => {
+    const normalized = String(raw || '').trim().toLowerCase();
+    return TRUE_VALUES.has(normalized);
+};
+export const resolveUnityLifecycleConfig = (env) => {
+    const enabled = parseBool(env.GITNEXUS_UNITY_LIFECYCLE_SYNTHETIC_CALLS);
+    const persistLifecycleProcessMetadata = parseBool(env.GITNEXUS_UNITY_LIFECYCLE_PROCESS_PERSIST);
+    const maxSyntheticEdgesPerClass = parsePositiveInt(env.GITNEXUS_UNITY_LIFECYCLE_SYNTHETIC_MAX_PER_CLASS, DEFAULT_UNITY_LIFECYCLE_SYNTHETIC_CONFIG.maxSyntheticEdgesPerClass);
+    const maxSyntheticEdgesTotal = parsePositiveInt(env.GITNEXUS_UNITY_LIFECYCLE_SYNTHETIC_MAX_TOTAL, DEFAULT_UNITY_LIFECYCLE_SYNTHETIC_CONFIG.maxSyntheticEdgesTotal);
+    return {
+        ...DEFAULT_UNITY_LIFECYCLE_SYNTHETIC_CONFIG,
+        enabled,
+        persistLifecycleProcessMetadata,
+        maxSyntheticEdgesPerClass,
+        maxSyntheticEdgesTotal,
+    };
+};

package/dist/core/ingestion/unity-lifecycle-synthetic-calls.d.ts

@@ -0,0 +1,26 @@
+import type { GraphNode, KnowledgeGraph } from '../graph/types.js';
+export interface UnityLifecycleSyntheticConfig {
+    enabled: boolean;
+    maxSyntheticEdgesPerClass: number;
+    maxSyntheticEdgesTotal: number;
+    lifecycleEdgeConfidence: number;
+    loaderEdgeConfidence: number;
+}
+export declare const DEFAULT_UNITY_LIFECYCLE_SYNTHETIC_CONFIG: UnityLifecycleSyntheticConfig;
+export interface UnityLifecycleHost {
+    classNode: GraphNode;
+    baseType: 'MonoBehaviour' | 'ScriptableObject';
+    lifecycleCallbacks: GraphNode[];
+    loaderAnchors: GraphNode[];
+    methods: GraphNode[];
+}
+export interface UnityLifecycleSyntheticResult {
+    syntheticEdgeCount: number;
+    lifecycleEdgeCount: number;
+    loaderEdgeCount: number;
+    hostCount: number;
+    rejectedHostCount: number;
+    runtimeRootNodeId?: string;
+}
+export declare const detectUnityLifecycleHosts: (graph: KnowledgeGraph) => UnityLifecycleHost[];
+export declare const applyUnityLifecycleSyntheticCalls: (graph: KnowledgeGraph, config?: Partial<UnityLifecycleSyntheticConfig>) => UnityLifecycleSyntheticResult;