@veewo/gitnexus 1.3.8 → 1.3.9

package/dist/cli/analyze-summary.js

@@ -0,0 +1,37 @@
+export function formatUnityDiagnosticsSummary(diagnostics, previewLimit = 3) {
+    if (!diagnostics || diagnostics.length === 0) {
+        return [];
+    }
+    const limit = previewLimit > 0 ? previewLimit : diagnostics.length;
+    const preview = diagnostics.slice(0, limit);
+    const lines = [`Unity Diagnostics: ${diagnostics.length} message(s)`];
+    for (const message of preview) {
+        lines.push(`- ${message}`);
+    }
+    if (diagnostics.length > preview.length) {
+        lines.push(`... ${diagnostics.length - preview.length} more`);
+    }
+    return lines;
+}
+export function formatFallbackSummary(warnings, stats, previewLimit = 5) {
+    if (!warnings || warnings.length === 0) {
+        return [];
+    }
+    const safeStats = stats ?? {
+        attempted: 0,
+        succeeded: 0,
+        failed: 0,
+    };
+    const limit = previewLimit > 0 ? previewLimit : warnings.length;
+    const preview = warnings.slice(0, limit);
+    const lines = [
+        `Fallback edges: attempted=${safeStats.attempted}, succeeded=${safeStats.succeeded}, failed=${safeStats.failed}, pairTypes=${warnings.length}`,
+    ];
+    for (const warning of preview) {
+        lines.push(`- ${warning}`);
+    }
+    if (warnings.length > preview.length) {
+        lines.push(`... ${warnings.length - preview.length} more`);
+    }
+    return lines;
+}

package/dist/cli/analyze-summary.test.d.ts

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

package/dist/cli/analyze-summary.test.js

@@ -0,0 +1,58 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { formatFallbackSummary, formatUnityDiagnosticsSummary } from './analyze-summary.js';
+test('formatUnityDiagnosticsSummary returns empty when diagnostics are missing', () => {
+    const lines = formatUnityDiagnosticsSummary([]);
+    assert.deepEqual(lines, []);
+});
+test('formatUnityDiagnosticsSummary renders diagnostics with count and bullets', () => {
+    const lines = formatUnityDiagnosticsSummary([
+        'scanContext: scripts=4, guids=4, resources=0',
+    ]);
+    assert.deepEqual(lines, [
+        'Unity Diagnostics: 1 message(s)',
+        '- scanContext: scripts=4, guids=4, resources=0',
+    ]);
+});
+test('formatUnityDiagnosticsSummary truncates output after max preview items', () => {
+    const lines = formatUnityDiagnosticsSummary([
+        'diag-a',
+        'diag-b',
+        'diag-c',
+        'diag-d',
+    ]);
+    assert.deepEqual(lines, [
+        'Unity Diagnostics: 4 message(s)',
+        '- diag-a',
+        '- diag-b',
+        '- diag-c',
+        '... 1 more',
+    ]);
+});
+test('formatFallbackSummary returns empty when no warnings exist', () => {
+    const lines = formatFallbackSummary([], {
+        attempted: 0,
+        succeeded: 0,
+        failed: 0,
+    });
+    assert.deepEqual(lines, []);
+});
+test('formatFallbackSummary renders attempted/succeeded/failed with warning preview', () => {
+    const lines = formatFallbackSummary([
+        'Method->Delegate (1233 edges): missing rel pair in schema',
+        'Class->Property (200 edges): missing rel pair in schema',
+        'Constructor->Property (97 edges): missing rel pair in schema',
+        'Function->Property (17 edges): missing rel pair in schema',
+    ], {
+        attempted: 1547,
+        succeeded: 0,
+        failed: 1547,
+    }, 3);
+    assert.deepEqual(lines, [
+        'Fallback edges: attempted=1547, succeeded=0, failed=1547, pairTypes=4',
+        '- Method->Delegate (1233 edges): missing rel pair in schema',
+        '- Class->Property (200 edges): missing rel pair in schema',
+        '- Constructor->Property (97 edges): missing rel pair in schema',
+        '... 1 more',
+    ]);
+});

package/dist/cli/analyze.js

