@snapcommit/cli 3.9.21 → 3.11.0

package/dist/index.js

@@ -22,7 +22,9 @@ const natural_1 = require("./commands/natural");
 const conflict_1 = require("./commands/conflict");
 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
@@ -127,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')
@@ -149,6 +165,28 @@ githubCmd
     .action(async () => {
     await (0, github_connect_1.githubDisconnectCommand)();
 });
+// Telemetry management
+const telemetryCmd = program
+    .command('telemetry')
+    .description('Manage anonymous telemetry');
+telemetryCmd
+    .command('enable')
+    .description('Enable anonymous telemetry diagnostics')
+    .action(async () => {
+    await (0, telemetry_1.telemetryEnableCommand)();
+});
+telemetryCmd
+    .command('disable')
+    .description('Disable anonymous telemetry diagnostics')
+    .action(async () => {
+    await (0, telemetry_1.telemetryDisableCommand)();
+});
+telemetryCmd
+    .command('status')
+    .description('Show telemetry status')
+    .action(async () => {
+    await (0, telemetry_1.telemetryStatusCommand)();
+});
 // Command: snapcommit uninstall
 program
     .command('uninstall')

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
@@ -101,13 +104,64 @@ async function startREPL() {
     }
     console.log(chalk_1.default.gray('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'));
     console.log(chalk_1.default.bold.yellow('🎯 Try it now! Type what you want to do:\n'));
+    const promptState = {
+        resolver: null,
+    };
+    const promptController = {
+        ask: (question, options = {}) => new Promise((resolve) => {
+            if (promptState.resolver) {
+                console.log(chalk_1.default.red('\n❌ Internal prompt error: previous question still active.\n'));
+                resolve(options.defaultValue ?? '');
+                return;
+            }
+            const { defaultValue, suffix } = options;
+            const segments = [`\n${question}`];
+            if (suffix)
+                segments.push(` ${suffix}`);
+            if (defaultValue !== undefined) {
+                segments.push(` ${chalk_1.default.gray(`[default: ${defaultValue}]`)}`);
+            }
+            process.stdout.write(segments.join('') + '\n' + chalk_1.default.cyan('› '));
+            promptState.resolver = (value) => {
+                const trimmed = value.trim();
+                if (defaultValue !== undefined && trimmed === '') {
+                    resolve(defaultValue);
+                }
+                else {
+                    resolve(trimmed);
+                }
+            };
+        }),
+        confirm: async (question, options = {}) => {
+            const defaultYes = options.defaultValue ?? false;
+            const hint = defaultYes ? chalk_1.default.gray('[Y/n]') : chalk_1.default.gray('[y/N]');
+            while (true) {
+                const response = (await promptController.ask(`${question} ${hint}`)).toLowerCase();
+                if (!response) {
+                    return defaultYes;
+                }
+                if (response === 'y' || response === 'yes') {
+                    return true;
+                }
+                if (response === 'n' || response === 'no') {
+                    return false;
+                }
+                console.log(chalk_1.default.yellow('Please answer with yes or no.'));
+            }
+        },
+    };
     const rl = readline_1.default.createInterface({
         input: process.stdin,
         output: process.stdout,
         prompt: chalk_1.default.cyan('snap> '),
     });
