@veewo/gitnexus 1.3.7 → 1.3.9

package/dist/cli/analyze-custom-modules-regression.test.js

@@ -0,0 +1,75 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { runPipelineFromRepo } from '../core/ingestion/pipeline.js';
+const FIXTURE_REPO = path.resolve(path.dirname(new URL(import.meta.url).pathname), '../../../benchmarks/fixtures/unity-mini');
+async function copyFixtureRepo() {
+    const tmpRepo = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-custom-modules-'));
+    await fs.cp(FIXTURE_REPO, tmpRepo, { recursive: true });
+    await fs.mkdir(path.join(tmpRepo, '.gitnexus'), { recursive: true });
+    return tmpRepo;
+}
+test('pipeline mixed mode writes config module + auto fallback memberships', { timeout: 120_000 }, async () => {
+    const repoPath = await copyFixtureRepo();
+    const configPath = path.join(repoPath, '.gitnexus', 'modules.json');
+    await fs.writeFile(configPath, JSON.stringify({
+        version: 1,
+        mode: 'mixed',
+        modules: [
+            {
+                name: 'Factory',
+                defaultPriority: 100,
+                rules: [
+                    {
+                        id: 'factory-file-rule',
+                        when: {
+                            all: [{ field: 'file.path', op: 'contains', value: 'MinionFactory.cs' }],
+                        },
+                    },
+                ],
+            },
+            {
+                name: 'Battle',
+                defaultPriority: 100,
+                rules: [],
+            },
+        ],
+    }), 'utf-8');
+    const result = await runPipelineFromRepo(repoPath, () => { }, { includeExtensions: ['.cs'] });
+    const communities = [...result.graph.iterNodes()].filter((n) => n.label === 'Community');
+    const memberships = [...result.graph.iterRelationships()].filter((r) => r.type === 'MEMBER_OF');
+    const commById = new Map(communities.map((c) => [c.id, c]));
+    const labels = communities.map((c) => String(c.properties.heuristicLabel || c.properties.name || c.id));
+    assert.ok(labels.includes('Factory'));
+    assert.ok(labels.includes('Battle'));
+    const createMembership = memberships.find((m) => m.sourceId.includes('MinionFactory.cs:Create'));
+    assert.ok(createMembership);
+    const targetCommunity = commById.get(createMembership.targetId);
+    assert.ok(targetCommunity);
+    assert.equal(String(targetCommunity.properties.heuristicLabel), 'Factory');
+    const uniquePerSymbol = new Set(memberships.map((m) => m.sourceId));
+    assert.equal(uniquePerSymbol.size, memberships.length);
+    const battleCommunity = communities.find((c) => String(c.properties.heuristicLabel) === 'Battle');
+    assert.ok(battleCommunity);
+    assert.ok(!memberships.some((m) => m.targetId === battleCommunity.id));
+    const membershipCommunities = new Set(memberships.map((m) => m.targetId));
+    const processCommunities = new Set((result.processResult?.processes || []).flatMap((p) => p.communities || []));
+    for (const processCommunity of processCommunities) {
+        assert.ok(membershipCommunities.has(processCommunity));
+    }
+});
+test('pipeline mixed + invalid modules.json fails fast', { timeout: 120_000 }, async () => {
+    const repoPath = await copyFixtureRepo();
+    const configPath = path.join(repoPath, '.gitnexus', 'modules.json');
+    await fs.writeFile(configPath, JSON.stringify({
+        version: 1,
+        mode: 'mixed',
+        modules: [
+            { name: 'Dup', defaultPriority: 100, rules: [] },
+            { name: 'Dup', defaultPriority: 100, rules: [] },
+        ],
+    }), 'utf-8');
+    await assert.rejects(runPipelineFromRepo(repoPath, () => { }, { includeExtensions: ['.cs'] }), /duplicate module name/i);
+});

package/dist/cli/analyze-modules-diagnostics.test.d.ts

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

package/dist/cli/analyze-modules-diagnostics.test.js

