@ai-coders/context 0.4.0 → 0.5.1

package/dist/index.js

@@ -47,8 +47,8 @@ exports.runLlmFill = runLlmFill;
 const commander_1 = require("commander");
 const path = __importStar(require("path"));
 const dotenv = __importStar(require("dotenv"));
-const chalk_1 = __importDefault(require("chalk"));
 const inquirer_1 = __importDefault(require("inquirer"));
+const theme_1 = require("./utils/theme");
 const planGenerator_1 = require("./generators/plans/planGenerator");
 const cliUI_1 = require("./utils/cliUI");
 const versionChecker_1 = require("./utils/versionChecker");
@@ -56,6 +56,13 @@ const i18n_1 = require("./utils/i18n");
 const initService_1 = require("./services/init/initService");
 const fillService_1 = require("./services/fill/fillService");
 const planService_1 = require("./services/plan/planService");
+const syncService_1 = require("./services/sync/syncService");
+const serve_1 = require("./services/serve");
+const mcp_1 = require("./services/mcp");
+const state_1 = require("./services/state");
+const update_1 = require("./services/update");
+const prompts_1 = require("./utils/prompts");
+const version_1 = require("./version");
 dotenv.config();
 const initialLocale = (0, i18n_1.detectLocale)(process.argv.slice(2), process.env.AI_CONTEXT_LANG);
 let currentLocale = initialLocale;
@@ -67,37 +74,44 @@ const localeLabelKeys = {
 };
 const program = new commander_1.Command();
 const ui = new cliUI_1.CLIInterface(t);
-const VERSION = '0.4.0';
-const PACKAGE_NAME = '@ai-coders/context';
-const DEFAULT_MODEL = 'x-ai/grok-4-fast';
+const DEFAULT_MODEL = 'gemini-3-flash-preview';
 const initService = new initService_1.InitService({
     ui,
     t,
-    version: VERSION
+    version: version_1.VERSION
 });
 const fillService = new fillService_1.FillService({
     ui,
     t,
-    version: VERSION,
+    version: version_1.VERSION,
     defaultModel: DEFAULT_MODEL
 });
 const planService = new planService_1.PlanService({
     ui,
     t,
-    version: VERSION,
+    version: version_1.VERSION,
     defaultModel: DEFAULT_MODEL
 });
+const syncService = new syncService_1.SyncService({
+    ui,
+    t,
+    version: version_1.VERSION
+});
+const updateService = new update_1.UpdateService({
+    ui,
+    t
+});
 program
     .name('ai-context')
     .description(t('cli.description'))
