@snapcommit/cli 3.9.21 → 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;
+}