@veewo/gitnexus 1.3.9 → 1.3.10

package/dist/cli/ai-context.js

@@ -38,7 +38,7 @@ This project is indexed by GitNexus as **${projectName}** (${stats.nodes || 0} s
 2. **Match your task to a skill below** and **read that skill file**
 3. **Follow the skill's workflow and checklist**
 
-> If step 1 warns the index is stale, run \`npx gitnexus analyze\` in the terminal first.
+> If step 1 warns the index is stale, ask user whether to rebuild index via \`npx -y gitnexus analyze\` first (it reuses previous analyze scope/options by default; add \`--no-reuse-options\` to reset). If user declines, explicitly warn that retrieval may not reflect current codebase. For build/analyze/test commands, use a 10-30 minute timeout; on failure/timeout, report exact tool output and do not auto-retry or silently fall back to glob/grep.
 
 ## Skills
 

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

@@ -27,6 +27,6 @@ test('pipeline forwards extension-filtered scoped paths to unity enrich', { time
         includeExtensions: ['.cs'],
         scopeRules: ['Assets'],
     });
-    assert.equal(result.unityResult?.bindingCount, 0);
+    assert.ok((result.unityResult?.bindingCount || 0) > 0);
     assert.ok(result.unityResult?.diagnostics.some((message) => message.includes('scanContext:')));
 });

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.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,7 @@ 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}`;
@@ -62,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);
@@ -99,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}',
@@ -171,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);
@@ -259,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)`;
         }
@@ -284,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,

package/dist/cli/index.js

@@ -69,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')

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/mcp/resources.js

@@ -186,7 +186,7 @@ async function getContextResource(backend, repoName) {
     lines.push('  - cypher: Raw graph queries');
     lines.push('  - list_repos: Discover all indexed repositories');
     lines.push('');
-    lines.push('re_index: Run `npx gitnexus analyze` in terminal if data is stale');
+    lines.push('re_index: If data is stale, ask user whether to run `npx -y gitnexus analyze` (reuses previous analyze scope/options unless `--no-reuse-options` is passed). If user declines, clearly state retrieval may not reflect current code. For build/analyze/test commands, use 10-30 minute timeout; on failure/timeout, report exact tool output and do not auto-retry or silently switch to glob/grep fallback.');
     lines.push('');
     lines.push('resources_available:');
     lines.push('  - gitnexus://repos: All indexed repositories');

package/dist/mcp/staleness.js

@@ -17,7 +17,7 @@ export function checkStaleness(repoPath, lastCommit) {
             return {
                 isStale: true,
                 commitsBehind,
-                hint: `⚠️ Index is ${commitsBehind} commit${commitsBehind > 1 ? 's' : ''} behind HEAD. Run analyze tool to update.`,
+                hint: `⚠️ Index is ${commitsBehind} commit${commitsBehind > 1 ? 's' : ''} behind HEAD. Ask user whether to run analyze to rebuild index; if not rebuilt, retrieval may not match current code.`,
             };
         }
         return { isStale: false, commitsBehind: 0 };

package/dist/storage/repo-manager.d.ts

@@ -9,6 +9,12 @@ export interface RepoMeta {
     repoPath: string;
     lastCommit: string;
     indexedAt: string;
+    analyzeOptions?: {
+        includeExtensions?: string[];
+        scopeRules?: string[];
+        repoAlias?: string;
+        embeddings?: boolean;
+    };
     stats?: {
         files?: number;
         nodes?: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@veewo/gitnexus",
-  "version": "1.3.9",
+  "version": "1.3.10",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",
@@ -36,7 +36,7 @@
     "vendor"
   ],
   "scripts": {
-    "build": "tsc",
+    "build": "rm -rf dist && tsc",
     "dev": "tsx watch src/cli/index.ts",
     "prepare": "npm run build",
     "check:release-paths": "node hooks/check-release-path-hygiene.mjs",
@@ -44,7 +44,7 @@
     "check:u2-e2e-target": "node -e \"const p=(process.env.GITNEXUS_U2_E2E_TARGET_PATH||'').trim();if(!p){console.error('Missing env: GITNEXUS_U2_E2E_TARGET_PATH');process.exit(1);}\"",
     "test:unity": "npm run build && node --test dist/core/unity/*.test.js",
     "test:u3:gates": "npm run check:release-paths && npm run build && node --test dist/benchmark/u2-e2e/*.test.js dist/mcp/local/unity-enrichment.test.js dist/core/ingestion/unity-resource-processor.test.js",
-    "test:benchmark": "npm run build && node --test dist/benchmark/*.test.js dist/cli/*.test.js",
+    "test:benchmark": "npm run build && node --test dist/benchmark/*.test.js && node --test dist/cli/*.test.js",
     "benchmark:quick": "npm run build && node dist/cli/index.js benchmark-unity ../benchmarks/unity-baseline/v1 --profile quick --target-path ../benchmarks/fixtures/unity-mini",
     "benchmark:full": "npm run build && node dist/cli/index.js benchmark-unity ../benchmarks/unity-baseline/v1 --profile full --target-path ../benchmarks/fixtures/unity-mini",
     "benchmark:neonspark:full": "npm run check:neonspark-target && npm run build && node dist/cli/index.js benchmark-unity ../benchmarks/unity-baseline/neonspark-v1 --profile full --target-path \"$GITNEXUS_NEONSPARK_TARGET_PATH\" --repo-alias neonspark-v1-subset --scope-manifest ../benchmarks/unity-baseline/neonspark-v1/sync-manifest.txt",

package/dist/cli/analyze-custom-modules-regression.test.d.ts

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

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

@@ -1,75 +0,0 @@
-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

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

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

@@ -1,36 +0,0 @@
-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/core/ingestion/modules/assignment-engine.d.ts

@@ -1,33 +0,0 @@
-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;