@@ -0,0 +1,36 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { formatModuleDiagnostics } from './analyze.js';
+test('prints one-time fallback warning for mixed + missing modules.json', () => {
+    const lines = formatModuleDiagnostics({
+        mode: 'mixed',
+        usedFallbackAuto: true,
+        warnings: ['modules.json missing in mixed mode, fallback to auto'],
+        emptyModules: [],
+        configuredModuleCount: 0,
+        finalModuleCount: 3,
+    });
+    assert.ok(lines.some((line) => /fallback to auto/i.test(line)));
+});
+test('prints warning for empty modules', () => {
+    const lines = formatModuleDiagnostics({
+        mode: 'mixed',
+        usedFallbackAuto: false,
+        warnings: [],
+        emptyModules: ['Battle'],
+        configuredModuleCount: 1,
+        finalModuleCount: 2,
+    });
+    assert.ok(lines.some((line) => /empty module/i.test(line)));
+    assert.ok(lines.some((line) => /Battle/.test(line)));
+});
+test('README mentions modules.json mode semantics and fallback behavior', async () => {
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    const readmePath = path.resolve(here, '../../README.md');
+    const readme = await fs.readFile(readmePath, 'utf-8');
+    assert.match(readme, /\.gitnexus\/modules\.json/);
+    assert.match(readme, /mixed.*fallback.*auto/i);
+});

package/dist/cli/analyze-multi-scope-regression.test.js

@@ -20,3 +20,13 @@ test('runPipelineFromRepo deduplicates overlapping scope matches and reports dia
     assert.equal(result.scopeDiagnostics?.dedupedMatchCount, 3);
     assert.equal(result.scopeDiagnostics?.normalizedCollisions.length, 0);
 });
+test('pipeline forwards extension-filtered scoped paths to unity enrich', { timeout: 60_000 }, async () => {
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    const fixtureRepo = path.resolve(here, '../../src/core/unity/__fixtures__/mini-unity');
+    const result = await runPipelineFromRepo(fixtureRepo, () => { }, {
+        includeExtensions: ['.cs'],
+        scopeRules: ['Assets'],
+    });
+    assert.equal(result.unityResult?.bindingCount, 0);
+    assert.ok(result.unityResult?.diagnostics.some((message) => message.includes('scanContext:')));
+});

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.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/setup.js

@@ -6,6 +6,7 @@
  * in either global or project scope.
  */
 import fs from 'fs/promises';
+import { readFileSync } from 'node:fs';
 import path from 'path';
 import os from 'os';
 import { execFile } from 'node:child_process';
@@ -16,6 +17,7 @@ import { getGitRoot } from '../storage/git.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const execFileAsync = promisify(execFile);
+const FALLBACK_MCP_PACKAGE = 'gitnexus@latest';
 function resolveSetupScope(rawScope) {
     if (!rawScope || rawScope.trim() === '')
         return 'global';
@@ -32,6 +34,25 @@ function resolveSetupAgent(rawAgent) {
     }
     throw new Error(`Invalid --agent value "${rawAgent}". Use "claude", "opencode", or "codex".`);
 }
