@veewo/gitnexus 1.5.0-rc.4 → 1.5.0

package/dist/cli/setup.js

@@ -14,7 +14,7 @@ import { fileURLToPath } from 'url';
 import { getGlobalDir, loadCLIConfig, saveCLIConfig } from '../storage/repo-manager.js';
 import { getGitRoot } from '../storage/git.js';
 import { glob } from 'glob';
-import { buildNpxCommand, resolveCliSpec } from '../config/cli-spec.js';
+import { resolveCliSpec } from '../config/cli-spec.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const execFileAsync = promisify(execFile);
@@ -47,25 +47,24 @@ async function installLegacyCursorSkills(result) {
         result.errors.push(`Cursor skills: ${err.message}`);
     }
 }
-const DEFAULT_MCP_PACKAGE_SPEC = resolveCliSpec().packageSpec;
 /**
  * The MCP server entry for all editors.
- * On Windows, npx must be invoked via cmd /c since it's a .cmd script.
+ * Uses the locally installed gitnexus binary.
  */
-function getMcpEntry(mcpPackageSpec) {
+function getMcpEntry() {
     if (process.platform === 'win32') {
         return {
             command: 'cmd',
-            args: ['/c', 'npx', '-y', mcpPackageSpec, 'mcp'],
+            args: ['/c', 'gitnexus', 'mcp'],
         };
     }
     return {
-        command: 'npx',
-        args: ['-y', mcpPackageSpec, 'mcp'],
+        command: 'gitnexus',
+        args: ['mcp'],
     };
 }
-function getOpenCodeMcpEntry(mcpPackageSpec) {
-    const entry = getMcpEntry(mcpPackageSpec);
+function getOpenCodeMcpEntry() {
+    const entry = getMcpEntry();
     return {
         type: 'local',
         command: [entry.command, ...entry.args],
@@ -75,28 +74,28 @@ function getOpenCodeMcpEntry(mcpPackageSpec) {
  * Merge gitnexus entry into an existing MCP config JSON object.
  * Returns the updated config.
  */
-function mergeMcpConfig(existing, mcpPackageSpec) {
+function mergeMcpConfig(existing) {
     if (!existing || typeof existing !== 'object') {
         existing = {};
     }
     if (!existing.mcpServers || typeof existing.mcpServers !== 'object') {
         existing.mcpServers = {};
     }
-    existing.mcpServers.gitnexus = getMcpEntry(mcpPackageSpec);
+    existing.mcpServers.gitnexus = getMcpEntry();
     return existing;
 }
 /**
  * Merge gitnexus entry into an OpenCode config JSON object.
  * Returns the updated config.
  */
-function mergeOpenCodeConfig(existing, mcpPackageSpec) {
+function mergeOpenCodeConfig(existing) {
     if (!existing || typeof existing !== 'object') {
         existing = {};
     }
     if (!existing.mcp || typeof existing.mcp !== 'object') {
         existing.mcp = {};
     }
-    existing.mcp.gitnexus = getOpenCodeMcpEntry(mcpPackageSpec);
+    existing.mcp.gitnexus = getOpenCodeMcpEntry();
     return existing;
 }
 /**
@@ -148,16 +147,16 @@ async function fileExists(filePath) {
 function toTomlString(value) {
     return `"${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
 }
-function buildCodexMcpTable(mcpPackageSpec) {
-    const entry = getMcpEntry(mcpPackageSpec);
+function buildCodexMcpTable() {
+    const entry = getMcpEntry();
     return [
         '[mcp_servers.gitnexus]',
         `command = ${toTomlString(entry.command)}`,
         `args = [${entry.args.map(toTomlString).join(', ')}]`,
     ].join('\n');
 }
-function mergeCodexConfig(existingRaw, mcpPackageSpec) {
-    const table = buildCodexMcpTable(mcpPackageSpec);
+function mergeCodexConfig(existingRaw) {
+    const table = buildCodexMcpTable();
     const normalized = existingRaw.replace(/\r\n/g, '\n');
     const tablePattern = /^\[mcp_servers\.gitnexus\][\s\S]*?(?=^\[[^\]]+\]|(?![\s\S]))/m;
     if (tablePattern.test(normalized)) {
@@ -179,7 +178,7 @@ async function resolveOpenCodeConfigPath(opencodeDir) {
     return preferredPath;
 }
 // ─── Editor-specific setup ─────────────────────────────────────────
-async function setupCursor(result, mcpPackageSpec) {
+async function setupCursor(result) {
     const cursorDir = path.join(os.homedir(), '.cursor');
     if (!(await dirExists(cursorDir))) {
         result.skipped.push('Cursor (not installed)');
@@ -188,7 +187,7 @@ async function setupCursor(result, mcpPackageSpec) {
     const mcpPath = path.join(cursorDir, 'mcp.json');
     try {
         const existing = await readJsonFile(mcpPath);
-        const updated = mergeMcpConfig(existing, mcpPackageSpec);
+        const updated = mergeMcpConfig(existing);
         await writeJsonFile(mcpPath, updated);
         result.configured.push('Cursor');
     }
@@ -196,7 +195,7 @@ async function setupCursor(result, mcpPackageSpec) {
         result.errors.push(`Cursor: ${err.message}`);
     }
 }
-async function setupClaudeCode(result, mcpPackageSpec) {
+async function setupClaudeCode(result) {
     const claudeDir = path.join(os.homedir(), '.claude');
     const hasClaude = await dirExists(claudeDir);
     if (!hasClaude) {
@@ -207,7 +206,7 @@ async function setupClaudeCode(result, mcpPackageSpec) {
     console.log('');
     console.log('  Claude Code detected. Run this command to add GitNexus MCP:');
     console.log('');
-    console.log(`    claude mcp add gitnexus -- ${buildNpxCommand(mcpPackageSpec, 'mcp')}`);
+    console.log(`    claude mcp add gitnexus -- gitnexus mcp`);
     console.log('');
     result.configured.push('Claude Code (MCP manual step printed)');
 }
@@ -243,7 +242,7 @@ async function installProjectAgentSkills(repoRoot, result) {
  * Install GitNexus hooks to ~/.claude/settings.json for Claude Code.
  * Merges hook config without overwriting existing hooks.
  */
-async function installClaudeCodeHooks(result, mcpPackageSpec) {
+async function installClaudeCodeHooks(result) {
     const claudeDir = path.join(os.homedir(), '.claude');
     if (!(await dirExists(claudeDir)))
         return;
@@ -295,7 +294,7 @@ async function installClaudeCodeHooks(result, mcpPackageSpec) {
         result.errors.push(`Claude Code hooks: ${err.message}`);
     }
 }
-async function setupOpenCode(result, mcpPackageSpec) {
+async function setupOpenCode(result) {
     const opencodeDir = path.join(os.homedir(), '.config', 'opencode');
     if (!(await dirExists(opencodeDir))) {
         result.skipped.push('OpenCode (not installed)');
@@ -304,7 +303,7 @@ async function setupOpenCode(result, mcpPackageSpec) {
     const configPath = await resolveOpenCodeConfigPath(opencodeDir);
     try {
         const existing = await readJsonFile(configPath);
-        const config = mergeOpenCodeConfig(existing, mcpPackageSpec);
+        const config = mergeOpenCodeConfig(existing);
         await writeJsonFile(configPath, config);
         result.configured.push(`OpenCode (${path.basename(configPath)})`);
     }
@@ -312,8 +311,8 @@ async function setupOpenCode(result, mcpPackageSpec) {
         result.errors.push(`OpenCode: ${err.message}`);
     }
 }
-async function setupCodex(result, mcpPackageSpec) {
-    const entry = getMcpEntry(mcpPackageSpec);
+async function setupCodex(result) {
+    const entry = getMcpEntry();
     try {
         await execFileAsync('codex', ['mcp', 'add', 'gitnexus', '--', entry.command, ...entry.args], { timeout: 15000 });
         result.configured.push('Codex');
@@ -326,11 +325,11 @@ async function setupCodex(result, mcpPackageSpec) {
         result.errors.push(`Codex: ${err.message}`);
     }
 }
-async function setupProjectMcp(repoRoot, result, mcpPackageSpec) {
+async function setupProjectMcp(repoRoot, result) {
     const mcpPath = path.join(repoRoot, '.mcp.json');
     try {
         const existing = await readJsonFile(mcpPath);
-        const updated = mergeMcpConfig(existing, mcpPackageSpec);
+        const updated = mergeMcpConfig(existing);
         await writeJsonFile(mcpPath, updated);
         result.configured.push(`Project MCP (${path.relative(repoRoot, mcpPath)})`);
     }
@@ -338,7 +337,7 @@ async function setupProjectMcp(repoRoot, result, mcpPackageSpec) {
         result.errors.push(`Project MCP: ${err.message}`);
     }
 }
-async function setupProjectCodex(repoRoot, result, mcpPackageSpec) {
+async function setupProjectCodex(repoRoot, result) {
     const codexConfigPath = path.join(repoRoot, '.codex', 'config.toml');
     try {
         let existingRaw = '';
@@ -349,7 +348,7 @@ async function setupProjectCodex(repoRoot, result, mcpPackageSpec) {
             if (err?.code !== 'ENOENT')
                 throw err;
         }
-        const merged = mergeCodexConfig(existingRaw, mcpPackageSpec);
+        const merged = mergeCodexConfig(existingRaw);
         await fs.mkdir(path.dirname(codexConfigPath), { recursive: true });
         await fs.writeFile(codexConfigPath, merged, 'utf-8');
         result.configured.push(`Project Codex MCP (${path.relative(repoRoot, codexConfigPath)})`);
@@ -358,11 +357,11 @@ async function setupProjectCodex(repoRoot, result, mcpPackageSpec) {
         result.errors.push(`Project Codex MCP: ${err.message}`);
     }
 }
-async function setupProjectOpenCode(repoRoot, result, mcpPackageSpec) {
+async function setupProjectOpenCode(repoRoot, result) {
     const opencodePath = path.join(repoRoot, 'opencode.json');
     try {
         const existing = await readJsonFile(opencodePath);
-        const merged = mergeOpenCodeConfig(existing, mcpPackageSpec);
+        const merged = mergeOpenCodeConfig(existing);
         await writeJsonFile(opencodePath, merged);
         result.configured.push(`Project OpenCode MCP (${path.relative(repoRoot, opencodePath)})`);
     }
@@ -510,7 +509,7 @@ export const setupCommand = async (options = {}) => {
         explicitVersion: options.cliVersion,
         config: existingConfig,
     });
-    const mcpPackageSpec = resolvedCliSpec.packageSpec || DEFAULT_MCP_PACKAGE_SPEC;
+    const mcpPackageSpec = resolvedCliSpec.packageSpec;
     const result = {
         configured: [],
         skipped: [],
@@ -518,7 +517,7 @@ export const setupCommand = async (options = {}) => {
     };
     if (scope === 'global') {
         if (legacyCursorMode) {
-            await setupCursor(result, mcpPackageSpec);
+            await setupCursor(result);
             await installLegacyCursorSkills(result);
             await saveSetupConfig(scope, mcpPackageSpec, result);
             agent = LEGACY_CURSOR_AGENT;
@@ -526,15 +525,15 @@ export const setupCommand = async (options = {}) => {
         else {
             // Configure only the selected agent MCP
             if (agent === 'claude') {
-                await setupClaudeCode(result, mcpPackageSpec);
+                await setupClaudeCode(result);
                 // Claude-only hooks should only be installed when Claude is selected.
-                await installClaudeCodeHooks(result, mcpPackageSpec);
+                await installClaudeCodeHooks(result);
             }
             else if (agent === 'opencode') {
-                await setupOpenCode(result, mcpPackageSpec);
+                await setupOpenCode(result);
             }
             else if (agent === 'codex') {
-                await setupCodex(result, mcpPackageSpec);
+                await setupCodex(result);
             }
             // Install shared global skills once
             await installGlobalAgentSkills(result);
@@ -549,13 +548,13 @@ export const setupCommand = async (options = {}) => {
             return;
         }
         if (agent === 'claude') {
-            await setupProjectMcp(repoRoot, result, mcpPackageSpec);
+            await setupProjectMcp(repoRoot, result);
         }
         else if (agent === 'codex') {
-            await setupProjectCodex(repoRoot, result, mcpPackageSpec);
+            await setupProjectCodex(repoRoot, result);
         }
         else if (agent === 'opencode') {
-            await setupProjectOpenCode(repoRoot, result, mcpPackageSpec);
+            await setupProjectOpenCode(repoRoot, result);
         }
         await installProjectAgentSkills(repoRoot, result);
         await saveSetupConfig(scope, mcpPackageSpec, result);

package/dist/cli/setup.test.js

@@ -10,9 +10,6 @@ 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`;
-const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 async function runSetup(args, env, cwd = packageRoot) {
     return execFileAsync(process.execPath, [cliPath, 'setup', ...args], { cwd, env });
 }
@@ -30,8 +27,8 @@ test('setup without --agent uses legacy Cursor install path', async () => {
         const configPath = path.join(fakeHome, '.gitnexus', 'config.json');
         const cursorMcpRaw = await fs.readFile(cursorMcpPath, 'utf-8');
         const cursorMcp = JSON.parse(cursorMcpRaw);
-        assert.equal(cursorMcp.mcpServers?.gitnexus?.command, 'npx');
-        assert.deepEqual(cursorMcp.mcpServers?.gitnexus?.args, ['-y', expectedMcpPackage, 'mcp']);
+        assert.equal(cursorMcp.mcpServers?.gitnexus?.command, 'gitnexus');
+        assert.deepEqual(cursorMcp.mcpServers?.gitnexus?.args, ['mcp']);
         await fs.access(cursorSkillPath);
         const configRaw = await fs.readFile(configPath, 'utf-8');
         const config = JSON.parse(configRaw);
@@ -142,7 +139,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(expectedMcpPackage));
+        assert.ok(parsed.args.includes('gitnexus'));
         assert.ok(parsed.args.includes('mcp'));
     }
     finally {
@@ -164,7 +161,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', expectedMcpPackage, 'mcp']);
+        assert.deepEqual(opencodeConfig.mcp?.gitnexus?.command, ['gitnexus', 'mcp']);
     }
     finally {
         await fs.rm(fakeHome, { recursive: true, force: true });
@@ -186,7 +183,8 @@ test('setup --cli-version pins MCP package spec and persists it in config', asyn
         const configPath = path.join(fakeHome, '.gitnexus', 'config.json');
         const savedConfigRaw = await fs.readFile(configPath, 'utf-8');
         const savedConfig = JSON.parse(savedConfigRaw);
-        assert.deepEqual(opencodeConfig.mcp?.gitnexus?.command, ['npx', '-y', '@veewo/gitnexus@1.4.7-rc', 'mcp']);
+        assert.deepEqual(opencodeConfig.mcp?.gitnexus?.command, ['gitnexus', 'mcp']);
+        // Version is persisted to config, not MCP entry:
         assert.equal(savedConfig.cliPackageSpec, '@veewo/gitnexus@1.4.7-rc');
         assert.equal(savedConfig.cliVersion, '1.4.7-rc');
     }
@@ -211,7 +209,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', expectedMcpPackage, 'mcp']);
+        assert.deepEqual(legacyConfig.mcp?.gitnexus?.command, ['gitnexus', 'mcp']);
         await assert.rejects(fs.access(preferredConfigPath));
     }
     finally {
@@ -254,7 +252,8 @@ test('setup --scope project --agent claude writes only .mcp.json', async () => {
         const opencodeConfigPath = path.join(fakeRepo, 'opencode.json');
         const projectMcpRaw = await fs.readFile(projectMcpPath, 'utf-8');
         const projectMcp = JSON.parse(projectMcpRaw);
-        assert.equal(projectMcp.mcpServers?.gitnexus?.command, 'npx');
+        assert.equal(projectMcp.mcpServers?.gitnexus?.command, 'gitnexus');
+        assert.deepEqual(projectMcp.mcpServers?.gitnexus?.args, ['mcp']);
         await assert.rejects(fs.access(codexConfigPath));
         await assert.rejects(fs.access(opencodeConfigPath));
     }
@@ -278,7 +277,8 @@ test('setup --scope project --agent codex writes only .codex/config.toml', async
         const opencodeConfigPath = path.join(fakeRepo, 'opencode.json');
         const codexConfigRaw = await fs.readFile(codexConfigPath, 'utf-8');
         assert.match(codexConfigRaw, /\[mcp_servers\.gitnexus\]/);
-        assert.match(codexConfigRaw, /command = "npx"/);
+        assert.match(codexConfigRaw, /command = "gitnexus"/);
+        assert.match(codexConfigRaw, /args = \["mcp"\]/);
         await assert.rejects(fs.access(projectMcpPath));
         await assert.rejects(fs.access(opencodeConfigPath));
     }
@@ -316,7 +316,7 @@ test('setup --scope project --agent codex replaces existing gitnexus table witho
         const gitnexusTable = gitnexusTableMatch[0];
         assert.equal((gitnexusTable.match(/^command\s*=/gm) || []).length, 1);
         assert.equal((gitnexusTable.match(/^args\s*=/gm) || []).length, 1);
-        assert.match(gitnexusTable, new RegExp(escapeRegExp(expectedMcpPackage)));
+        assert.match(gitnexusTable, /command = "gitnexus"/);
         assert.doesNotMatch(gitnexusTable, /oldpkg@latest/);
         assert.match(codexConfigRaw, /^\[profiles\.default\]$/m);
     }
@@ -346,7 +346,7 @@ test('setup --scope project --agent codex is idempotent across repeated runs', a
         const gitnexusTable = gitnexusTableMatch[0];
         assert.equal((gitnexusTable.match(/^command\s*=/gm) || []).length, 1);
         assert.equal((gitnexusTable.match(/^args\s*=/gm) || []).length, 1);
-        assert.match(gitnexusTable, new RegExp(escapeRegExp(expectedMcpPackage)));
+        assert.match(gitnexusTable, /command = "gitnexus"/);
     }
     finally {
         await fs.rm(fakeHome, { recursive: true, force: true });
@@ -374,7 +374,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', expectedMcpPackage, 'mcp']);
+        assert.deepEqual(opencodeConfig.mcp?.gitnexus?.command, ['gitnexus', 'mcp']);
         await assert.rejects(fs.access(projectMcpPath));
         await assert.rejects(fs.access(codexConfigPath));
         await fs.access(localSkillPath);

package/dist/cli/sync-manifest.d.ts

@@ -0,0 +1,27 @@
+export interface SyncManifestScopeOptions {
+    scopeManifest?: string;
+    scopePrefix?: string[] | string;
+}
+export type SyncManifestPolicy = 'ask' | 'update' | 'keep' | 'error';
+export interface SyncManifestDiffEntry {
+    directive: 'extensions' | 'repoAlias' | 'embeddings';
+    manifestValue?: string;
+    cliValue: string;
+}
+export interface EnforceSyncManifestConsistencyInput {
+    manifestPath?: string;
+    extensions?: string;
+    repoAlias?: string;
+    embeddings?: boolean;
+    policy?: SyncManifestPolicy;
+    stdinIsTTY?: boolean;
+    prompt?: (message: string) => Promise<'update' | 'keep'>;
+}
+export interface EnforceSyncManifestConsistencyResult {
+    decision: 'none' | 'update' | 'keep';
+    diff: SyncManifestDiffEntry[];
+}
+export declare function resolveDefaultSyncManifestPath(repoPath: string): string;
+export declare function shouldAutoUseSyncManifest(options?: SyncManifestScopeOptions): boolean;
+export declare function resolveScopeManifestForAnalyze(repoPath: string, options?: SyncManifestScopeOptions, pathExists?: (candidatePath: string) => Promise<boolean>): Promise<string | undefined>;
+export declare function enforceSyncManifestConsistency(input: EnforceSyncManifestConsistencyInput): Promise<EnforceSyncManifestConsistencyResult>;

package/dist/cli/sync-manifest.js

@@ -0,0 +1,200 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import readline from 'node:readline/promises';
+import { stdin as input, stdout as output } from 'node:process';
+import { parseScopeManifestConfig } from './scope-manifest-config.js';
+import { normalizeRepoAlias, parseExtensionList } from './analyze-options.js';
+export function resolveDefaultSyncManifestPath(repoPath) {
+    return path.join(repoPath, '.gitnexus', 'sync-manifest.txt');
+}
+export function shouldAutoUseSyncManifest(options) {
+    if (options?.scopeManifest)
+        return false;
+    return parseScopePrefixCount(options?.scopePrefix) === 0;
+}
+export async function resolveScopeManifestForAnalyze(repoPath, options, pathExists = fileExists) {
+    if (options?.scopeManifest) {
+        return options.scopeManifest;
+    }
+    if (!shouldAutoUseSyncManifest(options)) {
+        return undefined;
+    }
+    const defaultManifestPath = resolveDefaultSyncManifestPath(repoPath);
+    if (await pathExists(defaultManifestPath)) {
+        return defaultManifestPath;
+    }
+    return undefined;
+}
+export async function enforceSyncManifestConsistency(input) {
+    if (!input.manifestPath) {
+        return { decision: 'none', diff: [] };
+    }
+    ensureConcreteManifestPath(input.manifestPath);
+    const raw = await fs.readFile(input.manifestPath, 'utf-8');
+    const parsed = parseScopeManifestConfig(raw);
+    const normalizedDirectives = normalizeManifestDirectives(parsed.directives);
+    const diff = computeDiff(normalizedDirectives, input);
+    const policy = normalizePolicy(input.policy);
+    if (diff.length === 0) {
+        if (policy === 'update') {
+            throw new Error('Sync manifest rewrite requires non-empty diff entries.');
+        }
+        return { decision: 'none', diff };
+    }
+    const decision = await resolveDecision(policy, input.manifestPath, diff, input.stdinIsTTY, input.prompt);
+    if (decision === 'update') {
+        const nextDirectives = mergeDirectivesForUpdate(normalizedDirectives, input);
+        const rewritten = renderSyncManifest(parsed.scopeRules, nextDirectives);
+        await fs.writeFile(input.manifestPath, rewritten, 'utf-8');
+    }
+    return {
+        decision,
+        diff,
+    };
+}
+function parseScopePrefixCount(scopePrefix) {
+    if (Array.isArray(scopePrefix))
+        return scopePrefix.length;
+    if (typeof scopePrefix === 'string')
+        return scopePrefix.trim() ? 1 : 0;
+    return 0;
+}
+async function fileExists(candidatePath) {
+    try {
+        await fs.stat(candidatePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function normalizePolicy(raw) {
+    if (!raw)
+        return 'ask';
+    if (raw === 'ask' || raw === 'update' || raw === 'keep' || raw === 'error')
+        return raw;
+    throw new Error(`Invalid --sync-manifest-policy value: ${raw}. Use ask|update|keep|error.`);
+}
+function normalizeManifestDirectives(directives) {
+    return {
+        extensions: normalizeExtensions(directives.extensions),
+        repoAlias: normalizeAlias(directives.repoAlias),
+        embeddings: normalizeEmbeddings(directives.embeddings),
+    };
+}
+function computeDiff(manifest, input) {
+    const diff = [];
+    if (input.extensions !== undefined) {
+        const cliValue = normalizeExtensions(input.extensions);
+        if (cliValue !== manifest.extensions) {
+            diff.push({ directive: 'extensions', manifestValue: manifest.extensions, cliValue: cliValue || '' });
+        }
+    }
+    if (input.repoAlias !== undefined) {
+        const cliValue = normalizeAlias(input.repoAlias);
+        if (cliValue !== manifest.repoAlias) {
+            diff.push({ directive: 'repoAlias', manifestValue: manifest.repoAlias, cliValue: cliValue || '' });
+        }
+    }
+    if (input.embeddings !== undefined) {
+        const cliValue = input.embeddings ? 'true' : 'false';
+        if (cliValue !== manifest.embeddings) {
+            diff.push({ directive: 'embeddings', manifestValue: manifest.embeddings, cliValue });
+        }
+    }
+    return diff;
+}
+async function resolveDecision(policy, manifestPath, diff, stdinIsTTY, prompt) {
+    if (policy === 'update' || policy === 'keep')
+        return policy;
+    if (policy === 'error') {
+        throw new Error(`${formatMismatchHeader(manifestPath)}\n${formatDiff(diff)}`);
+    }
+    if (stdinIsTTY === undefined) {
+        throw new Error('TTY prompt branch requires concrete stdin.isTTY evidence.');
+    }
+    const interactive = stdinIsTTY;
+    if (!interactive) {
+        throw new Error(`${formatMismatchHeader(manifestPath)}\n${formatDiff(diff)}\n` +
+            'Non-interactive mode requires --sync-manifest-policy ask|update|keep|error.');
+    }
+    const promptFn = prompt || defaultPrompt;
+    return promptFn([
+        formatMismatchHeader(manifestPath),
+        formatDiff(diff),
+        'Choose: update (rewrite sync-manifest) or keep (continue without rewrite).',
+    ].join('\n'));
+}
+function mergeDirectivesForUpdate(manifest, input) {
+    const merged = { ...manifest };
+    if (input.extensions !== undefined) {
+        merged.extensions = normalizeExtensions(input.extensions);
+    }
+    if (input.repoAlias !== undefined) {
+        merged.repoAlias = normalizeAlias(input.repoAlias);
+    }
+    if (input.embeddings !== undefined) {
+        merged.embeddings = input.embeddings ? 'true' : 'false';
+    }
+    return merged;
+}
+function renderSyncManifest(scopeRules, directives) {
+    const lines = [...scopeRules];
+    if (directives.extensions)
+        lines.push(`@extensions=${directives.extensions}`);
+    if (directives.repoAlias)
+        lines.push(`@repoAlias=${directives.repoAlias}`);
+    if (directives.embeddings)
+        lines.push(`@embeddings=${directives.embeddings}`);
+    return `${lines.join('\n')}\n`;
+}
+function normalizeExtensions(raw) {
+    if (raw === undefined)
+        return undefined;
+    const parsed = parseExtensionList(raw);
+    return parsed.length > 0 ? parsed.join(',') : undefined;
+}
+function normalizeAlias(raw) {
+    if (raw === undefined)
+        return undefined;
+    return normalizeRepoAlias(raw);
+}
+function normalizeEmbeddings(raw) {
+    if (raw === undefined)
+        return undefined;
+    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.`);
+}
+function formatMismatchHeader(manifestPath) {
+    return `Explicit analyze options differ from sync manifest directives: ${manifestPath}`;
+}
+function formatDiff(diff) {
+    return diff
+        .map((entry) => `- @${entry.directive}: ${entry.manifestValue ?? '<unset>'} -> ${entry.cliValue}`)
+        .join('\n');
+}
+async function defaultPrompt(message) {
+    const rl = readline.createInterface({ input, output });
+    try {
+        const answer = await rl.question(`${message}\nUpdate sync-manifest now? [y/N] `);
+        return /^y(es)?$/i.test(answer.trim()) ? 'update' : 'keep';
+    }
+    finally {
+        rl.close();
+    }
+}
+function ensureConcreteManifestPath(manifestPath) {
+    const normalized = manifestPath.trim();
+    if (!normalized) {
+        throw new Error('Invalid placeholder manifest path: empty value.');
+    }
+    if (/placeholder/i.test(normalized) ||
+        /<\s*path\s*>/i.test(normalized) ||
+        /todo/i.test(normalized)) {
+        throw new Error(`Invalid placeholder manifest path: ${manifestPath}`);
+    }
+}

package/dist/cli/sync-manifest.test.d.ts

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