@@ -19,6 +19,7 @@ import { generateAIContextFiles } from './ai-context.js';
 import fs from 'fs/promises';
 import { registerClaudeHook } from './claude-hooks.js';
 import { normalizeRepoAlias, parseExtensionList, resolveAnalyzeScopeRules } from './analyze-options.js';
+import { formatFallbackSummary, formatUnityDiagnosticsSummary } from './analyze-summary.js';
 const HEAP_MB = 8192;
 const HEAP_FLAG = `--max-old-space-size=${HEAP_MB}`;
 /** Re-exec the process with an 8GB heap if we're currently below that. */
@@ -350,6 +351,10 @@ export const analyzeCommand = async (inputPath, options) => {
             }
         }
     }
+    const unitySummaryLines = formatUnityDiagnosticsSummary(pipelineResult.unityResult?.diagnostics);
+    for (const line of unitySummaryLines) {
+        console.log(`  ${line}`);
+    }
     console.log(`  ${stats.nodes.toLocaleString()} nodes | ${stats.edges.toLocaleString()} edges | ${pipelineResult.communityResult?.stats.totalCommunities || 0} clusters | ${pipelineResult.processResult?.stats.totalProcesses || 0} flows`);
     console.log(`  KuzuDB ${kuzuTime}s | FTS ${ftsTime}s | Embeddings ${embeddingSkipped ? embeddingSkipReason : embeddingTime + 's'}`);
     if (includeExtensions.length > 0) {
@@ -362,13 +367,13 @@ export const analyzeCommand = async (inputPath, options) => {
     if (hookResult.registered) {
         console.log(`  Hooks: ${hookResult.message}`);
     }
-    // Show a quiet summary if some edge types needed fallback insertion
+    // Show fallback summary with pair-level preview and explicit outcomes
     if (kuzuWarnings.length > 0) {
-        const totalFallback = kuzuWarnings.reduce((sum, w) => {
-            const m = w.match(/\((\d+) edges\)/);
-            return sum + (m ? parseInt(m[1]) : 0);
-        }, 0);
-        console.log(`  Note: ${totalFallback} edges across ${kuzuWarnings.length} types inserted via fallback (schema will be updated in next release)`);
+        const fallbackLines = formatFallbackSummary(kuzuWarnings, kuzuResult.fallbackStats);
+        for (const line of fallbackLines) {
+            console.log(`  ${line}`);
+        }
+        console.log('  Note: schema pair coverage should be updated when fallback failures are non-zero');
     }
     try {
         await fs.access(getGlobalRegistryPath());

package/dist/cli/benchmark-u2-e2e.d.ts

@@ -0,0 +1,9 @@
+export interface U2E2EArgs {
+    configPath: string;
+    reportDir?: string;
+}
+export declare function resolveU2E2EArgs(argv: string[]): U2E2EArgs;
+export declare function benchmarkU2E2ECommand(options: {
+    config?: string;
+    reportDir?: string;
+}): Promise<import("../benchmark/u2-e2e/neonspark-full-e2e.js").E2ERunFailure | import("../benchmark/u2-e2e/neonspark-full-e2e.js").E2ERunSuccess>;

package/dist/cli/benchmark-u2-e2e.js

@@ -0,0 +1,35 @@
+import path from 'node:path';
+import { runNeonsparkU2E2E } from '../benchmark/u2-e2e/neonspark-full-e2e.js';
+export function resolveU2E2EArgs(argv) {
+    const findValue = (name) => {
+        const index = argv.indexOf(name);
+        if (index === -1 || index + 1 >= argv.length)
+            return undefined;
+        return argv[index + 1];
+    };
+    const config = findValue('--config') || '../benchmarks/u2-e2e/neonspark-full-u2-e2e.config.json';
+    const reportDir = findValue('--report-dir');
+    return {
+        configPath: path.resolve(config),
+        ...(reportDir ? { reportDir: path.resolve(reportDir) } : {}),
+    };
+}
+export async function benchmarkU2E2ECommand(options) {
+    const result = await runNeonsparkU2E2E({
+        configPath: path.resolve(options.config || '../benchmarks/u2-e2e/neonspark-full-u2-e2e.config.json'),
+        reportDir: options.reportDir ? path.resolve(options.reportDir) : undefined,
+    });
+    if (result.status === 'failed') {
+        process.stderr.write(`FAIL\n`);
+        process.stderr.write(`Run ID: ${result.runId}\n`);
+        process.stderr.write(`Failed Gate: ${result.failedGate}\n`);
+        process.stderr.write(`Report: ${result.reportDir}\n`);
+        process.stderr.write(`Error: ${result.error}\n`);
+        process.exitCode = 1;
+        return result;
+    }
+    process.stderr.write('PASS\n');
+    process.stderr.write(`Run ID: ${result.runId}\n`);
+    process.stderr.write(`Report: ${result.reportDir}\n`);
+    return result;
+}

package/dist/cli/benchmark-u2-e2e.test.d.ts

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

package/dist/cli/benchmark-u2-e2e.test.js

@@ -0,0 +1,7 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { resolveU2E2EArgs } from './benchmark-u2-e2e.js';
+test('benchmark-u2-e2e resolves config and report directory', () => {
+    const out = resolveU2E2EArgs(['--config', 'benchmarks/u2-e2e/neonspark-full-u2-e2e.config.json']);
+    assert.match(out.configPath, /neonspark-full-u2-e2e\.config\.json$/);
+});

package/dist/cli/index.js

@@ -36,6 +36,8 @@ import { queryCommand, contextCommand, impactCommand, cypherCommand } from './to
 import { evalServerCommand } from './eval-server.js';
 import { benchmarkUnityCommand } from './benchmark-unity.js';
 import { benchmarkAgentContextCommand } from './benchmark-agent-context.js';
+import { unityBindingsCommand } from './unity-bindings.js';
+import { benchmarkU2E2ECommand } from './benchmark-u2-e2e.js';
 function resolveCliVersion() {
     try {
         const currentFile = fileURLToPath(import.meta.url);
@@ -121,6 +123,7 @@ program
     .option('-g, --goal <text>', 'What you want to find')
     .option('-l, --limit <n>', 'Max processes to return (default: 5)')
     .option('--content', 'Include full symbol source code')
+    .option('--unity-resources <mode>', 'Unity resource retrieval mode: off|on|auto', 'off')
     .action(queryCommand);
 program
     .command('context [name]')
@@ -129,7 +132,16 @@ program
     .option('-u, --uid <uid>', 'Direct symbol UID (zero-ambiguity lookup)')
     .option('-f, --file <path>', 'File path to disambiguate common names')
     .option('--content', 'Include full symbol source code')
+    .option('--unity-resources <mode>', 'Unity resource retrieval mode: off|on|auto', 'off')
     .action(contextCommand);
+program
+    .command('unity-bindings <symbol>')
+    .description('Experimental: inspect Unity resource bindings for a C# symbol')
+    .option('--target-path <path>', 'Unity project root (default: cwd)')
+    .option('--json', 'Output JSON')
+    .action(async (symbol, options) => {
+    await unityBindingsCommand(symbol, options);
+});
 program
     .command('impact <target>')
     .description('Blast radius analysis: what breaks if you change a symbol')
@@ -181,4 +193,12 @@ program
     .action(async (dataset, options) => {
     await benchmarkAgentContextCommand(dataset, options);
 });
+program
+    .command('benchmark-u2-e2e')
+    .description('Run fail-fast full neonspark U2 E2E benchmark and emit evidence reports')
+    .option('--config <path>', 'Path to E2E config JSON')
+    .option('--report-dir <path>', 'Output directory for reports')
+    .action(async (options) => {
+    await benchmarkU2E2ECommand(options);
+});
 program.parse(process.argv);

package/dist/cli/tool.d.ts

@@ -13,18 +13,21 @@
  * Note: Output goes to stderr because KuzuDB's native module captures stdout
  * at the OS level during init. This is consistent with augment.ts.
  */
+import type { UnityResourcesMode } from '../core/unity/options.js';
 export declare function queryCommand(queryText: string, options?: {
     repo?: string;
     context?: string;
     goal?: string;
     limit?: string;
     content?: boolean;
+    unityResources?: UnityResourcesMode;
 }): Promise<void>;
 export declare function contextCommand(name: string, options?: {
     repo?: string;
     file?: string;
     uid?: string;
     content?: boolean;
+    unityResources?: UnityResourcesMode;
 }): Promise<void>;
 export declare function impactCommand(target: string, options?: {
     direction?: string;

package/dist/cli/tool.js

@@ -43,6 +43,7 @@ export async function queryCommand(queryText, options) {
         goal: options?.goal,
         limit: options?.limit ? parseInt(options.limit) : undefined,
         include_content: options?.content ?? false,
+        unity_resources: options?.unityResources,
         repo: options?.repo,
     });
     output(result);
@@ -58,6 +59,7 @@ export async function contextCommand(name, options) {
         uid: options?.uid,
         file_path: options?.file,
         include_content: options?.content ?? false,
+        unity_resources: options?.unityResources,
         repo: options?.repo,
     });
     output(result);

package/dist/cli/unity-bindings.d.ts

@@ -0,0 +1,8 @@
+import { resolveUnityBindings } from '../core/unity/resolver.js';
+export declare function unityBindingsCommand(symbol: string, options: {
+    targetPath?: string;
+    json?: boolean;
+}, deps?: {
+    resolver?: typeof resolveUnityBindings;
+    writeLine?: (line: string) => void;
+}): Promise<void>;

package/dist/cli/unity-bindings.js

@@ -0,0 +1,33 @@
+import path from 'node:path';
+import { resolveUnityBindings } from '../core/unity/resolver.js';
+export async function unityBindingsCommand(symbol, options, deps) {
+    const resolver = deps?.resolver || resolveUnityBindings;
+    const writeLine = deps?.writeLine || ((line) => process.stderr.write(`${line}\n`));
+    const repoRoot = path.resolve(options.targetPath || process.cwd());
+    const result = await resolver({ repoRoot, symbol });
+    if (options.json) {
+        writeLine(JSON.stringify(result, null, 2));
+        return;
+    }
+    writeLine(`Unity bindings for ${result.symbol}`);
+    writeLine(`Script: ${result.scriptPath}`);
+    writeLine(`GUID: ${result.scriptGuid}`);
+    writeLine(`Resource bindings: ${result.resourceBindings.length}`);
+    for (const binding of result.resourceBindings) {
+        writeLine(`- ${binding.resourceType} ${binding.resourcePath} [${binding.bindingKind}] component=${binding.componentObjectId}`);
+    }
+    writeLine(`Scalar fields: ${result.serializedFields.scalarFields.length}`);
+    for (const field of result.serializedFields.scalarFields) {
+        writeLine(`- ${field.name} = ${field.value} (${field.sourceLayer})`);
+    }
+    writeLine(`Reference fields: ${result.serializedFields.referenceFields.length}`);
+    for (const field of result.serializedFields.referenceFields) {
+        writeLine(`- ${field.name} -> ${field.guid || field.fileId || 'unresolved'} (${field.sourceLayer})`);
+    }
+    if (result.unityDiagnostics.length > 0) {
+        writeLine(`Diagnostics: ${result.unityDiagnostics.length}`);
+        for (const diagnostic of result.unityDiagnostics) {
+            writeLine(`- ${diagnostic}`);
+        }
+    }
+}

package/dist/cli/unity-bindings.test.d.ts

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

package/dist/cli/unity-bindings.test.js

@@ -0,0 +1,24 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { unityBindingsCommand } from './unity-bindings.js';
+const here = path.dirname(fileURLToPath(import.meta.url));
+const fixtureRoot = path.resolve(here, '../../src/core/unity/__fixtures__/mini-unity');
+test('prints human readable summary by default', async () => {
+    const lines = [];
+    await unityBindingsCommand('MainUIManager', { targetPath: fixtureRoot }, { writeLine: (line) => lines.push(line) });
+    const output = lines.join('\n');
+    assert.match(output, /resource bindings/i);
+    assert.match(output, /MainUIManager/);
+    assert.match(output, /needPause/);
+});
+test('prints JSON when --json is enabled', async () => {
+    const lines = [];
+    await unityBindingsCommand('MainUIManager', { targetPath: fixtureRoot, json: true }, { writeLine: (line) => lines.push(line) });
+    const payload = JSON.parse(lines.join('\n'));
+    assert.equal(payload.symbol, 'MainUIManager');
+    assert.ok(Array.isArray(payload.resourceBindings));
+    assert.ok(Array.isArray(payload.serializedFields.scalarFields));
+    assert.ok(Array.isArray(payload.serializedFields.referenceFields));
+});

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>;