@alejandrochaves/devflow-cli 1.3.2 → 1.4.0

package/dist/commands/commit.js

@@ -1,8 +1,8 @@
-import { select, search, confirm, input, checkbox } from "@inquirer/prompts";
 import { execSync } from "child_process";
 import { loadConfig } from "../config.js";
 import { inferTicket, inferScope, getBranch, isProtectedBranch } from "../git.js";
 import { bold, cyan, dim, green, yellow } from "../colors.js";
+import { selectWithBack, inputWithBack, confirmWithBack, searchWithBack, checkboxWithBack, BACK_VALUE, } from "../prompts.js";
 export function inferScopeFromPaths(stagedFiles, scopes) {
     const scopesWithPaths = scopes.filter((s) => s.paths && s.paths.length > 0);
     if (scopesWithPaths.length === 0)
@@ -53,16 +53,17 @@ export async function commitCommand(options = {}) {
         if (isProtectedBranch() && !options.yes) {
             const branch = getBranch();
             console.log(yellow(`⚠ You are on ${bold(branch)}. Committing directly to protected branches is not recommended.`));
-            const proceed = await confirm({
+            const proceed = await confirmWithBack({
                 message: `Continue committing to ${branch}?`,
                 default: false,
+                showBack: false,
             });
-            if (!proceed) {
+            if (proceed !== true) {
                 console.log("Use: devflow branch");
                 process.exit(0);
             }
         }
-        // Stage files if --all or --files provided
+        // Stage files if --all or --files provided (non-interactive)
         if (options.all) {
             if (!options.dryRun) {
                 execSync("git add -A");
@@ -76,198 +77,354 @@ export async function commitCommand(options = {}) {
                 }
             }
         }
-        // Check for staged files
-        const staged = execSync("git diff --cached --name-only", { encoding: "utf-8" }).trim();
-        const unstaged = execSync("git diff --name-only", { encoding: "utf-8" }).trim();
-        const untracked = execSync("git ls-files --others --exclude-standard", { encoding: "utf-8" }).trim();
-        const allChanges = [
-            ...unstaged.split("\n").filter(Boolean).map((f) => ({ file: f, label: `M  ${f}` })),
-            ...untracked.split("\n").filter(Boolean).map((f) => ({ file: f, label: `?  ${f}` })),
-        ];
-        if (!staged && allChanges.length === 0) {
-            console.log("Nothing to commit — working tree clean.");
-            process.exit(0);
+        // Initialize state
+        const state = {
+            stagedFiles: [],
+            type: options.type || "",
+            scope: options.scope ?? "",
+            message: options.message || "",
+            isBreaking: options.breaking ?? false,
+            body: options.body || "",
+            breakingDesc: options.breakingDesc || "",
+        };
+        let currentStep = "stageFiles";
+        const stepOrder = ["stageFiles", "type", "scope", "message", "breaking", "body", "breakingDesc"];
+        // Determine starting step based on flags
+        if (options.all || options.files) {
+            // Files already staged via flags, skip to type
+            const staged = execSync("git diff --cached --name-only", { encoding: "utf-8" }).trim();
+            state.stagedFiles = staged ? staged.split("\n") : [];
+            currentStep = "type";
         }
-        let stagedFiles = staged ? staged.split("\n") : [];
-        // Interactive file staging (only if no files staged and no --all/--files flags)
-        if (!staged && !options.all && !options.files) {
-            if (allChanges.length === 1) {
-                if (options.yes) {
-                    // Auto-stage single file when --yes
-                    if (!options.dryRun) {
-                        execSync(`git add ${JSON.stringify(allChanges[0].file)}`);
+        const goBack = () => {
+            const currentIndex = stepOrder.indexOf(currentStep);
+            if (currentIndex > 0) {
+                currentStep = stepOrder[currentIndex - 1];
+                // Skip breakingDesc if not breaking
+                if (currentStep === "breakingDesc" && !state.isBreaking) {
+                    const prevIndex = stepOrder.indexOf(currentStep) - 1;
+                    if (prevIndex >= 0)
+                        currentStep = stepOrder[prevIndex];
+                }
+                // Skip stageFiles if files were staged via flags
+                if (currentStep === "stageFiles" && (options.all || options.files)) {
+                    // Can't go back further
+                    currentStep = "type";
+                }
+            }
+        };
+        const goNext = () => {
+            const currentIndex = stepOrder.indexOf(currentStep);
+            if (currentIndex < stepOrder.length - 1) {
+                currentStep = stepOrder[currentIndex + 1];
+                // Skip breakingDesc if not breaking
+                if (currentStep === "breakingDesc" && !state.isBreaking) {
+                    currentStep = stepOrder[stepOrder.indexOf(currentStep) + 1] || currentStep;
+                }
+            }
+        };
+        while (currentStep !== undefined) {
+            const canGoBackToStageFiles = !options.all && !options.files && !options.yes;
+            const isFirstStep = (currentStep === "stageFiles") || (currentStep === "type" && !canGoBackToStageFiles);
+            switch (currentStep) {
+                case "stageFiles": {
+                    // Check for staged files
+                    const staged = execSync("git diff --cached --name-only", { encoding: "utf-8" }).trim();
+                    const unstaged = execSync("git diff --name-only", { encoding: "utf-8" }).trim();
+                    const untracked = execSync("git ls-files --others --exclude-standard", { encoding: "utf-8" }).trim();
+                    const allChanges = [
+                        ...unstaged.split("\n").filter(Boolean).map((f) => ({ file: f, label: `M  ${f}` })),
+                        ...untracked.split("\n").filter(Boolean).map((f) => ({ file: f, label: `?  ${f}` })),
+                    ];
+                    // If already have staged changes, skip to type
+                    if (staged) {
+                        state.stagedFiles = staged.split("\n");
+                        console.log(dim("Staged files:"));
+                        staged.split("\n").forEach((f) => console.log(dim(`  ${f}`)));
+                        console.log("");
+                        goNext();
+                        break;
+                    }
+                    if (allChanges.length === 0) {
+                        console.log("Nothing to commit — working tree clean.");
+                        process.exit(0);
+                    }
+                    if (options.yes) {
+                        // Auto-stage all files when --yes
+                        if (!options.dryRun) {
+                            execSync("git add -A");
+                        }
+                        state.stagedFiles = allChanges.map((c) => c.file);
+                        goNext();
+                        break;
+                    }
+                    if (allChanges.length === 1) {
+                        const result = await confirmWithBack({
+                            message: `Stage ${allChanges[0].file}?`,
+                            default: true,
+                            showBack: false, // First step
+                        });
+                        if (result !== true) {
+                            console.log("No files staged. Aborting.");
+                            process.exit(0);
+                        }
+                        if (!options.dryRun) {
+                            execSync(`git add ${JSON.stringify(allChanges[0].file)}`);
+                        }
+                        state.stagedFiles = [allChanges[0].file];
+                        goNext();
+                    }
+                    else {
+                        // Ask: stage all or select specific files?
+                        const stageChoice = await selectWithBack({
+                            message: "Stage files:",
+                            choices: [
+                                { value: "all", name: `Stage all (${allChanges.length} files)` },
+                                { value: "select", name: "Select specific files" },
+                            ],
+                            default: "all",
+                            showBack: false, // First step
+                        });
+                        if (stageChoice === BACK_VALUE) {
+                            // Can't go back from first step
+                            break;
+                        }
+                        if (stageChoice === "all") {
+                            if (!options.dryRun) {
+                                execSync("git add -A");
+                            }
+                            state.stagedFiles = allChanges.map((c) => c.file);
+                            goNext();
+                        }
+                        else {
+                            const filesToStage = await checkboxWithBack({
+                                message: "Select files to stage:",
+                                choices: allChanges.map((c) => ({ value: c.file, name: c.label })),
+                                required: true,
+                                showBack: true,
+                            });
+                            if (filesToStage === BACK_VALUE) {
+                                // Stay on this step to re-show the all/select choice
+                                break;
+                            }
+                            if (filesToStage.length === 0) {
+                                console.log("No files selected. Please select at least one file.");
+                                break;
+                            }
+                            if (!options.dryRun) {
+                                for (const file of filesToStage) {
+                                    execSync(`git add ${JSON.stringify(file)}`);
+                                }
+                            }
+                            state.stagedFiles = filesToStage;
+                            goNext();
+                        }
                     }
-                    stagedFiles = [allChanges[0].file];
+                    break;
                 }
-                else {
-                    const stageIt = await confirm({
-                        message: `Stage ${allChanges[0].file}?`,
-                        default: true,
+                case "type": {
+                    if (options.type) {
+                        goNext();
+                        break;
+                    }
+                    const result = await selectWithBack({
+                        message: "Select commit type:",
+                        choices: config.commitTypes.map((t) => ({ value: t.value, name: t.label })),
+                        showBack: canGoBackToStageFiles,
                     });
-                    if (!stageIt) {
-                        console.log("No files staged. Aborting.");
-                        process.exit(0);
+                    if (result === BACK_VALUE) {
+                        // Unstage files before going back
+                        execSync("git reset HEAD", { stdio: "ignore" });
+                        goBack();
                     }
-                    if (!options.dryRun) {
-                        execSync(`git add ${JSON.stringify(allChanges[0].file)}`);
+                    else {
+                        state.type = result;
+                        goNext();
                     }
-                    stagedFiles = [allChanges[0].file];
+                    break;
                 }
-            }
-            else {
-                if (options.yes) {
-                    // Auto-stage all files when --yes
-                    if (!options.dryRun) {
-                        execSync("git add -A");
+                case "scope": {
+                    if (options.scope !== undefined) {
+                        goNext();
+                        break;
+                    }
+                    if (config.scopes.length > 0) {
+                        const inferredFromPaths = inferScopeFromPaths(state.stagedFiles, config.scopes);
+                        const inferredFromLog = inferScope();
+                        const inferred = inferredFromPaths || inferredFromLog;
+                        const result = await searchWithBack({
+                            message: inferred
+                                ? `Select scope (suggested: ${cyan(inferred)}):`
+                                : "Select scope (type to filter):",
+                            source: (term) => {
+                                const filtered = config.scopes.filter((s) => !term ||
+                                    s.value.includes(term.toLowerCase()) ||
+                                    s.description.toLowerCase().includes(term.toLowerCase()));
+                                if (inferred) {
+                                    filtered.sort((a, b) => a.value === inferred ? -1 : b.value === inferred ? 1 : 0);
+                                }
+                                return filtered.map((s) => ({
+                                    value: s.value,
+                                    name: `${s.value} — ${s.description}`,
+                                }));
+                            },
+                            showBack: true,
+                        });
+                        if (result === BACK_VALUE) {
+                            goBack();
+                        }
+                        else {
+                            state.scope = result;
+                            goNext();
+                        }
+                    }
+                    else {
+                        const inferredFromLog = inferScope();
+                        const result = await inputWithBack({
+                            message: inferredFromLog
+                                ? `Enter scope (default: ${inferredFromLog}):`
+                                : "Enter scope (optional):",
+                            default: inferredFromLog,
+                            showBack: true,
+                        });
+                        if (result === BACK_VALUE) {
+                            goBack();
+                        }
+                        else {
+                            state.scope = result;
+                            goNext();
+                        }
                     }
-                    stagedFiles = allChanges.map((c) => c.file);
+                    break;
                 }
-                else {
-                    const filesToStage = await checkbox({
-                        message: "Select files to stage:",
-                        choices: [
-                            { value: "__ALL__", name: "Stage all" },
-                            ...allChanges.map((c) => ({ value: c.file, name: c.label })),
-                        ],
-                        required: true,
+                case "message": {
+                    if (options.message) {
+                        goNext();
+                        break;
+                    }
+                    const result = await inputWithBack({
+                        message: "Enter commit message:",
+                        default: state.message || undefined,
+                        validate: (val) => val.trim().length > 0 || "Commit message is required",
+                        showBack: true,
                     });
-                    if (!options.dryRun) {
-                        if (filesToStage.includes("__ALL__")) {
-                            execSync("git add -A");
-                            stagedFiles = allChanges.map((c) => c.file);
+                    if (result === BACK_VALUE) {
+                        goBack();
+                    }
+                    else {
+                        state.message = result;
+                        goNext();
+                    }
+                    break;
+                }
+                case "breaking": {
+                    if (options.breaking !== undefined || options.yes) {
+                        state.isBreaking = options.breaking ?? false;
+                        goNext();
+                        break;
+                    }
+                    const result = await confirmWithBack({
+                        message: "Is this a breaking change?",
+                        default: state.isBreaking,
+                        showBack: true,
+                    });
+                    if (result === BACK_VALUE) {
+                        goBack();
+                    }
+                    else {
+                        state.isBreaking = result;
+                        goNext();
+                    }
+                    break;
+                }
+                case "body": {
+                    if (options.body || options.yes) {
+                        goNext();
+                        break;
+                    }
+                    const result = await confirmWithBack({
+                        message: "Add a longer description (body)?",
+                        default: false,
+                        showBack: true,
+                    });
+                    if (result === BACK_VALUE) {
+                        goBack();
+                    }
+                    else if (result) {
+                        const bodyResult = await inputWithBack({
+                            message: "Body (longer explanation):",
+                            default: state.body || undefined,
+                            showBack: true,
+                        });
+                        if (bodyResult === BACK_VALUE) {
+                            // Stay on this step
                         }
                         else {
-                            for (const file of filesToStage) {
-                                execSync(`git add ${JSON.stringify(file)}`);
-                            }
-                            stagedFiles = filesToStage;
+                            state.body = bodyResult;
+                            goNext();
                         }
                     }
                     else {
-                        stagedFiles = filesToStage.includes("__ALL__")
-                            ? allChanges.map((c) => c.file)
-                            : filesToStage;
+                        state.body = "";
+                        goNext();
                     }
+                    break;
                 }
-            }
-        }
-        else if (staged) {
-            console.log(dim("Staged files:"));
-            staged.split("\n").forEach((f) => console.log(dim(`  ${f}`)));
-            console.log("");
-        }
-        // Get commit type (from flag or prompt)
-        const type = options.type || await select({
-            message: "Select commit type:",
-            choices: config.commitTypes.map((t) => ({ value: t.value, name: t.label })),
-        });
-        // Get scope (from flag or prompt)
-        let finalScope;
-        if (options.scope !== undefined) {
-            finalScope = options.scope;
-        }
-        else if (config.scopes.length > 0) {
-            const inferredFromPaths = inferScopeFromPaths(stagedFiles, config.scopes);
-            const inferredFromLog = inferScope();
-            const inferred = inferredFromPaths || inferredFromLog;
-            finalScope = await search({
-                message: inferred
-                    ? `Select scope (suggested: ${cyan(inferred)}):`
-                    : "Select scope (type to filter):",
-                source: (term) => {
-                    const filtered = config.scopes.filter((s) => !term ||
-                        s.value.includes(term.toLowerCase()) ||
-                        s.description.toLowerCase().includes(term.toLowerCase()));
-                    if (inferred) {
-                        filtered.sort((a, b) => a.value === inferred ? -1 : b.value === inferred ? 1 : 0);
+                case "breakingDesc": {
+                    if (!state.isBreaking) {
+                        // Exit the loop - we're done collecting input
+                        currentStep = undefined;
+                        break;
                     }
-                    return filtered.map((s) => ({
-                        value: s.value,
-                        name: `${s.value} — ${s.description}`,
-                    }));
-                },
-            });
-        }
-        else {
-            const inferredFromLog = inferScope();
-            finalScope = await input({
-                message: inferredFromLog
-                    ? `Enter scope (default: ${inferredFromLog}):`
-                    : "Enter scope (optional):",
-                default: inferredFromLog,
-            });
-        }
-        // Get message (from flag or prompt)
-        let message;
-        if (options.message) {
-            message = options.message;
-        }
-        else {
-            message = await input({
-                message: "Enter commit message:",
-                validate: (val) => val.trim().length > 0 || "Commit message is required",
-            });
-        }
-        // Get breaking change status (from flag or prompt)
-        let isBreaking;
-        if (options.breaking !== undefined) {
-            isBreaking = options.breaking;
-        }
-        else if (options.yes) {
-            isBreaking = false;
-        }
-        else {
-            isBreaking = await confirm({
-                message: "Is this a breaking change?",
-                default: false,
-            });
+                    if (options.breakingDesc) {
+                        currentStep = undefined;
+                        break;
+                    }
+                    if (options.yes) {
+                        console.log(yellow("Warning: Breaking change without description. Use --breaking-desc to provide one."));
+                        currentStep = undefined;
+                        break;
+                    }
+                    const result = await inputWithBack({
+                        message: "Describe the breaking change:",
+                        default: state.breakingDesc || undefined,
+                        validate: (val) => val.trim().length > 0 || "Breaking change description is required",
+                        showBack: true,
+                    });
+                    if (result === BACK_VALUE) {
+                        goBack();
+                    }
+                    else {
+                        state.breakingDesc = result;
+                        currentStep = undefined;
+                    }
+                    break;
+                }
+                default:
+                    currentStep = undefined;
+            }
+            // Check if we've passed the last step
+            if (currentStep && stepOrder.indexOf(currentStep) >= stepOrder.length) {
+                break;
+            }
         }
         const ticket = inferTicket();
-        const breaking = isBreaking ? "!" : "";
-        const scope = finalScope || "";
+        const breaking = state.isBreaking ? "!" : "";
+        const scope = state.scope || "";
         const subject = formatCommitMessage(config.commitFormat, {
-            type,
+            type: state.type,
             ticket,
             breaking,
             scope,
-            message: message.trim(),
+            message: state.message.trim(),
         });
-        // Get body (from flag or prompt)
-        let body = options.body || "";
-        if (!options.body && !options.yes) {
-            const addBody = await confirm({
-                message: "Add a longer description (body)?",
-                default: false,
-            });
-            if (addBody) {
-                body = await input({
-                    message: "Body (longer explanation):",
-                });
-            }
-        }
-        // Get breaking change description (from flag or prompt)
-        let breakingFooter = "";
-        if (isBreaking) {
-            if (options.breakingDesc) {
-                breakingFooter = options.breakingDesc;
-            }
-            else if (options.yes) {
-                console.log(yellow("Warning: Breaking change without description. Use --breaking-desc to provide one."));
-            }
-            else {
-                breakingFooter = await input({
-                    message: "Describe the breaking change:",
-                    validate: (val) => val.trim().length > 0 || "Breaking change description is required",
-                });
-            }
-        }
         // Build full message
         const parts = [subject];
-        if (body.trim())
-            parts.push(body.trim());
+        if (state.body.trim())
+            parts.push(state.body.trim());
         const footers = [];
-        if (breakingFooter.trim())
-            footers.push(`BREAKING CHANGE: ${breakingFooter.trim()}`);
+        if (state.breakingDesc.trim())
+            footers.push(`BREAKING CHANGE: ${state.breakingDesc.trim()}`);
         if (ticket && ticket !== "UNTRACKED")
             footers.push(`Refs: ${ticket}`);
         if (footers.length > 0)
@@ -275,8 +432,8 @@ export async function commitCommand(options = {}) {
         const fullMessage = parts.join("\n\n");
         console.log(`\n${dim("───")} ${bold("Commit Preview")} ${dim("───")}`);
         console.log(green(subject));
-        if (body.trim())
-            console.log(`\n${body.trim()}`);
+        if (state.body.trim())
+            console.log(`\n${state.body.trim()}`);
         if (footers.length > 0)
             console.log(`\n${dim(footers.join("\n"))}`);
         console.log(`${dim("───────────────────")}\n`);
@@ -285,15 +442,26 @@ export async function commitCommand(options = {}) {
             return;
         }
         // Confirm (skip if --yes)
+        let confirmed = true;
         if (!options.yes) {
-            const confirmed = await confirm({
+            const confirmResult = await selectWithBack({
                 message: "Create this commit?",
-                default: true,
+                choices: [
+                    { value: "yes", name: "Yes, create commit" },
+                    { value: "no", name: "No, abort" },
+                ],
+                default: "yes",
+                showBack: true,
             });
-            if (!confirmed) {
-                console.log("Commit aborted.");
-                process.exit(0);
+            if (confirmResult === BACK_VALUE) {
+                // Go back to breaking desc or body step
+                return commitCommand(options); // Restart for simplicity (state is lost)
             }
+            confirmed = confirmResult === "yes";
+        }
+        if (!confirmed) {
+            console.log("Commit aborted.");
+            process.exit(0);
         }
         execSync(`git commit -m ${JSON.stringify(fullMessage)}`, {
             stdio: "inherit",