@snapcommit/cli 3.10.0 → 3.11.1

package/README.md

@@ -148,7 +148,7 @@ Full docs at [snapcommit.dev/docs](https://snapcommit.dev/docs)
 ## Support
 
 - 🐦 [Follow on X/Twitter](https://x.com/Arjun06061)
-- 📧 [Email support](mailto:support@snapcommit.dev)
+- 📧 [Email support](mailto:karjunvarma2001@gmail.com)
 - 💡 [Suggestions & Feedback](https://x.com/Arjun06061)
 
 ## License

package/dist/commands/autopilot.js

@@ -0,0 +1,464 @@
+"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 metrics_1 = require("../utils/metrics");
+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');
+                },
+            },
+        ],
+    },
+];
+const WORKFLOW_TIME_SAVINGS = {
+    'conflict-crusher': 25,
+    'release-ready': 18,
+};
+const WORKFLOW_EVENT_IDS = {
+    'conflict-crusher': 'autopilot:conflict-crusher',
+    'release-ready': 'autopilot:release-ready',
+};
+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();
+    const estimatedMinutes = WORKFLOW_TIME_SAVINGS[workflow.id];
+    const completedSteps = workflow.steps.filter((step) => result.statusByStep[step.id] === 'completed').length;
+    const eventId = WORKFLOW_EVENT_IDS[workflow.id];
+    if (estimatedMinutes && completedSteps > 0 && eventId) {
+        (0, metrics_1.logTimeSaved)(eventId, estimatedMinutes);
+        (0, ui_1.displaySuccess)(`${workflow.name} workflow completed.`, [
+            `Time saved: ~${(0, metrics_1.formatMinutes)(estimatedMinutes)} compared to manual steps.`,
+            'Re-run with --plan to preview or --auto to run without prompts.',
+        ]);
+    }
+    else {
+        (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/commit.js

@@ -44,6 +44,7 @@ const manager_1 = require("../license/manager");
 const rate_limit_1 = require("../utils/rate-limit");
 const analytics_1 = require("../utils/analytics");
 const readline_1 = __importDefault(require("readline"));
+const metrics_1 = require("../utils/metrics");
 async function commitCommand() {
     // Check license before proceeding
     const { allowed, reason, usage } = (0, manager_1.canUseCommit)();
@@ -226,6 +227,11 @@ async function commitCommand() {
         catch (error) {
             // Silent fail - cloud sync is optional
         }
+        const minutesSaved = (0, metrics_1.logTimeSaved)('commit:interactive');
+        if (minutesSaved > 0) {
+            console.log(chalk_1.default.gray(`   ⏱  Saved about ${(0, metrics_1.formatMinutes)(minutesSaved)} compared to drafting this commit by hand.`));
+            console.log();
+        }
         // Show dopamine stats
         const { displayQuickDopamine } = await Promise.resolve().then(() => __importStar(require('../utils/dopamine')));
         displayQuickDopamine();

package/dist/commands/conflict.js

@@ -14,6 +14,7 @@ const fs_1 = __importDefault(require("fs"));
 const readline_1 = __importDefault(require("readline"));
 const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
 const analytics_1 = require("../utils/analytics");
+const metrics_1 = require("../utils/metrics");
 const anthropic = new sdk_1.default({
     apiKey: process.env.ANTHROPIC_API_KEY || '',
 });
@@ -74,6 +75,11 @@ async function conflictCommand() {
     }
     // Final commit
     console.log(chalk_1.default.blue('\n✅ All conflicts resolved!\n'));
+    const minutesSaved = (0, metrics_1.logTimeSaved)('conflict:auto');
+    if (minutesSaved > 0) {
+        console.log(chalk_1.default.gray(`⏱  Saved roughly ${(0, metrics_1.formatMinutes)(minutesSaved)} by letting SnapCommit handle the merge.`));
+        console.log();
+    }
     const shouldCommit = await askQuestion(chalk_1.default.yellow('Commit the merge? (Y/n): '));
     if (shouldCommit.toLowerCase() !== 'n') {
         try {

package/dist/commands/onboard.js

@@ -75,6 +75,8 @@ 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('  snap stats         ') + chalk_1.default.gray('→ Track hours saved by AI'));
     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/commands/quick.js

@@ -9,6 +9,7 @@ const git_1 = require("../utils/git");
 const database_1 = require("../db/database");
 const auth_1 = require("../lib/auth");
 const analytics_1 = require("../utils/analytics");
+const metrics_1 = require("../utils/metrics");
 // API URL - defaults to production, can be overridden for development
 const API_BASE_URL = process.env.SNAPCOMMIT_API_URL || 'https://www.snapcommit.dev';
 /**
@@ -123,6 +124,11 @@ async function quickCommand() {
             deletions: stats.deletions,
             timestamp: Date.now(),
         });
+        const minutesSaved = (0, metrics_1.logTimeSaved)('commit:quick');
+        if (minutesSaved > 0) {
+            console.log(chalk_1.default.gray(`   ⏱  Saved ~${(0, metrics_1.formatMinutes)(minutesSaved)} with quick commit automation.`));
+            console.log();
+        }
     }
     catch (error) {
         console.log(chalk_1.default.red('\n❌ Commit failed\n'));

package/dist/commands/stats.js

@@ -8,6 +8,7 @@ const chalk_1 = __importDefault(require("chalk"));
 const database_1 = require("../db/database");
 const dopamine_1 = require("../utils/dopamine");
 const heatmap_1 = require("../utils/heatmap");
+const metrics_1 = require("../utils/metrics");
 function statsCommand() {
     console.log(chalk_1.default.blue.bold('\n📊 Your SnapCommit Stats\n'));
     // Show dopamine stats first (most engaging)
@@ -30,6 +31,18 @@ function statsCommand() {
         { label: 'Commits', value: statsAll.totalCommits, color: 'green' },
         { label: 'Commands', value: statsAll.totalCommands, color: 'cyan' },
     ]));
+    const timeSaved = (0, metrics_1.getTimeSavedSummary)();
+    if (timeSaved.totalMinutes > 0) {
+        console.log(chalk_1.default.white.bold('\nTime Saved With SnapCommit:'));
+        console.log(chalk_1.default.green(`  ≈ ${(0, metrics_1.formatMinutes)(Math.round(timeSaved.totalMinutes))} saved by AI assistance so far`));
+        const topEvents = Object.entries(timeSaved.breakdown)
+            .sort(([, a], [, b]) => (b.minutes ?? 0) - (a.minutes ?? 0))
+            .slice(0, 3);
+        topEvents.forEach(([eventId, data]) => {
+            console.log(chalk_1.default.gray(`   • ${formatEventLabel(eventId)} → ${(0, metrics_1.formatMinutes)(Math.round(data.minutes))} (${data.count} run${data.count === 1 ? '' : 's'})`));
+        });
+        console.log();
+    }
     // Commit streak
     const streak = calculateStreak(statsAll.recentCommits);
     if (streak > 0) {
@@ -71,6 +84,16 @@ function statsCommand() {
     console.log(chalk_1.default.gray('💡 Keep building with SnapCommit!'));
     console.log();
 }
+function formatEventLabel(eventId) {
+    const table = {
+        'autopilot:conflict-crusher': 'Autopilot – Conflict Crusher',
+        'autopilot:release-ready': 'Autopilot – Release Ready',
+        'commit:interactive': 'Interactive AI commits',
+        'commit:quick': 'Quick commits',
+        'conflict:auto': 'AI conflict resolution',
+    };
+    return table[eventId] ?? eventId;
+}
 function createStatCard(title, stats) {
     const width = 32;
     const border = '─'.repeat(width);

package/dist/commands/uninstall.js

@@ -91,7 +91,7 @@ async function uninstallCommand() {
     }
     // Feedback request
     console.log(chalk_1.default.yellow('💬 We\'d love to know why you\'re leaving:'));
-    console.log(chalk_1.default.gray('   Email: feedback@snapcommit.dev'));
+    console.log(chalk_1.default.gray('   Email: karjunvarma2001@gmail.com'));
     console.log(chalk_1.default.gray('   Or just reply to this prompt:\n'));
     const feedback = await askQuestion(chalk_1.default.yellow('Why are you uninstalling? (optional): '));
     if (feedback.trim()) {

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,92 @@
+"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: {},
+    metrics: {
+        minutesSavedTotal: 0,
+        events: {},
+    },
+};
+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 },
+            metrics: {
+                ...DEFAULT_MEMORY.metrics,
+                ...parsed.metrics,
+                events: {
+                    ...(DEFAULT_MEMORY.metrics?.events ?? {}),
+                    ...(parsed.metrics?.events ?? {}),
+                },
+            },
+        };
+    }
+    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/metrics.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logTimeSaved = logTimeSaved;
+exports.getTimeSavedSummary = getTimeSavedSummary;
+exports.formatMinutes = formatMinutes;
+const memory_1 = require("./memory");
+const telemetry_1 = require("./telemetry");
+const DEFAULT_TIME_SAVED_MINUTES = {
+    'autopilot:conflict-crusher': 25,
+    'autopilot:release-ready': 18,
+    'commit:interactive': 4,
+    'commit:quick': 2,
+    'conflict:auto': 20,
+};
+function logTimeSaved(eventId, minutesOverride) {
+    const minutes = minutesOverride ?? DEFAULT_TIME_SAVED_MINUTES[eventId] ?? 0;
+    if (!minutes || minutes <= 0) {
+        return 0;
+    }
+    let recordedMinutes = minutes;
+    (0, memory_1.updateMemory)((memory) => {
+        const metrics = memory.metrics || { minutesSavedTotal: 0, events: {} };
+        const current = metrics.events?.[eventId] ?? {
+            minutes: 0,
+            count: 0,
+            lastUpdated: Date.now(),
+        };
+        const events = {
+            ...(metrics.events || {}),
+            [eventId]: {
+                minutes: current.minutes + minutes,
+                count: current.count + 1,
+                lastUpdated: Date.now(),
+            },
+        };
+        const minutesSavedTotal = (metrics.minutesSavedTotal ?? 0) + minutes;
+        recordedMinutes = minutes;
+        return {
+            ...memory,
+            metrics: {
+                minutesSavedTotal,
+                events,
+            },
+        };
+    });
+    (0, telemetry_1.recordTelemetry)('time_saved', { eventId, minutes: recordedMinutes });
+    return recordedMinutes;
+}
+function getTimeSavedSummary() {
+    const memory = (0, memory_1.loadMemory)();
+    return {
+        totalMinutes: memory.metrics?.minutesSavedTotal ?? 0,
+        breakdown: memory.metrics?.events ?? {},
+    };
+}
+function formatMinutes(minutes) {
+    if (minutes < 60) {
+        return `${minutes} minute${minutes === 1 ? '' : 's'}`;
+    }
+    const hours = Math.floor(minutes / 60);
+    const remaining = minutes % 60;
+    if (remaining === 0) {
+        return `${hours} hour${hours === 1 ? '' : 's'}`;
+    }
+    return `${hours}h ${remaining}m`;
+}

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.1",
   "description": "Instant AI commits. Beautiful progress tracking. Never write commit messages again.",
   "main": "dist/index.js",
   "bin": {