@ai-coders/context 0.4.0 → 0.5.0

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,11 @@ 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 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 +72,40 @@ 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
+});
 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 +125,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 +149,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);
@@ -168,6 +180,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 +209,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 +225,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,7 +340,7 @@ 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() {
@@ -271,6 +356,7 @@ async function runInteractive() {
                     { name: t('prompts.main.choice.scaffold'), value: 'scaffold' },
                     { name: t('prompts.main.choice.fill'), value: 'fill' },
                     { name: t('prompts.main.choice.plan'), value: 'plan' },
+                    { name: t('prompts.main.choice.syncAgents'), value: 'syncAgents' },
                     { name: t('prompts.main.choice.changeLanguage'), value: 'changeLanguage' },
                     { name: t('prompts.main.choice.exit'), value: 'exit' }
                 ]
@@ -290,9 +376,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 +428,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,67 +516,49 @@ 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
-        }
-    ]);
-    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';
-    }
-    const { provideApiKey } = await inquirer_1.default.prompt([
-        {
-            type: 'confirm',
-            name: 'provideApiKey',
-            message: t('prompts.fill.provideApiKey'),
-            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 apiKey;
-    if (provideApiKey) {
-        const apiKeyAnswer = await inquirer_1.default.prompt([
-            {
-                type: 'password',
-                name: 'apiKey',
-                message: t('prompts.fill.apiKey'),
-                mask: '*'
-            }
-        ]);
-        apiKey = apiKeyAnswer.apiKey.trim();
+    };
+    (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 { verbose } = await inquirer_1.default.prompt([
-        {
-            type: 'confirm',
-            name: 'verbose',
-            message: t('prompts.common.verbose'),
-            default: false
-        }
-    ]);
-    await fillService.run(resolvedRepo, {
-        output: outputDir,
-        prompt: promptPath,
-        limit: parsedLimit,
-        model,
-        provider,
-        apiKey,
-        verbose
-    });
 }
 async function runInteractivePlan() {
+    const defaults = await (0, prompts_1.detectSmartDefaults)();
+    // Always ask for plan name first
     const { planName } = await inquirer_1.default.prompt([
         {
             type: 'input',
@@ -447,6 +567,82 @@ async function runInteractivePlan() {
             default: 'new-plan'
         }
     ]);
+    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: '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'
+            }
+        ]);
+        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,
+                    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;
+        }
+        // Quick fill: use auto-detected LLM config
+        const llmConfig = await (0, prompts_1.promptLLMConfig)(t, { defaultModel: DEFAULT_MODEL, skipIfConfigured: true });
+        const summary = {
+            operation: 'plan',
+            repoPath: defaults.repoPath,
+            outputDir: defaults.outputDir,
+            provider: llmConfig.provider,
+            model: llmConfig.model,
+            apiKeySource: llmConfig.autoDetected ? 'env' : llmConfig.apiKey ? 'provided' : 'none',
+            options: {
+                'Plan Name': planName,
+                LSP: true,
+                'Dry Run': false
+            }
+        };
+        (0, prompts_1.displayConfigSummary)(summary, t);
+        const proceed = await (0, prompts_1.promptConfirmProceed)(t);
+        if (proceed) {
+            try {
+                await planService.scaffoldPlanIfNeeded(planName, defaults.outputDir, {});
+                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([
         {
@@ -485,6 +681,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,22 +691,53 @@ 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 configSummary = {
+            operation: 'plan',
+            repoPath,
+            outputDir,
+            provider: llmConfig.provider,
+            model: llmConfig.model,
+            apiKeySource: llmConfig.autoDetected ? 'env' : llmConfig.apiKey ? 'provided' : 'none',
+            options: {
+                'Plan Name': planName,
+                LSP: useLsp,
+                'Dry Run': dryRun
+            }
+        };
+        (0, prompts_1.displayConfigSummary)(configSummary, 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: summary || undefined
+                });
+                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;
     }
+    // Scaffold mode
     const { summary } = await inquirer_1.default.prompt([
         {
             type: 'input',
@@ -524,10 +753,12 @@ async function runInteractivePlan() {
             planName,
             outputDir: path.resolve(outputDir.trim() || defaultOutput),
             summary: summary || undefined,
-            verbose: false
+            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 +768,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 +869,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