-    rl.prompt();
     rl.on('line', async (input) => {
+        if (promptState.resolver) {
+            const resolver = promptState.resolver;
+            promptState.resolver = null;
+            resolver(input);
+            return;
+        }
         const line = input.trim();
         if (!line) {
             rl.prompt();
@@ -315,18 +369,50 @@ async function startREPL() {
         }
         // Everything else is natural language
         try {
-            rl.pause(); // Pause REPL readline to avoid conflicts
-            await (0, natural_1.naturalCommand)(line);
-            rl.resume(); // Resume REPL readline
+            await (0, natural_1.naturalCommand)(line, promptController);
         }
         catch (error) {
             console.log(chalk_1.default.red(`\n❌ Error: ${error.message}\n`));
-            rl.resume(); // Make sure to resume even on error
         }
         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/prompt.js

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

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-helpers.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPromptHelpers = createPromptHelpers;
+const readline_1 = __importDefault(require("readline"));
+const chalk_1 = __importDefault(require("chalk"));
+function createPromptHelpers(prompt) {
+    return {
+        ask: (question, options) => askWithFallback(question, options, prompt),
+        confirm: (question, options) => confirmWithFallback(question, options, prompt),
+    };
+}
+async function askWithFallback(question, options = {}, prompt) {
+    if (prompt) {
+        return prompt.ask(question, options);
+    }
+    const rl = readline_1.default.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const { defaultValue, suffix } = options;
+    const segments = [question];
+    if (suffix)
+        segments.push(` ${suffix}`);
+    if (defaultValue !== undefined) {
+        segments.push(` ${chalk_1.default.gray(`[default: ${defaultValue}]`)}`);
+    }
+    return await new Promise((resolve) => {
+        rl.question(`${segments.join('')}` + '\n› ', (answer) => {
+            rl.close();
+            const trimmed = answer.trim();
+            if (defaultValue !== undefined && trimmed === '') {
+                resolve(defaultValue);
+            }
+            else {
+                resolve(trimmed);
+            }
+        });
+    });
+}
+async function confirmWithFallback(question, options = {}, prompt) {
+    if (prompt) {
+        return prompt.confirm(question, options);
+    }
+    const defaultYes = options.defaultValue ?? false;
+    const hint = defaultYes ? '[Y/n]' : '[y/N]';
+    while (true) {
+        const answer = (await askWithFallback(`${question} ${hint}`, {}, undefined)).toLowerCase();
+        if (!answer) {
+            return defaultYes;
+        }
+        if (answer === 'y' || answer === 'yes') {
+            return true;
+        }
+        if (answer === 'n' || answer === 'no') {
+            return false;
+        }
+        console.log(chalk_1.default.yellow('Please answer with yes or no.'));
+    }
+}

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/dist/utils/settings.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSettings = getSettings;
+exports.saveSettings = saveSettings;
+exports.updateSettings = updateSettings;
+exports.getOrCreateDeviceId = getOrCreateDeviceId;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const crypto_1 = __importDefault(require("crypto"));
+const CONFIG_DIR = path_1.default.join(os_1.default.homedir(), '.snapcommit');
+const SETTINGS_FILE = path_1.default.join(CONFIG_DIR, 'settings.json');
+const defaultSettings = {
+    telemetryEnabled: false,
+    telemetryPromptedAt: 0,
+};
+function ensureConfigDir() {
+    if (!fs_1.default.existsSync(CONFIG_DIR)) {
+        fs_1.default.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+}
+function getSettings() {
+    try {
+        ensureConfigDir();
+        if (!fs_1.default.existsSync(SETTINGS_FILE)) {
+            return { ...defaultSettings };
+        }
+        const raw = fs_1.default.readFileSync(SETTINGS_FILE, 'utf-8');
+        const parsed = JSON.parse(raw);
+        return { ...defaultSettings, ...parsed };
+    }
+    catch {
+        return { ...defaultSettings };
+    }
+}
+function saveSettings(settings) {
+    ensureConfigDir();
+    const merged = { ...defaultSettings, ...settings };
+    fs_1.default.writeFileSync(SETTINGS_FILE, JSON.stringify(merged, null, 2));
+    return merged;
+}
+function updateSettings(partial) {
+    const current = getSettings();
+    const merged = { ...current, ...partial };
+    return saveSettings(merged);
+}
+function getOrCreateDeviceId() {
+    const settings = getSettings();
+    if (settings.deviceId) {
+        return settings.deviceId;
+    }
+    const deviceId = crypto_1.default.randomUUID();
+    updateSettings({ deviceId });
+    return deviceId;
+}

package/dist/utils/telemetry.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTelemetryEnabled = isTelemetryEnabled;
+exports.setTelemetryEnabled = setTelemetryEnabled;
+exports.markTelemetryPrompted = markTelemetryPrompted;
+exports.recordTelemetry = recordTelemetry;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const settings_1 = require("./settings");
+const LOG_DIR = path_1.default.join(os_1.default.homedir(), '.snapcommit', 'logs');
+const LOG_FILE = path_1.default.join(LOG_DIR, 'telemetry.log');
+const TELEMETRY_ENDPOINT = process.env.SNAPCOMMIT_TELEMETRY_URL || 'https://www.snapcommit.dev/api/telemetry';
+let packageVersion = '0.0.0';
+try {
+    const pkgPath = path_1.default.join(__dirname, '../../package.json');
+    const raw = fs_1.default.readFileSync(pkgPath, 'utf-8');
+    const parsed = JSON.parse(raw);
+    packageVersion = parsed.version || packageVersion;
+}
+catch {
+    // ignore
+}
+function ensureLogDir() {
+    if (!fs_1.default.existsSync(LOG_DIR)) {
+        fs_1.default.mkdirSync(LOG_DIR, { recursive: true });
+    }
+}
+function isTelemetryEnabled() {
+    return Boolean((0, settings_1.getSettings)().telemetryEnabled);
+}
+function setTelemetryEnabled(enabled) {
+    (0, settings_1.updateSettings)({ telemetryEnabled: enabled });
+}
+function markTelemetryPrompted() {
+    (0, settings_1.updateSettings)({ telemetryPromptedAt: Date.now() });
+}
+function appendLocalLog(entry) {
+    try {
+        ensureLogDir();
+        fs_1.default.appendFileSync(LOG_FILE, JSON.stringify(entry) + '\n');
+    }
+    catch {
+        // ignore logging failures
+    }
+}
+function recordTelemetry(event, payload = {}) {
+    if (!isTelemetryEnabled()) {
+        return;
+    }
+    const timestamp = new Date().toISOString();
+    const deviceId = (0, settings_1.getOrCreateDeviceId)();
+    const body = {
+        event,
+        payload,
+        timestamp,
+        version: packageVersion,
+        deviceId,
+    };
+    // Fire and forget
+    void (async () => {
+        try {
+            const response = await fetch(TELEMETRY_ENDPOINT, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(body),
+            });
+            if (!response.ok) {
+                appendLocalLog({ ...body, status: response.status, error: await response.text().catch(() => undefined) });
+            }
+        }
+        catch (error) {
+            appendLocalLog({ ...body, error: error?.message || 'network-error' });
+        }
+    })();
+}

package/package.json

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