@veewo/gitnexus 1.3.8 → 1.3.10

package/dist/cli/analyze-options.d.ts

@@ -2,6 +2,25 @@ export interface AnalyzeScopeOptions {
     scopeManifest?: string;
     scopePrefix?: string[] | string;
 }
+export interface StoredAnalyzeOptions {
+    includeExtensions?: string[];
+    scopeRules?: string[];
+    repoAlias?: string;
+    embeddings?: boolean;
+}
+export interface ResolveAnalyzeOptionsInput extends AnalyzeScopeOptions {
+    extensions?: string;
+    repoAlias?: string;
+    embeddings?: boolean;
+    reuseOptions?: boolean;
+}
+export interface EffectiveAnalyzeOptions {
+    includeExtensions: string[];
+    scopeRules: string[];
+    repoAlias?: string;
+    embeddings: boolean;
+}
 export declare function parseExtensionList(rawExtensions?: string): string[];
 export declare function normalizeRepoAlias(repoAlias?: string): string | undefined;
 export declare function resolveAnalyzeScopeRules(options?: AnalyzeScopeOptions): Promise<string[]>;
+export declare function resolveEffectiveAnalyzeOptions(options?: ResolveAnalyzeOptionsInput, stored?: StoredAnalyzeOptions): Promise<EffectiveAnalyzeOptions>;

package/dist/cli/analyze-options.js

@@ -54,3 +54,38 @@ export async function resolveAnalyzeScopeRules(options) {
     }
     return normalizedRules;
 }
+function parseScopePrefixCount(scopePrefix) {
+    if (Array.isArray(scopePrefix))
+        return scopePrefix.length;
+    if (typeof scopePrefix === 'string')
+        return scopePrefix.trim() ? 1 : 0;
+    return 0;
+}
+export async function resolveEffectiveAnalyzeOptions(options, stored) {
+    const includeExtensionsFromCli = parseExtensionList(options?.extensions);
+    const scopeRulesFromCli = await resolveAnalyzeScopeRules({
+        scopeManifest: options?.scopeManifest,
+        scopePrefix: options?.scopePrefix,
+    });
+    const repoAliasFromCli = normalizeRepoAlias(options?.repoAlias);
+    const hasCliExtensions = options?.extensions !== undefined;
+    const hasCliScope = Boolean(options?.scopeManifest) || parseScopePrefixCount(options?.scopePrefix) > 0;
+    const hasCliRepoAlias = options?.repoAlias !== undefined;
+    const canReuse = options?.reuseOptions !== false;
+    const includeExtensions = hasCliExtensions
+        ? includeExtensionsFromCli
+        : (canReuse ? (stored?.includeExtensions || []) : []);
+    const scopeRules = hasCliScope
+        ? scopeRulesFromCli
+        : (canReuse ? (stored?.scopeRules || []) : []);
+    const repoAlias = hasCliRepoAlias
+        ? repoAliasFromCli
+        : (canReuse ? normalizeRepoAlias(stored?.repoAlias) : undefined);
+    const embeddings = options?.embeddings ?? (canReuse ? Boolean(stored?.embeddings) : false);
+    return {
+        includeExtensions: [...includeExtensions],
+        scopeRules: [...scopeRules],
+        repoAlias,
+        embeddings,
+    };
+}

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

@@ -3,7 +3,7 @@ import assert from 'node:assert/strict';
 import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
