@snapcommit/cli 3.10.0 → 3.11.0

package/dist/commands/autopilot.js

@@ -0,0 +1,443 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.autopilotCommand = autopilotCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const auth_1 = require("../lib/auth");
+const git_1 = require("../utils/git");
+const ui_1 = require("../utils/ui");
+const prompt_1 = require("../utils/prompt");
+const conflict_1 = require("./conflict");
+const commit_1 = require("./commit");
+const quick_1 = require("./quick");
+const memory_1 = require("../utils/memory");
+const WORKFLOWS = [
+    {
+        id: 'conflict-crusher',
+        name: 'Conflict Crusher',
+        headline: 'Resolve nasty merge conflicts with AI — fast.',
+        description: 'Diagnose merge conflicts, run the AI conflict wizard, and guide you through the final checks so you can finish the merge with confidence.',
+        idealFor: ['merge commits', 'rebases', 'cherry-picks'],
+        prerequisites: ['Repository has merge conflicts (status shows "both modified")'],
+        steps: [
+            {
+                id: 'scan',
+                title: 'Scan for conflicts',
+                description: 'Review git status and list conflicted files.',
+                action: async (ctx) => {
+                    const conflicts = getConflictedFiles();
+                    if (conflicts.length === 0) {
+                        (0, ui_1.displayWarning)('No merge conflicts detected.', [
+                            'If you just merged, run `git status` to double-check.',
+                            'You can still run the wizard, but it may exit early.',
+                        ]);
+                    }
+                    else {
+                        ctx.recordInsight('conflictsBefore', conflicts);
+                        (0, ui_1.displayInfo)('Conflicted files detected', conflicts);
+                    }
+                },
+            },
+            {
+                id: 'ai-resolution',
+                title: 'Run AI conflict resolution',
+                description: 'Launch the AI-powered conflict wizard. It will attempt to resolve all conflicts automatically and only fall back to manual guidance if needed.',
+                action: async () => {
+                    await (0, conflict_1.conflictCommand)();
+                },
+            },
+            {
+                id: 'verify',
+                title: 'Verify conflicts are resolved',
+                description: 'Double-check that no conflicted files remain.',
+                action: async (ctx) => {
+                    const remaining = getConflictedFiles();
+                    if (remaining.length === 0) {
+                        ctx.recordInsight('conflictsAfter', 'None 🎉');
+                        (0, ui_1.displaySuccess)('All conflicts resolved!', [
+                            'Run your tests and finish the merge when you are ready.',
+                        ]);
+                    }
+                    else {
+                        ctx.recordInsight('conflictsAfter', `${remaining.length} remaining`);
+                        (0, ui_1.displayWarning)('Conflicts still remain.', remaining);
+                    }
+                },
+            },
+            {
+                id: 'post-merge',
+                title: 'Optional: run safety checks',
+                description: 'Run tests or lint to ensure the merge is safe before committing.',
+                skippable: true,
+                action: async (ctx) => {
+                    const defaultCommand = getPreferredTestCommand();
+                    const shouldRun = ctx.autoContinue ||
+                        (await (0, prompt_1.promptConfirm)('Run project tests now?', Boolean(defaultCommand)));
+                    if (!shouldRun) {
+                        ctx.recordInsight('postMergeChecks', 'Skipped');
+                        return;
+                    }
+                    const command = ctx.autoContinue
+                        ? defaultCommand || ''
+                        : await (0, prompt_1.promptInput)('Command to run', defaultCommand || 'npm test');
+                    if (!command) {
+                        ctx.recordInsight('postMergeChecks', 'Skipped (no command)');
+                        return;
+                    }
+                    try {
+                        await runShellCommand(command);
+                        (0, memory_1.rememberPreference)('autopilot', 'testCommand', command);
+                        ctx.recordInsight('postMergeChecks', `Passed (${command})`);
+                        (0, ui_1.displaySuccess)('Tests completed successfully.');
+                    }
+                    catch (error) {
+                        ctx.recordInsight('postMergeChecks', `Failed (${command})`);
+                        (0, ui_1.displayError)('Test command failed.', [
+                            error.message,
+                            'Fix the failures and re-run the command.',
+                        ]);
+                    }
+                },
+            },
+        ],
+    },
+    {
+        id: 'release-ready',
+        name: 'Release Readiness',
+        headline: 'Stage, test, and craft the perfect release commit.',
+        description: 'Stage changes, run automated checks, generate an AI commit message, and prepare to open a pull request.',
+        idealFor: ['release branches', 'end-of-day handoff', 'pre-PR polish'],
+        prerequisites: ['Project builds and tests locally', 'Authentication configured'],
+        steps: [
+            {
+                id: 'status',
+                title: 'Assess working tree',
+                description: 'Check for staged/unstaged files and current branch.',
+                action: async (ctx) => {
+                    const status = (0, git_1.getGitStatus)();
+                    const branch = (0, git_1.getCurrentBranch)();
+                    ctx.recordInsight('branch', branch && branch !== 'unknown' ? branch : 'unknown branch');
+                    (0, ui_1.displayInfo)('Repository status', [
+                        `Branch: ${chalk_1.default.cyan(branch)}`,
+                        `${status.staged} staged • ${status.unstaged} unstaged • ${status.untracked} untracked`,
+                    ]);
+                },
+            },
+            {
+                id: 'stage',
+                title: 'Stage everything (optional)',
+                description: 'Stage all changes so the AI can review the full diff.',
+                skippable: true,
+                action: async (ctx) => {
+                    const shouldStage = ctx.autoContinue || (await (0, prompt_1.promptConfirm)('Stage all changes?', true));
+                    if (!shouldStage) {
+                        ctx.recordInsight('stageAll', 'Skipped');
+                        return;
+                    }
+                    try {
+                        await runShellCommand('git add -A');
+                        ctx.recordInsight('stageAll', 'Staged all changes');
+                        (0, ui_1.displaySuccess)('All changes staged.');
+                    }
+                    catch (error) {
+                        ctx.recordInsight('stageAll', 'Failed to stage');
+                        (0, ui_1.displayError)('Failed to stage files.', [error.message]);
+                    }
+                },
+            },
+            {
+                id: 'tests',
+                title: 'Run test suite',
+                description: 'Run your test command to ensure everything passes before committing.',
+                skippable: true,
+                action: async (ctx) => {
+                    const defaultCommand = getPreferredTestCommand();
+                    const shouldRun = ctx.autoContinue ||
+                        (await (0, prompt_1.promptConfirm)('Run tests before committing?', Boolean(defaultCommand)));
+                    if (!shouldRun) {
+                        ctx.recordInsight('tests', 'Skipped');
+                        return;
+                    }
+                    const command = ctx.autoContinue
+                        ? defaultCommand || ''
+                        : await (0, prompt_1.promptInput)('Test command', defaultCommand || 'npm test');
+                    if (!command) {
+                        ctx.recordInsight('tests', 'Skipped (no command)');
+                        return;
+                    }
+                    try {
+                        await runShellCommand(command);
+                        (0, memory_1.rememberPreference)('autopilot', 'testCommand', command);
+                        ctx.recordInsight('tests', `Passed (${command})`);
+                        (0, ui_1.displaySuccess)('Tests passed successfully.');
+                    }
+                    catch (error) {
+                        ctx.recordInsight('tests', `Failed (${command})`);
+                        (0, ui_1.displayError)('Tests failed.', [
+                            error.message,
+                            'Fix the tests or rerun with --auto to skip this step.',
+                        ]);
+                    }
+                },
+            },
+            {
+                id: 'commit',
+                title: 'Generate AI-powered commit',
+                description: 'Use the interactive commit flow to create a polished commit message and finalize your changes.',
+                action: async () => {
+                    await (0, commit_1.commitCommand)();
+                },
+            },
+            {
+                id: 'quick-summary',
+                title: 'Optional: quick commit instead',
+                description: 'If you prefer a one-click commit, run the quick commit flow.',
+                skippable: true,
+                action: async (ctx) => {
+                    const shouldRun = ctx.autoContinue || (await (0, prompt_1.promptConfirm)('Run quick commit now?', false));
+                    if (!shouldRun) {
+                        ctx.recordInsight('quickCommit', 'Skipped');
+                        return;
+                    }
+                    await (0, quick_1.quickCommand)();
+                    ctx.recordInsight('quickCommit', 'Executed');
+                },
+            },
+        ],
+    },
+];
+async function autopilotCommand(workflowId, rawOptions) {
+    const options = {
+        workflowId,
+        auto: rawOptions?.auto,
+        planOnly: rawOptions?.planOnly,
+    };
+    const authConfig = await (0, auth_1.ensureAuth)();
+    if (!authConfig) {
+        console.log(chalk_1.default.red('\n❌ Authentication required to use SnapCommit Autopilot\n'));
+        return;
+    }
+    if (!(0, git_1.isGitRepo)()) {
+        console.log(chalk_1.default.red('\n❌ Not a git repository'));
+        console.log(chalk_1.default.gray('   Autopilot needs to run inside an initialized git repo.\n'));
+        return;
+    }
+    const workflow = await selectWorkflow(options.workflowId);
+    if (!workflow) {
+        (0, ui_1.displayError)('No matching workflow found.', [
+            'Run `snap autopilot` without arguments to see the available options.',
+        ]);
+        return;
+    }
+    console.log();
+    console.log(chalk_1.default.inverse(` AUTOPILOT • ${workflow.name.toUpperCase()} `));
+    console.log(chalk_1.default.gray(workflow.headline));
+    console.log();
+    if (workflow.prerequisites?.length) {
+        (0, ui_1.displayInfo)('Prerequisites', workflow.prerequisites);
+    }
+    (0, memory_1.rememberPreference)('autopilot', 'preferredWorkflow', workflow.id);
+    if (options.planOnly) {
+        presentPlan(workflow);
+        return;
+    }
+    const result = await runWorkflow(workflow, {
+        summary: workflow.headline,
+        autoContinue: options.auto ?? false,
+    });
+    presentSummary(workflow, result);
+}
+async function selectWorkflow(preferredId) {
+    if (preferredId) {
+        const byId = WORKFLOWS.find((wf) => wf.id === preferredId || wf.id === preferredId.toLowerCase());
+        if (byId) {
+            return byId;
+        }
+        const fuzzy = WORKFLOWS.find((wf) => wf.name.toLowerCase().startsWith(preferredId.toLowerCase()));
+        if (fuzzy) {
+            return fuzzy;
+        }
+    }
+    const choice = await (0, prompt_1.promptSelect)('Choose a workflow to run:', WORKFLOWS.map((wf) => ({
+        label: `${wf.name}`,
+        value: wf.id,
+        hint: wf.headline,
+    })));
+    return WORKFLOWS.find((wf) => wf.id === choice);
+}
+async function runWorkflow(workflow, baseContext) {
+    const statusByStep = {};
+    const insights = [];
+    const context = {
+        workflow,
+        summary: baseContext.summary,
+        autoContinue: baseContext.autoContinue,
+        stepStatus: statusByStep,
+        setStepStatus: (stepId, status) => {
+            statusByStep[stepId] = status;
+        },
+        recordInsight: (key, value) => {
+            const stringify = typeof value === 'string'
+                ? value
+                : Array.isArray(value)
+                    ? value.join(', ')
+                    : JSON.stringify(value, null, 2);
+            const existingIndex = insights.findIndex((insight) => insight.key === key);
+            const label = key
+                .split(/(?=[A-Z])/)
+                .join(' ')
+                .replace(/\b\w/g, (char) => char.toUpperCase());
+            if (existingIndex >= 0) {
+                insights[existingIndex] = { key, label, value: stringify };
+            }
+            else {
+                insights.push({ key, label, value: stringify });
+            }
+        },
+    };
+    for (let i = 0; i < workflow.steps.length; i += 1) {
+        const step = workflow.steps[i];
+        const position = `${i + 1}/${workflow.steps.length}`;
+        console.log(chalk_1.default.bold(`\n${position} • ${step.title}`));
+        console.log(chalk_1.default.gray(step.description));
+        context.setStepStatus(step.id, 'pending');
+        if (!context.autoContinue && step.skippable) {
+            const runStep = await (0, prompt_1.promptConfirm)('Run this step?', true);
+            if (!runStep) {
+                context.setStepStatus(step.id, 'skipped');
+                continue;
+            }
+        }
+        context.setStepStatus(step.id, 'running');
+        try {
+            await step.action(context);
+            context.setStepStatus(step.id, 'completed');
+        }
+        catch (error) {
+            context.setStepStatus(step.id, 'failed');
+            (0, ui_1.displayError)('Step failed.', [
+                error.message || 'Unknown error occurred',
+                'Resolve the issue and re-run Autopilot.',
+            ]);
+            const continueWorkflow = context.autoContinue || (await (0, prompt_1.promptConfirm)('Continue to the next step?', true));
+            if (!continueWorkflow) {
+                break;
+            }
+        }
+    }
+    return { statusByStep, insights };
+}
+function presentPlan(workflow) {
+    console.log(chalk_1.default.bold('\nWorkflow plan:\n'));
+    workflow.steps.forEach((step, index) => {
+        const bullet = chalk_1.default.gray(`${index + 1}.`);
+        const title = chalk_1.default.white(step.title);
+        const optional = step.skippable ? chalk_1.default.yellow(' (optional)') : '';
+        console.log(`${bullet} ${title}${optional}`);
+        console.log(chalk_1.default.gray(`   ${step.description}`));
+    });
+    console.log();
+}
+function presentSummary(workflow, result) {
+    const rows = workflow.steps.map((step) => {
+        const status = result.statusByStep[step.id] ?? 'pending';
+        let symbol = chalk_1.default.gray('•');
+        switch (status) {
+            case 'completed':
+                symbol = chalk_1.default.green('✓');
+                break;
+            case 'skipped':
+                symbol = chalk_1.default.yellow('↷');
+                break;
+            case 'failed':
+                symbol = chalk_1.default.red('✗');
+                break;
+            case 'running':
+                symbol = chalk_1.default.blue('…');
+                break;
+            default:
+                symbol = chalk_1.default.gray('•');
+        }
+        return [symbol, step.title, step.description];
+    });
+    console.log();
+    console.log((0, ui_1.createTable)(['', 'Step', 'Details'], rows));
+    if (result.insights.length) {
+        console.log();
+        console.log(chalk_1.default.bold('Insights & artifacts:'));
+        result.insights.forEach((insight) => {
+            console.log(`  ${chalk_1.default.cyan(insight.label)}: ${insight.value}`);
+        });
+    }
+    console.log();
+    (0, ui_1.displaySuccess)(`${workflow.name} workflow completed.`, [
+        'Re-run with --plan to preview or --auto to run without prompts.',
+    ]);
+}
+function getConflictedFiles() {
+    try {
+        const output = (0, child_process_1.execSync)('git status --short', {
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        const lines = output
+            .split('\n')
+            .map((line) => line.trim())
+            .filter(Boolean);
+        return lines
+            .filter((line) => line.startsWith('UU') || line.startsWith('AA') || line.startsWith('DD'))
+            .map((line) => line.substring(3));
+    }
+    catch {
+        return [];
+    }
+}
+async function runShellCommand(command) {
+    await new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(command, { shell: true, stdio: 'inherit' });
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(`Command "${command}" exited with code ${code}`));
+            }
+        });
+    });
+}
+function getPreferredTestCommand() {
+    const remembered = (0, memory_1.recallPreference)('autopilot', 'testCommand');
+    if (remembered) {
+        return remembered;
+    }
+    return inferProjectTestCommand();
+}
+function inferProjectTestCommand() {
+    const cwd = process.cwd();
+    const pkgPath = path_1.default.join(cwd, 'package.json');
+    if (!(0, fs_1.existsSync)(pkgPath)) {
+        return null;
+    }
+    try {
+        const raw = (0, fs_1.readFileSync)(pkgPath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (parsed.scripts?.test && parsed.scripts.test !== 'echo "Error: no test specified" && exit 1') {
+            return 'npm test';
+        }
+        if (parsed.scripts?.['test:ci']) {
+            return 'npm run test:ci';
+        }
+        if (parsed.scripts?.lint) {
+            return 'npm run lint';
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}

package/dist/commands/onboard.js

@@ -75,6 +75,7 @@ async function onboardCommand() {
     console.log(chalk_1.default.gray('Other commands:'));
     console.log(chalk_1.default.cyan('  snapcommit doctor  ') + chalk_1.default.gray('→ Check setup'));
     console.log(chalk_1.default.cyan('  snapcommit stats   ') + chalk_1.default.gray('→ See your progress'));
+    console.log(chalk_1.default.cyan('  snap autopilot     ') + chalk_1.default.gray('→ AI workflows for conflicts & releases'));
     console.log(chalk_1.default.cyan('  snapcommit --help  ') + chalk_1.default.gray('→ All commands'));
     console.log();
     console.log(chalk_1.default.yellow.bold('💡 Pro tip: ') + chalk_1.default.white('Use') + chalk_1.default.cyan(' bq ') + chalk_1.default.white('for instant commits!'));

package/dist/index.js

@@ -24,6 +24,7 @@ const uninstall_1 = require("./commands/uninstall");
 const github_connect_1 = require("./commands/github-connect");
 const telemetry_1 = require("./commands/telemetry");
 const repl_1 = require("./repl");
+const autopilot_1 = require("./commands/autopilot");
 // Load environment variables from root .env
 (0, dotenv_1.config)({ path: path_1.default.join(__dirname, '../../.env') });
 // Read version from package.json
@@ -128,6 +129,20 @@ program
     .action(async () => {
     await (0, conflict_1.conflictCommand)();
 });
+// Command: snapcommit autopilot
+program
+    .command('autopilot [workflowId]')
+    .description('Run multi-step AI-assisted workflows (merge recovery, release prep, etc.)')
+    .option('--auto', 'Run without confirmations where possible')
+    .option('--plan', 'Show the workflow plan without executing steps')
+    .action(async (workflowId, cmd) => {
+    const opts = cmd.opts();
+    await (0, autopilot_1.autopilotCommand)(workflowId, {
+        workflowId,
+        auto: Boolean(opts.auto),
+        planOnly: Boolean(opts.plan),
+    });
+});
 // Command: snapcommit github
 const githubCmd = program
     .command('github')

package/dist/repl.js

@@ -43,6 +43,9 @@ const auth_1 = require("./lib/auth");
 const natural_1 = require("./commands/natural");
 const github_connect_1 = require("./commands/github-connect");
 const version_1 = require("./utils/version");
+const telemetry_1 = require("./utils/telemetry");
+const settings_1 = require("./utils/settings");
+const TELEMETRY_REPROMPT_INTERVAL_MS = 1000 * 60 * 60 * 24 * 14;
 /**
  * Start SnapCommit REPL (Read-Eval-Print-Loop)
  * Interactive mode for natural language Git commands
@@ -152,7 +155,6 @@ async function startREPL() {
         output: process.stdout,
         prompt: chalk_1.default.cyan('snap> '),
     });
-    rl.prompt();
     rl.on('line', async (input) => {
         if (promptState.resolver) {
             const resolver = promptState.resolver;
@@ -374,8 +376,43 @@ async function startREPL() {
         }
         rl.prompt();
     });
+    await showTelemetryNotice(promptController);
+    rl.prompt();
     rl.on('close', () => {
         console.log(chalk_1.default.gray('\n👋 See you later! Happy coding!\n'));
         process.exit(0);
     });
 }
+async function showTelemetryNotice(prompt) {
+    const settings = (0, settings_1.getSettings)();
+    const telemetryOn = (0, telemetry_1.isTelemetryEnabled)();
+    const lastPrompt = settings.telemetryPromptedAt ?? 0;
+    const shouldPrompt = !telemetryOn &&
+        (lastPrompt === 0 || Date.now() - lastPrompt > TELEMETRY_REPROMPT_INTERVAL_MS);
+    console.log(chalk_1.default.gray(`📊 Telemetry: ${telemetryOn ? chalk_1.default.green('enabled') : chalk_1.default.red('disabled')} • Manage anytime with ` +
+        chalk_1.default.cyan('snap telemetry status | enable | disable')));
+    if (!shouldPrompt) {
+        if (!telemetryOn) {
+            console.log(chalk_1.default.gray('   Help improve SnapCommit by enabling anonymous diagnostics when you are ready.'));
+        }
+        else {
+            console.log(chalk_1.default.gray('   Thanks for helping us prioritise new features!'));
+        }
+        console.log();
+        return;
+    }
+    console.log();
+    console.log(chalk_1.default.yellow.bold('Help us keep SnapCommit fast for everyone!'));
+    console.log(chalk_1.default.gray('We collect anonymous usage diagnostics (never your code, repo names, or secrets) to guide feature development.'));
+    console.log();
+    const enable = await prompt.confirm('Enable anonymous telemetry?', { defaultValue: true });
+    (0, telemetry_1.markTelemetryPrompted)();
+    if (enable) {
+        (0, telemetry_1.setTelemetryEnabled)(true);
+        (0, telemetry_1.recordTelemetry)('telemetry_opt_in');
+        console.log(chalk_1.default.green('\n✅ Telemetry enabled. Manage anytime with `snap telemetry disable`.\n'));
+    }
+    else {
+        console.log(chalk_1.default.gray('\nNo problem. Enable later with `snap telemetry enable` if you change your mind.\n'));
+    }
+}

package/dist/types/workflow.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/memory.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadMemory = loadMemory;
+exports.saveMemory = saveMemory;
+exports.updateMemory = updateMemory;
+exports.rememberPreference = rememberPreference;
+exports.recallPreference = recallPreference;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const MEMORY_DIR = path_1.default.join(os_1.default.homedir(), '.snapcommit');
+const MEMORY_FILE = path_1.default.join(MEMORY_DIR, 'memory.json');
+const DEFAULT_MEMORY = {
+    version: 1,
+    workflows: {},
+    preferences: {},
+};
+function loadMemory() {
+    try {
+        if (!fs_1.default.existsSync(MEMORY_FILE)) {
+            ensureMemoryFile();
+            return { ...DEFAULT_MEMORY };
+        }
+        const raw = fs_1.default.readFileSync(MEMORY_FILE, 'utf-8');
+        const parsed = JSON.parse(raw);
+        return {
+            ...DEFAULT_MEMORY,
+            ...parsed,
+            workflows: { ...DEFAULT_MEMORY.workflows, ...parsed.workflows },
+            preferences: { ...DEFAULT_MEMORY.preferences, ...parsed.preferences },
+        };
+    }
+    catch {
+        return { ...DEFAULT_MEMORY };
+    }
+}
+function saveMemory(memory) {
+    ensureMemoryFile();
+    fs_1.default.writeFileSync(MEMORY_FILE, JSON.stringify(memory, null, 2), 'utf-8');
+}
+function updateMemory(mutator) {
+    const current = loadMemory();
+    const next = mutator({ ...current });
+    saveMemory(next);
+    return next;
+}
+function rememberPreference(namespace, key, value) {
+    updateMemory((memory) => {
+        const preferences = {
+            ...(memory.preferences || {}),
+            [namespace]: {
+                ...(typeof memory.preferences?.[namespace] === 'object'
+                    ? memory.preferences?.[namespace]
+                    : {}),
+                [key]: value,
+            },
+        };
+        return { ...memory, preferences };
+    });
+}
+function recallPreference(namespace, key) {
+    const memory = loadMemory();
+    const namespacePrefs = memory.preferences?.[namespace];
+    if (!namespacePrefs || typeof namespacePrefs !== 'object') {
+        return undefined;
+    }
+    const record = namespacePrefs;
+    return record[key];
+}
+function ensureMemoryFile() {
+    if (!fs_1.default.existsSync(MEMORY_DIR)) {
+        fs_1.default.mkdirSync(MEMORY_DIR, { recursive: true });
+    }
+    if (!fs_1.default.existsSync(MEMORY_FILE)) {
+        fs_1.default.writeFileSync(MEMORY_FILE, JSON.stringify(DEFAULT_MEMORY, null, 2), 'utf-8');
+    }
+}

package/dist/utils/prompt.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptConfirm = promptConfirm;
+exports.promptSelect = promptSelect;
+exports.promptInput = promptInput;
+const readline_1 = __importDefault(require("readline"));
+const chalk_1 = __importDefault(require("chalk"));
+function createInterface() {
+    return readline_1.default.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+}
+async function promptConfirm(question, defaultValue = true) {
+    const rl = createInterface();
+    const hint = defaultValue ? '[Y/n]' : '[y/N]';
+    return new Promise((resolve) => {
+        rl.question(`${chalk_1.default.cyan(question)} ${chalk_1.default.gray(hint)} `, (answer) => {
+            rl.close();
+            const normalized = answer.trim().toLowerCase();
+            if (!normalized) {
+                resolve(defaultValue);
+                return;
+            }
+            if (['y', 'yes'].includes(normalized)) {
+                resolve(true);
+                return;
+            }
+            if (['n', 'no'].includes(normalized)) {
+                resolve(false);
+                return;
+            }
+            resolve(defaultValue);
+        });
+    });
+}
+async function promptSelect(question, choices, defaultIndex = 0) {
+    const rl = createInterface();
+    const safeIndex = Math.min(Math.max(defaultIndex, 0), choices.length - 1);
+    console.log(chalk_1.default.cyan(question));
+    choices.forEach((choice, index) => {
+        const prefix = index === safeIndex ? chalk_1.default.green('➤') : chalk_1.default.gray('•');
+        const label = `${choice.label}${choice.hint ? chalk_1.default.gray(` — ${choice.hint}`) : ''}`;
+        console.log(`${prefix} [${index + 1}] ${label}`);
+    });
+    console.log();
+    return new Promise((resolve) => {
+        rl.question(chalk_1.default.cyan(`Select an option [1-${choices.length}] (default: ${safeIndex + 1}): `), (answer) => {
+            rl.close();
+            const trimmed = answer.trim();
+            if (!trimmed) {
+                resolve(choices[safeIndex].value);
+                return;
+            }
+            const idx = parseInt(trimmed, 10);
+            if (!Number.isNaN(idx) && idx >= 1 && idx <= choices.length) {
+                resolve(choices[idx - 1].value);
+            }
+            else {
+                resolve(choices[safeIndex].value);
+            }
+        });
+    });
+}
+async function promptInput(question, defaultValue = '') {
+    const rl = createInterface();
+    const suffix = defaultValue ? chalk_1.default.gray(` (default: ${defaultValue})`) : '';
+    return new Promise((resolve) => {
+        rl.question(chalk_1.default.cyan(`${question}${suffix}: `), (answer) => {
+            rl.close();
+            const trimmed = answer.trim();
+            resolve(trimmed || defaultValue);
+        });
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snapcommit/cli",
-  "version": "3.10.0",
+  "version": "3.11.0",
   "description": "Instant AI commits. Beautiful progress tracking. Never write commit messages again.",
   "main": "dist/index.js",
   "bin": {