-    .version(VERSION);
+    .version(version_1.VERSION);
 program.option('-l, --lang <locale>', t('global.options.lang'), initialLocale);
 let versionCheckPromise = null;
 function scheduleVersionCheck(force = false) {
     if (!versionCheckPromise || force) {
         versionCheckPromise = (0, versionChecker_1.checkForUpdates)({
-            packageName: PACKAGE_NAME,
-            currentVersion: VERSION,
+            packageName: version_1.PACKAGE_NAME,
+            currentVersion: version_1.VERSION,
             ui,
             t,
             force
@@ -117,6 +131,7 @@ program
     .option('--exclude <patterns...>', t('commands.init.options.exclude'))
     .option('--include <patterns...>', t('commands.init.options.include'))
     .option('-v, --verbose', t('commands.init.options.verbose'))
+    .option('--no-semantic', t('commands.init.options.noSemantic'))
     .action(async (repoPath, type, options) => {
     try {
         await initService.run(repoPath, type, options);
@@ -140,6 +155,9 @@ program
     .option('--exclude <patterns...>', t('commands.fill.options.exclude'))
     .option('--include <patterns...>', t('commands.fill.options.include'))
     .option('-v, --verbose', t('commands.fill.options.verbose'))
+    .option('--no-semantic', t('commands.fill.options.noSemantic'))
+    .option('--languages <langs>', t('commands.fill.options.languages'))
+    .option('--use-lsp', t('commands.fill.options.useLsp'))
     .action(async (repoPath, options) => {
     try {
         await fillService.run(repoPath, options);
@@ -149,6 +167,64 @@ program
         process.exit(1);
     }
 });
+program
+    .command('update')
+    .description('Analyze code changes and update affected documentation')
+    .argument('[repo-path]', 'Repository path to analyze', '.')
+    .option('-o, --output <dir>', 'Output directory', './.context')
+    .option('--days <number>', 'Days to look back for changes', (v) => parseInt(v, 10), 30)
+    .option('--dry-run', 'Show what would be updated without making changes')
+    .option('--no-git', 'Use mtime instead of git for change detection')
+    .option('-k, --api-key <key>', 'API key for LLM provider')
+    .option('-m, --model <model>', 'Model to use', DEFAULT_MODEL)
+    .option('-p, --provider <provider>', 'LLM provider')
+    .option('--base-url <url>', 'Custom base URL for API')
+    .option('-v, --verbose', 'Verbose output')
+    .action(async (repoPath, options) => {
+    try {
+        const outputDir = path.resolve(options.output || './.context');
+        const analysis = await updateService.analyze(repoPath, {
+            output: options.output,
+            days: options.days,
+            useGit: options.git !== false,
+            verbose: options.verbose
+        });
+        updateService.displayAnalysis(analysis);
+        if (options.dryRun) {
+            return;
+        }
+        const filesToUpdate = updateService.getFilesToUpdate(analysis);
+        if (filesToUpdate.length === 0) {
+            return;
+        }
+        const { proceed } = await inquirer_1.default.prompt([{
+                type: 'confirm',
+                name: 'proceed',
+                message: `Update ${filesToUpdate.length} document(s)?`,
+                default: true
+            }]);
+        if (!proceed) {
+            return;
+        }
+        // Run fill on affected docs
+        // Convert absolute paths to relative paths from the output directory
+        await fillService.run(repoPath, {
+            output: options.output,
+            include: filesToUpdate.map(f => path.relative(outputDir, f)),
+            model: options.model,
+            provider: options.provider,
+            apiKey: options.apiKey,
+            baseUrl: options.baseUrl,
+            verbose: options.verbose,
+            semantic: true
+        });
+        ui.displaySuccess('Documentation updated!');
+    }
+    catch (error) {
+        ui.displayError('Failed to update documentation', error);
+        process.exit(1);
+    }
+});
 program
     .command('plan')
     .description(t('commands.plan.description'))
@@ -168,6 +244,8 @@ program
     .option('--include <patterns...>', t('commands.plan.options.include'))
     .option('--exclude <patterns...>', t('commands.plan.options.exclude'))
     .option('-v, --verbose', t('commands.plan.options.verbose'))
+    .option('--no-semantic', t('commands.plan.options.noSemantic'))
+    .option('--no-lsp', t('commands.plan.options.noLsp'))
     .action(async (planName, rawOptions) => {
     const outputDir = path.resolve(rawOptions.output || './.context');
     if (rawOptions.fill) {
@@ -195,10 +273,12 @@ program
             title: rawOptions.title,
             summary: rawOptions.summary,
             force: Boolean(rawOptions.force),
-            verbose: Boolean(rawOptions.verbose)
+            verbose: Boolean(rawOptions.verbose),
+            semantic: rawOptions.semantic !== false,
+            projectPath: rawOptions.repo ? path.resolve(rawOptions.repo) : path.resolve(rawOptions.output || './.context', '..')
         });
         ui.updateSpinner(t('spinner.plan.created'), 'success');
-        ui.displaySuccess(t('success.plan.createdAt', { path: chalk_1.default.cyan(result.relativePath) }));
+        ui.displaySuccess(t('success.plan.createdAt', { path: theme_1.colors.accent(result.relativePath) }));
     }
     catch (error) {
         ui.updateSpinner(t('spinner.plan.creationFailed'), 'fail');
@@ -209,6 +289,75 @@ program
         ui.stopSpinner();
     }
 });
+program
+    .command('sync-agents')
+    .description(t('commands.sync.description'))
+    .option('-s, --source <dir>', t('commands.sync.options.source'), './.context/agents')
+    .option('-t, --target <paths...>', t('commands.sync.options.target'))
+    .option('-m, --mode <type>', t('commands.sync.options.mode'), 'symlink')
+    .option('-p, --preset <name>', t('commands.sync.options.preset'))
+    .option('--force', t('commands.sync.options.force'))
+    .option('--dry-run', t('commands.sync.options.dryRun'))
+    .option('-v, --verbose', t('commands.sync.options.verbose'))
+    .action(async (options) => {
+    try {
+        await syncService.run(options);
+    }
+    catch (error) {
+        ui.displayError(t('errors.sync.failed'), error);
+        process.exit(1);
+    }
+});
+program
+    .command('serve')
+    .description('Start passthrough server for external AI agents (stdin/stdout JSON)')
+    .option('-r, --repo-path <path>', 'Default repository path for tools')
+    .option('-f, --format <format>', 'Output format: json or jsonl', 'jsonl')
+    .option('-v, --verbose', 'Enable verbose logging to stderr')
+    .action(async (options) => {
+    const service = new serve_1.ServeService({
+        repoPath: options.repoPath,
+        format: options.format,
+        verbose: options.verbose
+    });
+    try {
+        await service.run();
+    }
+    catch (error) {
+        if (options.verbose) {
+            process.stderr.write(`[serve] Error: ${error}\n`);
+        }
+        process.exit(1);
+    }
+});
+program
+    .command('mcp')
+    .description('Start MCP (Model Context Protocol) server for Claude Code integration')
+    .option('-r, --repo-path <path>', 'Default repository path for tools')
+    .option('-v, --verbose', 'Enable verbose logging to stderr')
+    .action(async (options) => {
+    try {
+        const server = await (0, mcp_1.startMCPServer)({
+            repoPath: options.repoPath,
+            verbose: options.verbose
+        });
+        // Handle graceful shutdown
+        process.on('SIGINT', async () => {
+            await server.stop();
+            process.exit(0);
+        });
+        process.on('SIGTERM', async () => {
+            await server.stop();
+            process.exit(0);
+        });
+    }
+    catch (error) {
+        if (options.verbose) {
+            process.stderr.write(`[mcp] Error: ${error}\n`);
+        }
+        process.exit(1);
+    }
+});
 async function runInit(repoPath, type, rawOptions) {
     await initService.run(repoPath, type, rawOptions);
 }
@@ -255,27 +404,150 @@ async function selectLocale(showWelcome) {
     currentLocale = normalizedLocale;
     translateFn = (0, i18n_1.createTranslator)(normalizedLocale);
     if (showWelcome) {
-        ui.displayWelcome(VERSION);
+        ui.displayWelcome(version_1.VERSION);
     }
 }
 async function runInteractive() {
     await selectLocale(true);
-    let exitRequested = false;
-    while (!exitRequested) {
+    const projectPath = process.cwd();
+    const detector = new state_1.StateDetector({ projectPath });
+    const result = await detector.detect();
+    // Display project info
+    console.log('');
+    ui.displayInfo(`${version_1.PACKAGE_NAME} v${version_1.VERSION}`, `Project: ${projectPath}`);
+    // Show state-specific information
+    switch (result.state) {
+        case 'new':
+            console.log(theme_1.colors.secondaryDim('  No context documentation found.\n'));
+            break;
+        case 'unfilled':
+            console.log(theme_1.colors.secondaryDim(`  Context: ${result.details.unfilledFiles} files need filling\n`));
+            break;
+        case 'outdated':
+            console.log(theme_1.colors.warning(`  Code modified ${result.details.daysBehind} day(s) ago (docs not updated)\n`));
+            break;
+        case 'ready':
+            console.log(theme_1.colors.success(`  Context: ${result.details.totalFiles} docs, all up to date\n`));
+            break;
+    }
+    // Handle state-based flow
+    if (result.state === 'new') {
         const { action } = await inquirer_1.default.prompt([
             {
                 type: 'list',
                 name: 'action',
                 message: t('prompts.main.action'),
                 choices: [
-                    { name: t('prompts.main.choice.scaffold'), value: 'scaffold' },
+                    { name: t('prompts.main.choice.create'), value: 'create' },
+                    { name: t('prompts.main.choice.exit'), value: 'exit' }
+                ]
+            }
+        ]);
+        if (action === 'create') {
+            // Run init + fill automatically
+            await runQuickSetup(projectPath);
+        }
+        return;
+    }
+    if (result.state === 'unfilled') {
+        const { action } = await inquirer_1.default.prompt([
+            {
+                type: 'list',
+                name: 'action',
+                message: t('prompts.main.unfilledPrompt', { count: result.details.unfilledFiles }),
+                choices: [
                     { name: t('prompts.main.choice.fill'), value: 'fill' },
-                    { name: t('prompts.main.choice.plan'), value: 'plan' },
-                    { name: t('prompts.main.choice.changeLanguage'), value: 'changeLanguage' },
+                    { name: t('prompts.main.choice.moreOptions'), value: 'menu' },
                     { name: t('prompts.main.choice.exit'), value: 'exit' }
                 ]
             }
         ]);
+        if (action === 'fill') {
+            await runInteractiveLlmFill();
+            return;
+        }
+        else if (action === 'menu') {
+            await runFullMenu();
+        }
+        return;
+    }
+    // For 'ready' or 'outdated' states, show full menu
+    await runFullMenu(result.state === 'outdated' ? result.details.daysBehind : undefined);
+}
+async function runQuickSetup(projectPath) {
+    const { confirm } = await inquirer_1.default.prompt([
+        {
+            type: 'confirm',
+            name: 'confirm',
+            message: t('prompts.setup.confirmContinue'),
+            default: true
+        }
+    ]);
+    if (!confirm) {
+        return;
+    }
+    // Run init
+    ui.startSpinner(t('spinner.setup.creatingStructure'));
+    try {
+        const initService = new initService_1.InitService({ ui, t, version: version_1.VERSION });
+        await initService.run(projectPath, 'both', {
+            semantic: true
+        });
+        ui.stopSpinner();
+    }
+    catch (error) {
+        ui.stopSpinner();
+        ui.displayError('Failed to create structure', error);
+        return;
+    }
+    // Prompt for LLM config and run fill
+    const llmConfig = await (0, prompts_1.promptLLMConfig)(t);
+    if (!llmConfig) {
+        ui.displayInfo(t('info.setup.incomplete.title'), t('info.setup.incomplete.detail'));
+        return;
+    }
+    ui.startSpinner(t('spinner.setup.fillingDocs'));
+    try {
+        const fillService = new fillService_1.FillService({ ui, t, version: version_1.VERSION, defaultModel: DEFAULT_MODEL });
+        await fillService.run(projectPath, {
+            model: llmConfig.model,
+            provider: llmConfig.provider,
+            apiKey: llmConfig.apiKey,
+            baseUrl: llmConfig.baseUrl,
+            verbose: false,
+            semantic: true
+        });
+        ui.stopSpinner();
+        ui.displaySuccess(t('success.setup.docsCreated'));
+        console.log(theme_1.colors.secondaryDim(`  ${t('info.setup.reviewFiles')}`));
+    }
+    catch (error) {
+        ui.stopSpinner();
+        ui.displayError('Failed to fill documentation', error);
+    }
+}
+async function runFullMenu(daysBehind) {
+    let exitRequested = false;
+    while (!exitRequested) {
+        const updateLabel = daysBehind
+            ? t('prompts.main.choice.updateDocsBehind', { daysBehind })
+            : t('prompts.main.choice.updateDocs');
+        const choices = [
+            { name: t('prompts.main.choice.plan'), value: 'plan' },
+            { name: updateLabel, value: 'fill' },
+            { name: t('prompts.main.choice.syncAgents'), value: 'syncAgents' },
+            { name: t('prompts.main.choice.rescaffold'), value: 'scaffold' },
+            { name: t('prompts.main.choice.changeLanguage'), value: 'changeLanguage' },
+            { name: t('prompts.main.choice.exit'), value: 'exit' }
+        ];
+        const { action } = await inquirer_1.default.prompt([
+            {
+                type: 'list',
+                name: 'action',
+                message: t('prompts.main.action'),
+                choices
+            }
+        ]);
         if (action === 'changeLanguage') {
             await selectLocale(true);
             continue;
@@ -290,9 +562,12 @@ async function runInteractive() {
         else if (action === 'fill') {
             await runInteractiveLlmFill();
         }
-        else {
+        else if (action === 'plan') {
             await runInteractivePlan();
         }
+        else if (action === 'syncAgents') {
+            await runInteractiveSync();
+        }
         ui.displayInfo(t('info.interactive.returning.title'), t('info.interactive.returning.detail'));
     }
     ui.displaySuccess(t('success.interactive.goodbye'));
@@ -339,16 +614,65 @@ async function runInteractiveScaffold() {
     ]);
     await runInit(resolvedRepo, scaffoldType, {
         output: outputDir,
-        verbose
+        verbose,
+        semantic: true
     });
 }
 async function runInteractiveLlmFill() {
+    const defaults = await (0, prompts_1.detectSmartDefaults)();
+    const interactiveMode = await (0, prompts_1.promptInteractiveMode)(t);
+    if (interactiveMode === 'quick') {
+        // Quick mode: minimal prompts with smart defaults
+        const { confirmRepo } = await inquirer_1.default.prompt([
+            {
+                type: 'confirm',
+                name: 'confirmRepo',
+                message: `${t('prompts.quick.confirmRepo')} (${defaults.repoPath})`,
+                default: true
+            }
+        ]);
+        const resolvedRepo = confirmRepo ? defaults.repoPath : (await inquirer_1.default.prompt([
+            { type: 'input', name: 'repoPath', message: t('prompts.fill.repoPath'), default: defaults.repoPath }
+        ])).repoPath;
+        // Get LLM config (auto-detected or prompt for API key)
+        const llmConfig = await (0, prompts_1.promptLLMConfig)(t, { defaultModel: DEFAULT_MODEL, skipIfConfigured: true });
+        // Build summary
+        const summary = {
+            operation: 'fill',
+            repoPath: resolvedRepo,
+            outputDir: defaults.outputDir,
+            provider: llmConfig.provider,
+            model: llmConfig.model,
+            apiKeySource: llmConfig.autoDetected ? 'env' : llmConfig.apiKey ? 'provided' : 'none',
+            options: {
+                Semantic: true,
+                Languages: defaults.detectedLanguages.join(', '),
+                LSP: false
+            }
+        };
+        (0, prompts_1.displayConfigSummary)(summary, t);
+        const proceed = await (0, prompts_1.promptConfirmProceed)(t);
+        if (proceed) {
+            await fillService.run(resolvedRepo, {
+                output: defaults.outputDir,
+                model: llmConfig.model,
+                provider: llmConfig.provider,
+                apiKey: llmConfig.apiKey,
+                verbose: false,
+                semantic: true,
+                languages: defaults.detectedLanguages,
+                useLsp: false
+            });
+        }
+        return;
+    }
+    // Advanced mode: full configuration
     const { repoPath } = await inquirer_1.default.prompt([
         {
             type: 'input',
             name: 'repoPath',
             message: t('prompts.fill.repoPath'),
-            default: process.cwd()
+            default: defaults.repoPath
         }
     ]);
     const resolvedRepo = path.resolve(repoPath.trim() || '.');
@@ -378,75 +702,154 @@ async function runInteractiveLlmFill() {
     ]);
     const limitValue = limit ? parseInt(limit, 10) : undefined;
     const parsedLimit = Number.isNaN(limitValue) ? undefined : limitValue;
-    const { specifyModel } = await inquirer_1.default.prompt([
-        {
-            type: 'confirm',
-            name: 'specifyModel',
-            message: t('prompts.fill.overrideModel'),
-            default: false
+    // Use shared LLM prompt helper
+    const llmConfig = await (0, prompts_1.promptLLMConfig)(t, { defaultModel: DEFAULT_MODEL, skipIfConfigured: false });
+    // Use shared analysis options prompt
+    const analysisOptions = await (0, prompts_1.promptAnalysisOptions)(t, {
+        languages: defaults.detectedLanguages,
+        useLsp: false
+    });
+    // Show summary before execution
+    const summary = {
+        operation: 'fill',
+        repoPath: resolvedRepo,
+        outputDir,
+        provider: llmConfig.provider,
+        model: llmConfig.model,
+        apiKeySource: llmConfig.autoDetected ? 'env' : llmConfig.apiKey ? 'provided' : 'none',
+        options: {
+            Semantic: analysisOptions.semantic,
+            Languages: analysisOptions.languages?.join(', ') || 'none',
+            LSP: analysisOptions.useLsp,
+            Verbose: analysisOptions.verbose,
+            ...(parsedLimit ? { Limit: String(parsedLimit) } : {})
         }
-    ]);
-    let provider;
-    let model;
-    if (specifyModel) {
-        const modelAnswer = await inquirer_1.default.prompt([
-            {
-                type: 'input',
-                name: 'model',
-                message: t('prompts.fill.model'),
-                default: DEFAULT_MODEL
-            }
-        ]);
-        model = modelAnswer.model.trim();
-        provider = 'openrouter';
+    };
+    (0, prompts_1.displayConfigSummary)(summary, t);
+    const proceed = await (0, prompts_1.promptConfirmProceed)(t);
+    if (proceed) {
+        await fillService.run(resolvedRepo, {
+            output: outputDir,
+            prompt: promptPath,
+            limit: parsedLimit,
+            model: llmConfig.model,
+            provider: llmConfig.provider,
+            apiKey: llmConfig.apiKey,
+            verbose: analysisOptions.verbose,
+            semantic: analysisOptions.semantic,
+            languages: analysisOptions.languages,
+            useLsp: analysisOptions.useLsp
+        });
     }
-    const { provideApiKey } = await inquirer_1.default.prompt([
+}
+function generatePlanSlug(goal) {
+    return goal
+        .toLowerCase()
+        .replace(/[àáâãäå]/g, 'a')
+        .replace(/[èéêë]/g, 'e')
+        .replace(/[ìíîï]/g, 'i')
+        .replace(/[òóôõö]/g, 'o')
+        .replace(/[ùúûü]/g, 'u')
+        .replace(/[ç]/g, 'c')
+        .replace(/[ñ]/g, 'n')
+        .replace(/[^a-z0-9\s-]/g, '')
+        .trim()
+        .replace(/\s+/g, '-')
+        .replace(/-+/g, '-')
+        .substring(0, 50)
+        .replace(/-$/, '') || 'new-plan';
+}
+async function runInteractivePlan() {
+    const defaults = await (0, prompts_1.detectSmartDefaults)();
+    // Ask what should be planned
+    const { planGoal } = await inquirer_1.default.prompt([
         {
-            type: 'confirm',
-            name: 'provideApiKey',
-            message: t('prompts.fill.provideApiKey'),
-            default: false
+            type: 'input',
+            name: 'planGoal',
+            message: t('prompts.plan.goal'),
+            validate: (input) => input.trim().length > 0 || 'Please describe what should be planned'
         }
     ]);
-    let apiKey;
-    if (provideApiKey) {
-        const apiKeyAnswer = await inquirer_1.default.prompt([
+    const planName = generatePlanSlug(planGoal);
+    const planSummary = planGoal;
+    const interactiveMode = await (0, prompts_1.promptInteractiveMode)(t);
+    if (interactiveMode === 'quick') {
+        // Quick mode: choose scaffold or fill with defaults
+        const { action } = await inquirer_1.default.prompt([
             {
-                type: 'password',
-                name: 'apiKey',
-                message: t('prompts.fill.apiKey'),
-                mask: '*'
+                type: 'list',
+                name: 'action',
+                message: t('prompts.plan.mode'),
+                choices: [
+                    { name: t('prompts.plan.modeScaffold'), value: 'scaffold' },
+                    { name: t('prompts.plan.modeFill'), value: 'fill' }
+                ],
+                default: 'scaffold'
             }
         ]);
-        apiKey = apiKeyAnswer.apiKey.trim();
-    }
-    const { verbose } = await inquirer_1.default.prompt([
-        {
-            type: 'confirm',
-            name: 'verbose',
-            message: t('prompts.common.verbose'),
-            default: false
+        if (action === 'scaffold') {
+            // Quick scaffold: just create the template
+            const generator = new planGenerator_1.PlanGenerator();
+            ui.startSpinner(t('spinner.plan.creating'));
+            try {
+                const result = await generator.generatePlan({
+                    planName,
+                    summary: planSummary,
+                    outputDir: defaults.outputDir,
+                    verbose: false,
+                    semantic: true,
+                    projectPath: defaults.repoPath
+                });
+                ui.updateSpinner(t('spinner.plan.created'), 'success');
+                ui.displaySuccess(t('success.plan.createdAt', { path: theme_1.colors.accent(result.relativePath) }));
+            }
+            catch (error) {
+                ui.updateSpinner(t('spinner.plan.creationFailed'), 'fail');
+                ui.displayError(t('errors.plan.creationFailed'), error);
+            }
+            finally {
+                ui.stopSpinner();
+            }
+            return;
         }
-    ]);
-    await fillService.run(resolvedRepo, {
-        output: outputDir,
-        prompt: promptPath,
-        limit: parsedLimit,
-        model,
-        provider,
-        apiKey,
-        verbose
-    });
-}
-async function runInteractivePlan() {
-    const { planName } = await inquirer_1.default.prompt([
-        {
-            type: 'input',
-            name: 'planName',
-            message: t('prompts.plan.name'),
-            default: 'new-plan'
+        // Quick fill: use auto-detected LLM config
+        const llmConfig = await (0, prompts_1.promptLLMConfig)(t, { defaultModel: DEFAULT_MODEL, skipIfConfigured: true });
+        const configSummary = {
+            operation: 'plan',
+            repoPath: defaults.repoPath,
+            outputDir: defaults.outputDir,
+            provider: llmConfig.provider,
+            model: llmConfig.model,
+            apiKeySource: llmConfig.autoDetected ? 'env' : llmConfig.apiKey ? 'provided' : 'none',
+            options: {
+                Goal: planSummary,
+                'File': `${planName}.md`,
+                LSP: true,
+                'Dry Run': false
+            }
+        };
+        (0, prompts_1.displayConfigSummary)(configSummary, t);
+        const proceed = await (0, prompts_1.promptConfirmProceed)(t);
+        if (proceed) {
+            try {
+                await planService.scaffoldPlanIfNeeded(planName, defaults.outputDir, { summary: planSummary });
+                await planService.fillPlan(planName, {
+                    output: defaults.outputDir,
+                    repo: defaults.repoPath,
+                    dryRun: false,
+                    provider: llmConfig.provider,
+                    model: llmConfig.model,
+                    apiKey: llmConfig.apiKey,
+                    lsp: true
+                });
+            }
+            catch (error) {
+                ui.displayError(t('errors.plan.fillFailed'), error);
+            }
         }
-    ]);
+        return;
+    }
+    // Advanced mode: full configuration
     const defaultOutput = path.resolve(process.cwd(), '.context');
     const { mode } = await inquirer_1.default.prompt([
         {
@@ -469,14 +872,6 @@ async function runInteractivePlan() {
         }
     ]);
     if (mode === 'fill') {
-        const { summary } = await inquirer_1.default.prompt([
-            {
-                type: 'input',
-                name: 'summary',
-                message: t('prompts.plan.summary'),
-                filter: (value) => value.trim()
-            }
-        ]);
         const { repoPath } = await inquirer_1.default.prompt([
             {
                 type: 'input',
@@ -485,6 +880,8 @@ async function runInteractivePlan() {
                 default: process.cwd()
             }
         ]);
+        // Use shared LLM prompt helper
+        const llmConfig = await (0, prompts_1.promptLLMConfig)(t, { defaultModel: DEFAULT_MODEL, skipIfConfigured: false });
         const { dryRun } = await inquirer_1.default.prompt([
             {
                 type: 'confirm',
@@ -493,41 +890,67 @@ async function runInteractivePlan() {
                 default: true
             }
         ]);
-        try {
-            const resolvedOutput = path.resolve(outputDir.trim() || defaultOutput);
-            await planService.scaffoldPlanIfNeeded(planName, resolvedOutput, {
-                summary: summary || undefined
-            });
-            await planService.fillPlan(planName, {
-                output: resolvedOutput,
-                repo: repoPath,
-                dryRun
-            });
-        }
-        catch (error) {
-            ui.displayError(t('errors.plan.fillFailed'), error);
+        const { useLsp } = await inquirer_1.default.prompt([
+            {
+                type: 'confirm',
+                name: 'useLsp',
+                message: t('prompts.plan.useLsp'),
+                default: true
+            }
+        ]);
+        // Show summary before execution
+        const advancedConfigSummary = {
+            operation: 'plan',
+            repoPath,
+            outputDir,
+            provider: llmConfig.provider,
+            model: llmConfig.model,
+            apiKeySource: llmConfig.autoDetected ? 'env' : llmConfig.apiKey ? 'provided' : 'none',
+            options: {
+                Goal: planSummary,
+                'File': `${planName}.md`,
+                LSP: useLsp,
+                'Dry Run': dryRun
+            }
+        };
+        (0, prompts_1.displayConfigSummary)(advancedConfigSummary, t);
+        const proceed = await (0, prompts_1.promptConfirmProceed)(t);
+        if (proceed) {
+            try {
+                const resolvedOutput = path.resolve(outputDir.trim() || defaultOutput);
+                await planService.scaffoldPlanIfNeeded(planName, resolvedOutput, {
+                    summary: planSummary
+                });
+                await planService.fillPlan(planName, {
+                    output: resolvedOutput,
+                    repo: repoPath,
+                    dryRun,
+                    provider: llmConfig.provider,
+                    model: llmConfig.model,
+                    apiKey: llmConfig.apiKey,
+                    lsp: useLsp
+                });
+            }
+            catch (error) {
+                ui.displayError(t('errors.plan.fillFailed'), error);
+            }
         }
         return;
     }
-    const { summary } = await inquirer_1.default.prompt([
-        {
-            type: 'input',
-            name: 'summary',
-            message: t('prompts.plan.summary'),
-            filter: (value) => value.trim()
-        }
-    ]);
+    // Scaffold mode - use planSummary from goal input
     const generator = new planGenerator_1.PlanGenerator();
     ui.startSpinner(t('spinner.plan.creating'));
     try {
         const result = await generator.generatePlan({
             planName,
             outputDir: path.resolve(outputDir.trim() || defaultOutput),
-            summary: summary || undefined,
-            verbose: false
+            summary: planSummary,
+            verbose: false,
+            semantic: true,
+            projectPath: path.resolve(outputDir.trim() || defaultOutput, '..')
         });
         ui.updateSpinner(t('spinner.plan.created'), 'success');
-        ui.displaySuccess(t('success.plan.createdAt', { path: chalk_1.default.cyan(result.relativePath) }));
+        ui.displaySuccess(t('success.plan.createdAt', { path: theme_1.colors.accent(result.relativePath) }));
     }
     catch (error) {
         ui.updateSpinner(t('spinner.plan.creationFailed'), 'fail');
@@ -537,6 +960,82 @@ async function runInteractivePlan() {
         ui.stopSpinner();
     }
 }
+async function runInteractiveSync() {
+    const defaults = await (0, prompts_1.detectSmartDefaults)();
+    const defaultSource = path.resolve(defaults.repoPath, '.context/agents');
+    // Simplified: single prompt for target selection with common presets
+    const { quickTarget } = await inquirer_1.default.prompt([
+        {
+            type: 'list',
+            name: 'quickTarget',
+            message: t('prompts.sync.quickTarget'),
+            choices: [
+                { name: t('prompts.sync.quickTarget.common'), value: 'common' },
+                { name: t('prompts.sync.quickTarget.claude'), value: 'claude' },
+                { name: t('prompts.sync.quickTarget.all'), value: 'all' },
+                { name: t('prompts.sync.quickTarget.custom'), value: 'custom' }
+            ],
+            default: 'common'
+        }
+    ]);
+    let preset;
+    let target;
+    let sourcePath = defaultSource;
+    if (quickTarget === 'custom') {
+        // Custom path: ask for source and target
+        const answers = await inquirer_1.default.prompt([
+            {
+                type: 'input',
+                name: 'sourcePath',
+                message: t('prompts.sync.source'),
+                default: defaultSource
+            },
+            {
+                type: 'input',
+                name: 'customPath',
+                message: t('prompts.sync.customPath')
+            }
+        ]);
+        sourcePath = answers.sourcePath;
+        target = [answers.customPath];
+    }
+    else if (quickTarget === 'common') {
+        // Common: Claude + GitHub - use explicit target paths instead of preset
+        target = [
+            path.resolve(defaults.repoPath, '.claude/agents'),
+            path.resolve(defaults.repoPath, '.github/agents')
+        ];
+    }
+    else {
+        preset = quickTarget;
+    }
+    // Show summary
+    const summary = {
+        operation: 'sync',
+        repoPath: sourcePath,
+        options: {
+            Target: quickTarget === 'custom' ? (target?.[0] || 'custom') : quickTarget,
+            Mode: 'symlink'
+        }
+    };
+    (0, prompts_1.displayConfigSummary)(summary, t);
+    const proceed = await (0, prompts_1.promptConfirmProceed)(t);
+    if (proceed) {
+        try {
+            await syncService.run({
+                source: sourcePath,
+                mode: 'symlink',
+                preset: preset,
+                target,
+                force: false,
+                dryRun: false
+            });
+        }
+        catch (error) {
+            ui.displayError(t('errors.sync.failed'), error);
+        }
+    }
+}
 function filterOutLocaleArgs(args) {
     const filtered = [];
     for (let index = 0; index < args.length; index += 1) {
@@ -562,10 +1061,43 @@ async function main() {
     }
     await program.parseAsync(process.argv);
 }
+/**
+ * Check if an error is from user interrupt (Ctrl+C)
+ */
+function isUserInterrupt(error) {
+    if (error instanceof Error) {
+        // Inquirer's ExitPromptError when user presses Ctrl+C
+        if (error.name === 'ExitPromptError')
+            return true;
+        // Check message patterns
+        if (error.message.includes('force closed'))
+            return true;
+        if (error.message.includes('User force closed'))
+            return true;
+    }
+    return false;
+}
+/**
+ * Handle graceful exit
+ */
+function handleGracefulExit() {
+    console.log('');
+    ui.displaySuccess(t('success.interactive.goodbye'));
+    process.exit(0);
+}
+// Handle SIGINT (Ctrl+C) at process level
+process.on('SIGINT', () => {
+    handleGracefulExit();
+});
 if (require.main === module) {
     main().catch(error => {
-        ui.displayError(t('errors.cli.executionFailed'), error);
-        process.exit(1);
+        if (isUserInterrupt(error)) {
+            handleGracefulExit();
+        }
+        else {
+            ui.displayError(t('errors.cli.executionFailed'), error);
+            process.exit(1);
+        }
     });
 }
 //# sourceMappingURL=index.js.map