@veewo/gitnexus 1.5.5 → 1.5.7

package/dist/benchmark/analyze-runner.d.ts

@@ -1,8 +1,6 @@
 export interface AnalyzeRunOptions {
     extensions?: string;
     repoAlias?: string;
-    scopeManifest?: string;
-    scopePrefix?: string[];
 }
 export declare function parseAnalyzeSummary(output: string): {
     totalSeconds: number;

package/dist/benchmark/analyze-runner.js

@@ -21,12 +21,6 @@ export function buildAnalyzeArgs(repoPath, options) {
     if (options.repoAlias) {
         args.push('--repo-alias', options.repoAlias);
     }
-    if (options.scopeManifest) {
-        args.push('--scope-manifest', options.scopeManifest);
-    }
-    for (const prefix of options.scopePrefix || []) {
-        args.push('--scope-prefix', prefix);
-    }
     return args;
 }
 export async function runAnalyze(repoPath, options) {

package/dist/benchmark/analyze-runner.test.js

@@ -11,12 +11,10 @@ Repository indexed successfully (42.3s)
     assert.equal(parsed.nodes, 51172);
     assert.equal(parsed.edges, 108578);
 });
-test('buildAnalyzeArgs forwards alias and scope options', () => {
+test('buildAnalyzeArgs forwards alias and extensions', () => {
     const args = buildAnalyzeArgs('/repo/path', {
         extensions: '.cs,.ts',
         repoAlias: 'neonspark-v1-subset',
-        scopeManifest: '/tmp/scope-manifest.txt',
-        scopePrefix: ['Assets/NEON/Code', 'Packages/com.veewo.*'],
     });
     assert.deepEqual(args, [
         'dist/cli/index.js',
@@ -27,18 +25,11 @@ test('buildAnalyzeArgs forwards alias and scope options', () => {
         '/repo/path',
         '--repo-alias',
         'neonspark-v1-subset',
-        '--scope-manifest',
-        '/tmp/scope-manifest.txt',
-        '--scope-prefix',
-        'Assets/NEON/Code',
-        '--scope-prefix',
-        'Packages/com.veewo.*',
     ]);
 });
 test('buildAnalyzeArgs omits --extensions when not explicitly provided', () => {
     const args = buildAnalyzeArgs('/repo/path', {
         repoAlias: 'neonspark-v1-subset',
-        scopeManifest: '/tmp/scope-manifest.txt',
     });
     assert.equal(args.includes('--extensions'), false);
 });

package/dist/benchmark/runner.d.ts

@@ -16,8 +16,6 @@ interface RunBenchmarkOptions {
     profile: ProfileConfig;
     reportDir?: string;
     extensions: string;
-    scopeManifest?: string;
-    scopePrefix?: string[];
     skipAnalyze: boolean;
 }
 export interface BenchmarkResult {

package/dist/benchmark/runner.js

@@ -198,8 +198,6 @@ export async function runBenchmark(ds, options) {
         const analyze = await runAnalyze(path.resolve(options.targetPath), {
             extensions: options.extensions,
             repoAlias: options.repoAlias,
-            scopeManifest: options.scopeManifest,
-            scopePrefix: options.scopePrefix,
         });
         analyzeSummary = parseAnalyzeSummary(`${analyze.stdout}\n${analyze.stderr}`);
     }

package/dist/benchmark/u2-e2e/neonspark-full-e2e.js

@@ -79,13 +79,6 @@ async function execCommand(command, args, cwd) {
         });
     });
 }
-function scopePrefixArgs(prefixes) {
-    const out = [];
-    for (const prefix of prefixes) {
-        out.push('--scope-prefix', prefix);
-    }
-    return out;
-}
 async function runRequiredCommand(command, args, cwd) {
     const result = await execCommand(command, args, cwd);
     if (result.code !== 0) {
@@ -282,7 +275,6 @@ export async function runNeonsparkU2E2E(options) {
             },
             'pipeline-profile': async () => {
                 const reportPath = path.join(reportDir, 'pipeline-profile.json');
-                const scopeArgs = scopePrefixArgs(config.scope.scriptPrefixes || []);
                 await runRequiredCommand('npm', [
                     '--prefix',
                     'gitnexus',
@@ -295,14 +287,12 @@ export async function runNeonsparkU2E2E(options) {
                     '1',
                     '--report',
                     reportPath,
-                    ...scopeArgs,
                 ], repoRoot);
                 const raw = await fs.readFile(reportPath, 'utf-8');
                 state.pipelineProfile = JSON.parse(raw);
                 return state.pipelineProfile;
             },
             analyze: async () => {
-                const scopeArgs = scopePrefixArgs(config.scope.scriptPrefixes || []);
                 const analyze = await runRequiredCommand('/usr/bin/time', [
                     '-p',
                     'node',
@@ -313,7 +303,6 @@ export async function runNeonsparkU2E2E(options) {
                     '.cs',
                     '--repo-alias',
                     repoAlias,
-                    ...scopeArgs,
                     config.targetPath,
                 ], gitnexusRoot);
                 const logPath = path.join(reportDir, 'analyze.log');

package/dist/benchmark/u2-performance-sampler.js

@@ -2,7 +2,6 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { performance } from 'node:perf_hooks';
 import { runPipelineFromRepo } from '../core/ingestion/pipeline.js';
-import { resolveAnalyzeScopeRules } from '../cli/analyze-options.js';
 export function computeNumericStats(values) {
     if (values.length === 0) {
         return { mean: 0, median: 0, min: 0, max: 0, spread: 0 };
@@ -96,32 +95,22 @@ function parseArgs(argv) {
     const targetPath = get('--target-path');
     const reportPath = get('--report');
     const thresholdsPath = get('--thresholds');
-    const scopeManifest = get('--scope-manifest');
     const runs = Number(get('--runs') || '3');
-    const scopePrefix = [];
-    for (let i = 0; i < argv.length; i += 1) {
-        if (argv[i] === '--scope-prefix' && i + 1 < argv.length) {
-            scopePrefix.push(argv[i + 1]);
-            i += 1;
-        }
-    }
     if (!targetPath)
         throw new Error('Missing required arg: --target-path <path>');
     if (!reportPath)
         throw new Error('Missing required arg: --report <path>');
     if (!Number.isFinite(runs) || runs <= 0)
         throw new Error('Invalid --runs, must be positive integer');
-    return { targetPath: path.resolve(targetPath), runs: Math.floor(runs), reportPath: path.resolve(reportPath), thresholdsPath: thresholdsPath ? path.resolve(thresholdsPath) : undefined, scopeManifest, scopePrefix };
+    return { targetPath: path.resolve(targetPath), runs: Math.floor(runs), reportPath: path.resolve(reportPath), thresholdsPath: thresholdsPath ? path.resolve(thresholdsPath) : undefined };
 }
 function round1(value) {
     return Number(value.toFixed(1));
 }
 async function main() {
     const args = parseArgs(process.argv.slice(2));
-    const scopeRules = await resolveAnalyzeScopeRules({
-        scopeManifest: args.scopeManifest,
-        scopePrefix: args.scopePrefix,
-    });
+    // No scope rules — full repo scan
+    const scopeRules = [];
     const runs = [];
     for (let run = 1; run <= args.runs; run += 1) {
         console.log(`[u2-sampler] run ${run}/${args.runs} ...`);
@@ -145,8 +134,6 @@ async function main() {
         targetPath: args.targetPath,
         runs: args.runs,
         scope: {
-            scopeManifest: args.scopeManifest || null,
-            scopePrefix: args.scopePrefix,
             scopeRuleCount: scopeRules.length,
         },
         samples: runs,

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

@@ -1,26 +1,39 @@
-export interface AnalyzeScopeOptions {
-    scopeManifest?: string;
-    scopePrefix?: string[] | string;
-}
 export interface StoredAnalyzeOptions {
     includeExtensions?: string[];
     scopeRules?: string[];
     repoAlias?: string;
     embeddings?: boolean;
+    csharpDefineCsproj?: string;
 }
-export interface ResolveAnalyzeOptionsInput extends AnalyzeScopeOptions {
+export interface ResolveAnalyzeOptionsInput {
     extensions?: string;
+    scope?: string;
     repoAlias?: string;
     embeddings?: boolean;
     reuseOptions?: boolean;
+    csharpDefineCsproj?: string;
 }
 export interface EffectiveAnalyzeOptions {
     includeExtensions: string[];
     scopeRules: string[];
     repoAlias?: string;
     embeddings: boolean;
+    csharpDefineCsproj?: string;
 }
 export declare function parseExtensionList(rawExtensions?: string): string[];
+/** Parse comma-separated scope rules (e.g. "Assets/,Packages/com.veewo.*"). */
+export declare function parseScopeList(rawScope?: string): string[];
 export declare function normalizeRepoAlias(repoAlias?: string): string | undefined;
-export declare function resolveAnalyzeScopeRules(options?: AnalyzeScopeOptions): Promise<string[]>;
+export interface ValidatedStoredOptions {
+    includeExtensions: string[];
+    scopeRules: string[];
+    repoAlias?: string;
+    embeddings: boolean;
+    csharpDefineCsproj?: string;
+}
+/**
+ * Validate stored options from meta.json.analyzeOptions before reusing them.
+ * Invalid fields are filtered out or set to undefined, with console.warn output.
+ */
+export declare function validateStoredOptions(stored: StoredAnalyzeOptions | undefined, repoPath: string): Promise<ValidatedStoredOptions>;
 export declare function resolveEffectiveAnalyzeOptions(options?: ResolveAnalyzeOptionsInput, stored?: StoredAnalyzeOptions): Promise<EffectiveAnalyzeOptions>;

package/dist/cli/analyze-options.js

@@ -1,7 +1,5 @@
 import fs from 'node:fs/promises';
-import path from 'node:path';
 import { normalizeScopeRules } from '../core/ingestion/scope-filter.js';
-import { parseScopeManifestConfig } from './scope-manifest-config.js';
 const REPO_ALIAS_REGEX = /^[a-zA-Z0-9._-]{3,64}$/;
 export function parseExtensionList(rawExtensions) {
     return (rawExtensions || '')
@@ -10,6 +8,16 @@ export function parseExtensionList(rawExtensions) {
         .filter(Boolean)
         .map((ext) => (ext.startsWith('.') ? ext : `.${ext}`));
 }
+/** Parse comma-separated scope rules (e.g. "Assets/,Packages/com.veewo.*"). */
+export function parseScopeList(rawScope) {
+    if (!rawScope)
+        return [];
+    const rules = rawScope
+        .split(',')
+        .map((rule) => rule.trim())
+        .filter(Boolean);
+    return normalizeScopeRules(rules);
+}
 export function normalizeRepoAlias(repoAlias) {
     if (!repoAlias)
         return undefined;
@@ -21,95 +29,92 @@ export function normalizeRepoAlias(repoAlias) {
     }
     return normalized;
 }
-export async function resolveAnalyzeScopeRules(options) {
-    let manifestRules = [];
-    if (options?.scopeManifest) {
-        const manifestPath = path.resolve(options.scopeManifest);
-        const manifest = await readScopeManifestConfig(manifestPath);
-        manifestRules = manifest.scopeRules;
-        if (manifestRules.length === 0) {
-            throw new Error(`Scope manifest has no valid scope rules: ${manifestPath}`);
+/**
+ * Validate stored options from meta.json.analyzeOptions before reusing them.
+ * Invalid fields are filtered out or set to undefined, with console.warn output.
+ */
+export async function validateStoredOptions(stored, repoPath) {
+    if (!stored) {
+        return { includeExtensions: [], scopeRules: [], repoAlias: undefined, embeddings: false, csharpDefineCsproj: undefined };
+    }
+    // Validate repoAlias
+    let repoAlias;
+    if (stored.repoAlias) {
+        const trimmed = stored.repoAlias.trim();
+        if (trimmed && REPO_ALIAS_REGEX.test(trimmed)) {
+            repoAlias = trimmed;
+        }
+        else {
+            console.warn(`  Warning: stored repoAlias "${stored.repoAlias}" is invalid, resetting to undefined.`);
         }
     }
-    return resolveScopeRulesFromInput(manifestRules, normalizeScopePrefixes(options?.scopePrefix), Boolean(options?.scopeManifest));
-}
-function parseScopePrefixCount(scopePrefix) {
-    if (Array.isArray(scopePrefix))
-        return scopePrefix.length;
-    if (typeof scopePrefix === 'string')
-        return scopePrefix.trim() ? 1 : 0;
-    return 0;
+    // Validate includeExtensions (must start with '.')
+    let includeExtensions = [];
+    if (stored.includeExtensions) {
+        const valid = [];
+        for (const ext of stored.includeExtensions) {
+            if (typeof ext === 'string' && ext.startsWith('.')) {
+                valid.push(ext);
+            }
+            else {
+                console.warn(`  Warning: stored includeExtensions entry "${ext}" does not start with '.', filtering out.`);
+            }
+        }
+        includeExtensions = valid;
+    }
+    // Validate scopeRules (filter empty/whitespace-only)
+    let scopeRules = [];
+    if (stored.scopeRules) {
+        scopeRules = stored.scopeRules.filter((rule) => typeof rule === 'string' && rule.trim().length > 0);
+    }
+    // Validate csharpDefineCsproj (file must exist)
+    let csharpDefineCsproj;
+    if (stored.csharpDefineCsproj) {
+        try {
+            await fs.stat(stored.csharpDefineCsproj);
+            csharpDefineCsproj = stored.csharpDefineCsproj;
+        }
+        catch {
+            console.warn(`  Warning: stored csharpDefineCsproj "${stored.csharpDefineCsproj}" not found on disk, resetting to undefined.`);
+        }
+    }
+    return {
+        includeExtensions,
+        scopeRules,
+        repoAlias,
+        embeddings: Boolean(stored.embeddings),
+        csharpDefineCsproj,
+    };
 }
 export async function resolveEffectiveAnalyzeOptions(options, stored) {
-    const manifestConfig = options?.scopeManifest
-        ? await readScopeManifestConfig(path.resolve(options.scopeManifest))
-        : undefined;
     const includeExtensionsFromCli = parseExtensionList(options?.extensions);
-    const scopeRulesFromCli = resolveScopeRulesFromInput(manifestConfig?.scopeRules || [], normalizeScopePrefixes(options?.scopePrefix), Boolean(options?.scopeManifest));
+    const scopeRulesFromCli = parseScopeList(options?.scope);
     const repoAliasFromCli = normalizeRepoAlias(options?.repoAlias);
-    const manifestExtensions = manifestConfig?.directives.extensions;
-    const manifestRepoAlias = manifestConfig?.directives.repoAlias;
-    const manifestEmbeddings = manifestConfig?.directives.embeddings;
     const hasCliExtensions = options?.extensions !== undefined;
-    const hasCliScope = Boolean(options?.scopeManifest) || parseScopePrefixCount(options?.scopePrefix) > 0;
+    const hasCliScope = options?.scope !== undefined;
     const hasCliRepoAlias = options?.repoAlias !== undefined;
+    const hasCliCsproj = options?.csharpDefineCsproj !== undefined;
     const canReuse = options?.reuseOptions !== false;
     const includeExtensions = hasCliExtensions
         ? includeExtensionsFromCli
-        : (manifestExtensions !== undefined
-            ? parseExtensionList(manifestExtensions)
-            : (canReuse ? (stored?.includeExtensions || []) : []));
+        : (canReuse ? (stored?.includeExtensions || []) : []);
     const scopeRules = hasCliScope
         ? scopeRulesFromCli
         : (canReuse ? (stored?.scopeRules || []) : []);
     const repoAlias = hasCliRepoAlias
         ? repoAliasFromCli
-        : (manifestRepoAlias !== undefined
-            ? normalizeRepoAlias(manifestRepoAlias)
-            : (canReuse ? normalizeRepoAlias(stored?.repoAlias) : undefined));
-    const embeddings = options?.embeddings
-        ?? (manifestEmbeddings !== undefined
-            ? parseManifestEmbeddings(manifestEmbeddings)
-            : (canReuse ? Boolean(stored?.embeddings) : false));
+        : (canReuse ? normalizeRepoAlias(stored?.repoAlias) : undefined);
+    const embeddings = options?.embeddings !== undefined
+        ? options.embeddings
+        : (canReuse ? Boolean(stored?.embeddings) : false);
+    const csharpDefineCsproj = hasCliCsproj
+        ? options.csharpDefineCsproj
+        : (canReuse ? stored?.csharpDefineCsproj : undefined);
     return {
         includeExtensions: [...includeExtensions],
         scopeRules: [...scopeRules],
         repoAlias,
         embeddings,
+        csharpDefineCsproj,
     };
 }
-function normalizeScopePrefixes(scopePrefix) {
-    const prefixesRaw = Array.isArray(scopePrefix)
-        ? scopePrefix || []
-        : scopePrefix
-            ? [scopePrefix]
-            : [];
-    return prefixesRaw
-        .map((prefix) => prefix.trim())
-        .filter(Boolean);
-}
-function resolveScopeRulesFromInput(manifestRules, prefixes, hasScopeManifest) {
-    const normalizedRules = normalizeScopeRules([...manifestRules, ...prefixes]);
-    if ((hasScopeManifest || prefixes.length > 0) && normalizedRules.length === 0) {
-        throw new Error('No valid scope rules provided.');
-    }
-    return normalizedRules;
-}
-async function readScopeManifestConfig(manifestPath) {
-    let content;
-    try {
-        content = await fs.readFile(manifestPath, 'utf-8');
-    }
-    catch {
-        throw new Error(`Scope manifest not found: ${manifestPath}`);
-    }
-    return parseScopeManifestConfig(content);
-}
-function parseManifestEmbeddings(raw) {
-    const normalized = raw.trim().toLowerCase();
-    if (normalized === 'true')
-        return true;
-    if (normalized === 'false')
-        return false;
-    throw new Error(`Invalid @embeddings directive value: ${raw}. Expected true or false.`);
-}

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

@@ -3,8 +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, resolveEffectiveAnalyzeOptions, } from './analyze-options.js';
-import { parseScopeManifestConfig } from './scope-manifest-config.js';
+import { normalizeRepoAlias, parseExtensionList, resolveEffectiveAnalyzeOptions, validateStoredOptions, } from './analyze-options.js';
 test('parseExtensionList normalizes dot prefixes', () => {
     const exts = parseExtensionList('cs,.ts, go ');
     assert.deepEqual(exts, ['.cs', '.ts', '.go']);
@@ -15,26 +14,6 @@ test('normalizeRepoAlias validates format', () => {
     assert.throws(() => normalizeRepoAlias('ab'), /repo alias/i);
     assert.throws(() => normalizeRepoAlias('bad alias'), /repo alias/i);
 });
-test('resolveAnalyzeScopeRules combines manifest and repeated prefixes', async () => {
-    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-scope-test-'));
-    const manifestPath = path.join(tmpDir, 'scope.txt');
-    await fs.writeFile(manifestPath, '# comment\nAssets/NEON/Code\n\nPackages/com.veewo.*\n', 'utf-8');
-    const rules = await resolveAnalyzeScopeRules({
-        scopeManifest: manifestPath,
-        scopePrefix: ['Packages/com.neonspark.*'],
-    });
-    assert.deepEqual(rules, [
-        'Assets/NEON/Code',
-        'Packages/com.veewo.*',
-        'Packages/com.neonspark.*',
-    ]);
-});
-test('resolveAnalyzeScopeRules fails when manifest has no usable rule', async () => {
-    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-scope-test-'));
-    const manifestPath = path.join(tmpDir, 'empty-scope.txt');
-    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'],
@@ -53,16 +32,18 @@ test('resolveEffectiveAnalyzeOptions disables reuse via reuseOptions=false', asy
         scopeRules: ['Assets/NEON/Code'],
         repoAlias: 'neonspark-v1-subset',
         embeddings: true,
+        csharpDefineCsproj: '/tmp/Assembly-CSharp.csproj',
     });
     assert.deepEqual(resolved.includeExtensions, []);
     assert.deepEqual(resolved.scopeRules, []);
     assert.equal(resolved.repoAlias, undefined);
     assert.equal(resolved.embeddings, false);
+    assert.equal(resolved.csharpDefineCsproj, undefined);
 });
 test('resolveEffectiveAnalyzeOptions prefers explicit CLI values over stored settings', async () => {
     const resolved = await resolveEffectiveAnalyzeOptions({
         extensions: '.ts',
-        scopePrefix: ['src'],
+        scope: 'src/',
         repoAlias: 'new-alias',
         embeddings: false,
     }, {
@@ -76,59 +57,83 @@ test('resolveEffectiveAnalyzeOptions prefers explicit CLI values over stored set
     assert.equal(resolved.repoAlias, 'new-alias');
     assert.equal(resolved.embeddings, false);
 });
-test('resolveEffectiveAnalyzeOptions reads @extensions/@repoAlias/@embeddings from manifest', async () => {
-    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-manifest-directives-'));
-    const manifestPath = path.join(tmpDir, 'sync-manifest.txt');
-    await fs.writeFile(manifestPath, ['Assets/', '@extensions=.cs,.meta', '@repoAlias=neonspark-core', '@embeddings=false'].join('\n'), 'utf-8');
-    const resolved = await resolveEffectiveAnalyzeOptions({ scopeManifest: manifestPath }, {
-        includeExtensions: ['.ts'],
-        scopeRules: ['src'],
-        repoAlias: 'stored-alias',
-        embeddings: true,
-    });
-    assert.deepEqual(resolved.scopeRules, ['Assets']);
-    assert.deepEqual(resolved.includeExtensions, ['.cs', '.meta']);
-    assert.equal(resolved.repoAlias, 'neonspark-core');
+test('resolveEffectiveAnalyzeOptions no stored uses defaults', async () => {
+    const resolved = await resolveEffectiveAnalyzeOptions({}, undefined);
+    assert.deepEqual(resolved.includeExtensions, []);
+    assert.deepEqual(resolved.scopeRules, []);
+    assert.equal(resolved.repoAlias, undefined);
     assert.equal(resolved.embeddings, false);
+    assert.equal(resolved.csharpDefineCsproj, undefined);
 });
-test('resolveEffectiveAnalyzeOptions enforces precedence CLI > manifest > meta', async () => {
-    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-manifest-precedence-'));
-    const manifestPath = path.join(tmpDir, 'sync-manifest.txt');
-    await fs.writeFile(manifestPath, ['Assets/', '@extensions=.cs,.meta', '@repoAlias=manifest-alias', '@embeddings=false'].join('\n'), 'utf-8');
-    const resolved = await resolveEffectiveAnalyzeOptions({
-        scopeManifest: manifestPath,
-        extensions: '.ts',
-    }, {
-        includeExtensions: ['.js'],
-        scopeRules: ['tools'],
-        repoAlias: 'meta-alias',
-        embeddings: true,
+test('resolveEffectiveAnalyzeOptions reuses stored scopeRules when CLI scope is omitted', async () => {
+    const resolved = await resolveEffectiveAnalyzeOptions({ extensions: '.ts' }, {
+        scopeRules: ['Assets/', 'Packages/com.veewo.*'],
     });
-    assert.deepEqual(resolved.scopeRules, ['Assets']);
-    assert.deepEqual(resolved.includeExtensions, ['.ts']);
-    assert.equal(resolved.repoAlias, 'manifest-alias');
-    assert.equal(resolved.embeddings, false);
+    assert.deepEqual(resolved.scopeRules, ['Assets/', 'Packages/com.veewo.*']);
+});
+test('resolveEffectiveAnalyzeOptions parses --scope comma-separated rules', async () => {
+    const resolved = await resolveEffectiveAnalyzeOptions({ scope: 'Assets/,Packages/com.veewo.*' }, undefined);
+    assert.deepEqual(resolved.scopeRules, ['Assets/', 'Packages/com.veewo.*']);
+});
+test('resolveEffectiveAnalyzeOptions reuses stored csharpDefineCsproj', async () => {
+    const resolved = await resolveEffectiveAnalyzeOptions({}, {
+        csharpDefineCsproj: '/path/to/Assembly-CSharp.csproj',
+    });
+    assert.equal(resolved.csharpDefineCsproj, '/path/to/Assembly-CSharp.csproj');
 });
-test('resolveEffectiveAnalyzeOptions rejects unknown manifest directives', async () => {
-    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-manifest-unknown-'));
-    const manifestPath = path.join(tmpDir, 'sync-manifest.txt');
-    await fs.writeFile(manifestPath, ['Assets/', '@foo=bar'].join('\n'), 'utf-8');
-    await assert.rejects(resolveEffectiveAnalyzeOptions({ scopeManifest: manifestPath }), /unknown manifest directive/i);
-});
-test('parseScopeManifestConfig splits scope rules and directives', () => {
-    const parsed = parseScopeManifestConfig([
-        '# comment',
-        'Assets/',
-        'Packages/com.veewo.*',
-        '',
-        '@extensions=.cs,.meta',
-        '@repoAlias=demo-repo',
-        '@embeddings=false',
-    ].join('\n'));
-    assert.deepEqual(parsed.scopeRules, ['Assets', 'Packages/com.veewo.*']);
-    assert.deepEqual(parsed.directives, {
-        extensions: '.cs,.meta',
-        repoAlias: 'demo-repo',
-        embeddings: 'false',
+test('resolveEffectiveAnalyzeOptions CLI csharpDefineCsproj overrides stored', async () => {
+    const resolved = await resolveEffectiveAnalyzeOptions({ csharpDefineCsproj: '/new/path.csproj' }, {
+        csharpDefineCsproj: '/old/path.csproj',
     });
+    assert.equal(resolved.csharpDefineCsproj, '/new/path.csproj');
+});
+// ─── validateStoredOptions tests ────────────────────────────────────
+test('validateStoredOptions returns defaults when stored is undefined', async () => {
+    const result = await validateStoredOptions(undefined, '/tmp');
+    assert.deepEqual(result.includeExtensions, []);
+    assert.deepEqual(result.scopeRules, []);
+    assert.equal(result.repoAlias, undefined);
+    assert.equal(result.embeddings, false);
+    assert.equal(result.csharpDefineCsproj, undefined);
+});
+test('validateStoredOptions passes valid options unchanged', async () => {
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-validate-'));
+    const csprojPath = path.join(tmpDir, 'Assembly-CSharp.csproj');
+    await fs.writeFile(csprojPath, '<Project />', 'utf-8');
+    const result = await validateStoredOptions({
+        includeExtensions: ['.cs', '.ts'],
+        scopeRules: ['Assets/'],
+        repoAlias: 'my-repo',
+        csharpDefineCsproj: csprojPath,
+        embeddings: true,
+    }, tmpDir);
+    assert.deepEqual(result.includeExtensions, ['.cs', '.ts']);
+    assert.deepEqual(result.scopeRules, ['Assets/']);
+    assert.equal(result.repoAlias, 'my-repo');
+    assert.equal(result.csharpDefineCsproj, csprojPath);
+    assert.equal(result.embeddings, true);
+});
+test('validateStoredOptions warns on invalid repoAlias and falls back', async () => {
+    const result = await validateStoredOptions({
+        repoAlias: 'bad alias!',
+    }, '/tmp');
+    assert.equal(result.repoAlias, undefined);
+});
+test('validateStoredOptions filters invalid extensions', async () => {
+    const result = await validateStoredOptions({
+        includeExtensions: ['cs', '.ts', '', '.go'],
+    }, '/tmp');
+    assert.deepEqual(result.includeExtensions, ['.ts', '.go']);
+});
+test('validateStoredOptions filters empty scopeRules', async () => {
+    const result = await validateStoredOptions({
+        scopeRules: ['', '  ', 'Assets/', 'Packages/com.veewo.*'],
+    }, '/tmp');
+    assert.deepEqual(result.scopeRules, ['Assets/', 'Packages/com.veewo.*']);
+});
+test('validateStoredOptions warns on missing csharpDefineCsproj file', async () => {
+    const result = await validateStoredOptions({
+        csharpDefineCsproj: '/nonexistent/path.csproj',
+    }, '/tmp');
+    assert.equal(result.csharpDefineCsproj, undefined);
 });

package/dist/cli/analyze.d.ts

@@ -3,16 +3,13 @@
  *
  * Indexes a repository and stores the knowledge graph in .gitnexus/
  */
-import { type SyncManifestPolicy } from './sync-manifest.js';
 export interface AnalyzeOptions {
     force?: boolean;
     embeddings?: boolean;
     extensions?: string;
+    scope?: string;
     repoAlias?: string;
     csharpDefineCsproj?: string;
-    scopeManifest?: string;
-    scopePrefix?: string[];
-    syncManifestPolicy?: SyncManifestPolicy;
     reuseOptions?: boolean;
     skills?: boolean;
     verbose?: boolean;
@@ -21,6 +18,7 @@ export declare const analyzeCommand: (inputPath?: string, options?: AnalyzeOptio
 export declare function buildPipelineRunOptionsForAnalyze(resolvedOptions: {
     includeExtensions: string[];
     scopeRules: string[];
+    csharpDefineCsproj?: string;
 }, options?: AnalyzeOptions): {
     includeExtensions: string[];
     scopeRules: string[];