-import { normalizeRepoAlias, parseExtensionList, resolveAnalyzeScopeRules } from './analyze-options.js';
+import { normalizeRepoAlias, parseExtensionList, resolveAnalyzeScopeRules, resolveEffectiveAnalyzeOptions, } from './analyze-options.js';
 test('parseExtensionList normalizes dot prefixes', () => {
     const exts = parseExtensionList('cs,.ts, go ');
     assert.deepEqual(exts, ['.cs', '.ts', '.go']);
@@ -34,3 +34,44 @@ test('resolveAnalyzeScopeRules fails when manifest has no usable rule', async ()
     await fs.writeFile(manifestPath, '# only comments\n\n', 'utf-8');
     await assert.rejects(resolveAnalyzeScopeRules({ scopeManifest: manifestPath }), /no valid scope rules/i);
 });
+test('resolveEffectiveAnalyzeOptions reuses stored settings when CLI omits them', async () => {
+    const resolved = await resolveEffectiveAnalyzeOptions({}, {
+        includeExtensions: ['.cs'],
+        scopeRules: ['Assets/NEON/Code'],
+        repoAlias: 'neonspark-v1-subset',
+        embeddings: true,
+    });
+    assert.deepEqual(resolved.includeExtensions, ['.cs']);
+    assert.deepEqual(resolved.scopeRules, ['Assets/NEON/Code']);
+    assert.equal(resolved.repoAlias, 'neonspark-v1-subset');
+    assert.equal(resolved.embeddings, true);
+});
+test('resolveEffectiveAnalyzeOptions disables reuse via reuseOptions=false', async () => {
+    const resolved = await resolveEffectiveAnalyzeOptions({ reuseOptions: false }, {
+        includeExtensions: ['.cs'],
+        scopeRules: ['Assets/NEON/Code'],
+        repoAlias: 'neonspark-v1-subset',
+        embeddings: true,
+    });
+    assert.deepEqual(resolved.includeExtensions, []);
+    assert.deepEqual(resolved.scopeRules, []);
+    assert.equal(resolved.repoAlias, undefined);
+    assert.equal(resolved.embeddings, false);
+});
+test('resolveEffectiveAnalyzeOptions prefers explicit CLI values over stored settings', async () => {
+    const resolved = await resolveEffectiveAnalyzeOptions({
+        extensions: '.ts',
+        scopePrefix: ['src'],
+        repoAlias: 'new-alias',
+        embeddings: false,
+    }, {
+        includeExtensions: ['.cs'],
+        scopeRules: ['Assets/NEON/Code'],
+        repoAlias: 'old-alias',
+        embeddings: true,
+    });
+    assert.deepEqual(resolved.includeExtensions, ['.ts']);
+    assert.deepEqual(resolved.scopeRules, ['src']);
+    assert.equal(resolved.repoAlias, 'new-alias');
+    assert.equal(resolved.embeddings, false);
+});

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

@@ -0,0 +1,7 @@
+export interface FallbackInsertStats {
+    attempted: number;
+    succeeded: number;
+    failed: number;
+}
+export declare function formatUnityDiagnosticsSummary(diagnostics: string[] | undefined, previewLimit?: number): string[];
+export declare function formatFallbackSummary(warnings: string[] | undefined, stats: FallbackInsertStats | undefined, previewLimit?: number): string[];

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.d.ts

@@ -10,5 +10,6 @@ export interface AnalyzeOptions {
     repoAlias?: string;
     scopeManifest?: string;
     scopePrefix?: string[];
+    reuseOptions?: boolean;
 }
 export declare const analyzeCommand: (inputPath?: string, options?: AnalyzeOptions) => Promise<void>;

package/dist/cli/analyze.js

@@ -18,7 +18,8 @@ import { getCurrentCommit, isGitRepo, getGitRoot } from '../storage/git.js';
 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 { resolveEffectiveAnalyzeOptions } 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. */
@@ -61,22 +62,6 @@ export const analyzeCommand = async (inputPath, options) => {
     if (ensureHeap())
         return;
     console.log('\n  GitNexus Analyzer\n');
-    let includeExtensions = [];
-    let scopeRules = [];
-    let repoAlias;
-    try {
-        includeExtensions = parseExtensionList(options?.extensions);
-        scopeRules = await resolveAnalyzeScopeRules({
-            scopeManifest: options?.scopeManifest,
-            scopePrefix: options?.scopePrefix,
-        });
-        repoAlias = normalizeRepoAlias(options?.repoAlias);
-    }
-    catch (error) {
-        console.log(`  ${error?.message || String(error)}\n`);
-        process.exitCode = 1;
-        return;
-    }
     let repoPath;
     if (inputPath) {
         repoPath = path.resolve(inputPath);
@@ -98,15 +83,52 @@ export const analyzeCommand = async (inputPath, options) => {
     const { storagePath, kuzuPath } = getStoragePaths(repoPath);
     const currentCommit = getCurrentCommit(repoPath);
     const existingMeta = await loadMeta(storagePath);
-    if (existingMeta &&
-        !options?.force &&
-        existingMeta.lastCommit === currentCommit &&
-        includeExtensions.length === 0 &&
-        scopeRules.length === 0 &&
-        !repoAlias) {
-        console.log('  Already up to date\n');
+    let includeExtensions = [];
+    let scopeRules = [];
+    let repoAlias;
+    let embeddingsEnabled = false;
+    try {
+        const effectiveOptions = await resolveEffectiveAnalyzeOptions({
+            extensions: options?.extensions,
+            scopeManifest: options?.scopeManifest,
+            scopePrefix: options?.scopePrefix,
+            repoAlias: options?.repoAlias,
+            embeddings: options?.embeddings,
+            reuseOptions: options?.reuseOptions,
+        }, existingMeta?.analyzeOptions);
+        includeExtensions = effectiveOptions.includeExtensions;
+        scopeRules = effectiveOptions.scopeRules;
+        repoAlias = effectiveOptions.repoAlias;
+        embeddingsEnabled = effectiveOptions.embeddings;
+    }
+    catch (error) {
+        console.log(`  ${error?.message || String(error)}\n`);
+        process.exitCode = 1;
         return;
     }
+    if (existingMeta && !options?.force && existingMeta.lastCommit === currentCommit) {
+        const hasScopePrefixInput = Array.isArray(options?.scopePrefix)
+            ? options.scopePrefix.length > 0
+            : Boolean(options?.scopePrefix);
+        const hasCliOverrides = options?.extensions !== undefined ||
+            Boolean(options?.scopeManifest) ||
+            hasScopePrefixInput ||
+            options?.repoAlias !== undefined ||
+            options?.embeddings !== undefined ||
+            options?.reuseOptions === false;
+        if (!hasCliOverrides) {
+            console.log('  Already up to date\n');
+            return;
+        }
+        if (options?.reuseOptions !== false &&
+            includeExtensions.length === 0 &&
+            scopeRules.length === 0 &&
+            !repoAlias &&
+            !embeddingsEnabled) {
+            console.log('  Already up to date\n');
+            return;
+        }
+    }
     // Single progress bar for entire pipeline
     const bar = new cliProgress.SingleBar({
         format: '  {bar} {percentage}% | {phase}',
@@ -170,7 +192,7 @@ export const analyzeCommand = async (inputPath, options) => {
     // ── Cache embeddings from existing index before rebuild ────────────
     let cachedEmbeddingNodeIds = new Set();
     let cachedEmbeddings = [];
-    if (options?.embeddings && existingMeta && !options?.force) {
+    if (embeddingsEnabled && existingMeta && !options?.force) {
         try {
             updateBar(0, 'Caching embeddings...');
             await initKuzu(kuzuPath);
@@ -258,7 +280,7 @@ export const analyzeCommand = async (inputPath, options) => {
     let embeddingTime = '0.0';
     let embeddingSkipped = true;
     let embeddingSkipReason = 'off (use --embeddings to enable)';
-    if (options?.embeddings) {
+    if (embeddingsEnabled) {
         if (stats.nodes > EMBEDDING_NODE_LIMIT) {
             embeddingSkipReason = `skipped (${stats.nodes.toLocaleString()} nodes > ${EMBEDDING_NODE_LIMIT.toLocaleString()} limit)`;
         }
@@ -283,6 +305,12 @@ export const analyzeCommand = async (inputPath, options) => {
         repoPath,
         lastCommit: currentCommit,
         indexedAt: new Date().toISOString(),
+        analyzeOptions: {
+            includeExtensions,
+            scopeRules,
+            repoAlias,
+            embeddings: embeddingsEnabled,
+        },
         stats: {
             files: pipelineResult.totalFileCount,
             nodes: stats.nodes,
@@ -350,6 +378,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 +394,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);
@@ -67,6 +69,7 @@ program
     .command('analyze [path]')
     .description('Index a repository (full analysis)')
     .option('-f, --force', 'Force full re-index even if up to date')
+    .option('--no-reuse-options', 'Do not reuse stored analyze options from previous index')
     .option('--embeddings', 'Enable embedding generation for semantic search (off by default)')
     .option('--extensions <list>', 'Comma-separated file extensions to include (e.g. .cs,.ts)')
     .option('--repo-alias <name>', 'Override indexed repository name with a stable alias')
@@ -121,6 +124,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 +133,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 +194,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/repo-manager-alias.test.js

@@ -3,7 +3,7 @@ import assert from 'node:assert/strict';
 import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
-import { readRegistry, registerRepo } from '../storage/repo-manager.js';
+import { loadMeta, readRegistry, registerRepo, saveMeta } from '../storage/repo-manager.js';
 function makeMeta(repoPath, lastCommit) {
     return {
         repoPath,
@@ -38,3 +38,26 @@ test('registerRepo stores alias and rejects collisions on different paths', asyn
         }
     }
 });
+test('saveMeta/loadMeta persists analyzeOptions for future re-index reuse', async () => {
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-meta-'));
+    const storagePath = path.join(tmpDir, '.gitnexus');
+    await saveMeta(storagePath, {
+        repoPath: tmpDir,
+        lastCommit: 'abc1234',
+        indexedAt: '2026-03-12T00:00:00.000Z',
+        analyzeOptions: {
+            includeExtensions: ['.cs'],
+            scopeRules: ['Assets/NEON/Code'],
+            repoAlias: 'neonspark-v1-subset',
+            embeddings: true,
+        },
+        stats: { files: 1, nodes: 2, edges: 3 },
+    });
+    const meta = await loadMeta(storagePath);
+    assert.deepEqual(meta?.analyzeOptions, {
+        includeExtensions: ['.cs'],
+        scopeRules: ['Assets/NEON/Code'],
+        repoAlias: 'neonspark-v1-subset',
+        embeddings: true,
+    });
+});

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));
+});