+/**
+ * Resolve the package spec used by MCP commands.
+ * Defaults to gitnexus@latest when package metadata is unavailable.
+ */
+function resolveMcpPackageSpec() {
+    try {
+        const packageJsonPath = path.join(__dirname, '..', '..', 'package.json');
+        const raw = readFileSync(packageJsonPath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.name === 'string' && parsed.name.trim().length > 0) {
+            return `${parsed.name}@latest`;
+        }
+    }
+    catch {
+        // Fallback keeps behavior for unusual runtimes.
+    }
+    return FALLBACK_MCP_PACKAGE;
+}
+const MCP_PACKAGE_SPEC = resolveMcpPackageSpec();
 /**
  * The MCP server entry for all editors.
  * On Windows, npx must be invoked via cmd /c since it's a .cmd script.
@@ -40,12 +61,12 @@ function getMcpEntry() {
     if (process.platform === 'win32') {
         return {
             command: 'cmd',
-            args: ['/c', 'npx', '-y', 'gitnexus@latest', 'mcp'],
+            args: ['/c', 'npx', '-y', MCP_PACKAGE_SPEC, 'mcp'],
         };
     }
     return {
         command: 'npx',
-        args: ['-y', 'gitnexus@latest', 'mcp'],
+        args: ['-y', MCP_PACKAGE_SPEC, 'mcp'],
     };
 }
 function getOpenCodeMcpEntry() {
@@ -190,7 +211,7 @@ async function setupClaudeCode(result) {
     console.log('');
     console.log('  Claude Code detected. Run this command to add GitNexus MCP:');
     console.log('');
-    console.log('    claude mcp add gitnexus -- npx -y gitnexus mcp');
+    console.log(`    claude mcp add gitnexus -- npx -y ${MCP_PACKAGE_SPEC} mcp`);
     console.log('');
     result.configured.push('Claude Code (MCP manual step printed)');
 }

package/dist/cli/setup.test.js

@@ -10,6 +10,8 @@ const execFileAsync = promisify(execFile);
 const here = path.dirname(fileURLToPath(import.meta.url));
 const packageRoot = path.resolve(here, '..', '..');
 const cliPath = path.join(packageRoot, 'dist', 'cli', 'index.js');
+const packageName = JSON.parse(await fs.readFile(path.join(packageRoot, 'package.json'), 'utf-8'));
+const expectedMcpPackage = `${packageName.name || 'gitnexus'}@latest`;
 async function runSetup(args, env, cwd = packageRoot) {
     return execFileAsync(process.execPath, [cliPath, 'setup', ...args], { cwd, env });
 }
@@ -112,7 +114,7 @@ process.exit(0);
         const raw = await fs.readFile(outputPath, 'utf-8');
         const parsed = JSON.parse(raw);
         assert.deepEqual(parsed.args.slice(0, 4), ['mcp', 'add', 'gitnexus', '--']);
-        assert.ok(parsed.args.includes('gitnexus@latest'));
+        assert.ok(parsed.args.includes(expectedMcpPackage));
         assert.ok(parsed.args.includes('mcp'));
     }
     finally {
@@ -134,7 +136,7 @@ test('setup configures OpenCode MCP in ~/.config/opencode/opencode.json', async
         const opencodeRaw = await fs.readFile(opencodeConfigPath, 'utf-8');
         const opencodeConfig = JSON.parse(opencodeRaw);
         assert.equal(opencodeConfig.mcp?.gitnexus?.type, 'local');
-        assert.deepEqual(opencodeConfig.mcp?.gitnexus?.command, ['npx', '-y', 'gitnexus@latest', 'mcp']);
+        assert.deepEqual(opencodeConfig.mcp?.gitnexus?.command, ['npx', '-y', expectedMcpPackage, 'mcp']);
     }
     finally {
         await fs.rm(fakeHome, { recursive: true, force: true });
@@ -157,7 +159,7 @@ test('setup keeps using legacy ~/.config/opencode/config.json when it already ex
         const legacyConfig = JSON.parse(legacyRaw);
         assert.equal(legacyConfig.existing, true);
         assert.equal(legacyConfig.mcp?.gitnexus?.type, 'local');
-        assert.deepEqual(legacyConfig.mcp?.gitnexus?.command, ['npx', '-y', 'gitnexus@latest', 'mcp']);
+        assert.deepEqual(legacyConfig.mcp?.gitnexus?.command, ['npx', '-y', expectedMcpPackage, 'mcp']);
         await assert.rejects(fs.access(preferredConfigPath));
     }
     finally {
@@ -254,7 +256,7 @@ test('setup --scope project --agent opencode writes only opencode.json', async (
         const configRaw = await fs.readFile(configPath, 'utf-8');
         const config = JSON.parse(configRaw);
         assert.equal(opencodeConfig.mcp?.gitnexus?.type, 'local');
-        assert.deepEqual(opencodeConfig.mcp?.gitnexus?.command, ['npx', '-y', 'gitnexus@latest', 'mcp']);
+        assert.deepEqual(opencodeConfig.mcp?.gitnexus?.command, ['npx', '-y', expectedMcpPackage, 'mcp']);
         await assert.rejects(fs.access(projectMcpPath));
         await assert.rejects(fs.access(codexConfigPath));
         await fs.access(localSkillPath);

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/modules/assignment-engine.d.ts

@@ -0,0 +1,33 @@
+import type { CommunityMembership, CommunityNode } from '../community-processor.js';
+import type { ModuleConfig, ModuleMode } from './types.js';
+import { type MatchableSymbol } from './rule-matcher.js';
+export type AssignmentSource = 'config-rule' | 'auto-fallback';
+export type AssignmentResolvedBy = 'priority' | 'specificity' | 'rule-order' | 'module-lexicographic' | 'fallback-auto';
+export interface AssignmentInput {
+    mode: ModuleMode;
+    symbols: MatchableSymbol[];
+    autoCommunities: CommunityNode[];
+    autoMemberships: CommunityMembership[];
+    config: ModuleConfig | null;
+}
+export interface SymbolAssignment {
+    symbolId: string;
+    moduleName: string;
+    communityId: string;
+    assignmentSource: AssignmentSource;
+    matchedRuleId?: string;
+    resolvedBy: AssignmentResolvedBy;
+}
+export interface AssignmentDiagnostics {
+    mode: ModuleMode;
+    configuredModuleCount: number;
+    finalModuleCount: number;
+    emptyModules: string[];
+}
+export interface AssignmentOutput {
+    finalModules: CommunityNode[];
+    finalMemberships: CommunityMembership[];
+    membershipsBySymbol: Map<string, SymbolAssignment>;
+    diagnostics: AssignmentDiagnostics;
+}
+export declare function assignModules(input: AssignmentInput): AssignmentOutput;