geeto 0.6.5 → 0.9.0

package/lib/workflows/reword.js

@@ -14,9 +14,10 @@ import { multiSelect, select } from '../cli/menu.js';
 import { colors } from '../utils/colors.js';
 import { extractCommitBody, extractCommitTitle, formatCommitBody, normalizeAIOutput, } from '../utils/commit-helpers.js';
 import { DEFAULT_GEMINI_MODEL } from '../utils/config.js';
+import { BOX_W } from '../utils/display.js';
 import { isDryRun, logDryRun } from '../utils/dry-run.js';
 import { execAsync, execSilent } from '../utils/exec.js';
-import { chooseModelForProvider, getAIProviderShortName, getModelValue, interactiveAIFallback, isContextLimitFailure, isTransientAIFailure, } from '../utils/git-ai.js';
+import { chooseModelForProvider, generateCommitMessageWithProvider, getAIProviderShortName, getModelValue, interactiveAIFallback, isContextLimitFailure, isTransientAIFailure, } from '../utils/git-ai.js';
 import { getCurrentBranch } from '../utils/git.js';
 import { log } from '../utils/logging.js';
 import { ScrambleProgress } from '../utils/scramble.js';
@@ -255,28 +256,97 @@ const getRepoUrl = () => {
 };
 /** Wrap text in OSC 8 hyperlink (clickable in supported terminals). */
 const hyperlink = (url, text) => `\u001B]8;;${url}\u0007${text}\u001B]8;;\u0007`;
-// ── Main handler ───────────────────────────────────────────────────
-export const handleReword = async () => {
-    log.banner();
-    log.step(`${colors.cyan}Edit Commit Messages${colors.reset}\n`);
-    const branch = getCurrentBranch();
-    const isProtected = ['main', 'master', 'develop', 'production', 'staging'].includes(branch);
-    console.log(`  ${colors.gray}Branch: ${branch}${colors.reset}`);
-    if (isProtected) {
-        console.log(`  ${colors.red}⚠${colors.reset} ${colors.bright}Protected branch${colors.reset} — rewriting history here affects all collaborators.`);
-    }
-    // Check working tree
-    if (!isWorkingTreeClean()) {
-        log.error('Working tree has uncommitted changes.');
-        log.info('Please commit or stash changes before rewording.');
-        return;
-    }
-    // Load commits
-    const commits = getRecentCommits(30);
-    if (commits.length === 0) {
-        log.warn('No commits found.');
-        return;
+// ── Small helpers ──────────────────────────────────────────────────
+/** Resolve current AI provider and model from persisted state. */
+const resolveAIProvider = (state) => {
+    const provider = (state.aiProvider === 'manual' ? undefined : state.aiProvider) ?? 'gemini';
+    if (provider === 'copilot')
+        return { provider, model: state.copilotModel };
+    if (provider === 'openrouter')
+        return { provider, model: state.openrouterModel };
+    return { provider, model: state.geminiModel ?? DEFAULT_GEMINI_MODEL };
+};
+/** Normalize AI output and extract title + body into final commit message. */
+const buildFinalMessage = (raw) => {
+    const normalized = normalizeAIOutput(raw);
+    const extracted = extractCommitTitle(normalized);
+    let title;
+    let bodyText = null;
+    if (extracted) {
+        title = extracted;
+        bodyText = extractCommitBody(normalized, title);
+        if (bodyText)
+            bodyText = formatCommitBody(bodyText);
+    }
+    else {
+        const first = normalized.split('\n').find((l) => l.trim());
+        title = first?.trim() ?? normalized;
+    }
+    return bodyText ? `${title}\n\n${bodyText}` : title;
+};
+/** Regenerate commit message directly via the current provider (with retry). */
+const regenerateDirect = async (state, diff, correction) => {
+    const maxAttempts = 2;
+    let aiResult = null;
+    for (let attempt = 0; attempt < maxAttempts && !aiResult; attempt++) {
+        let modelName = '';
+        if (state.aiProvider === 'copilot' && state.copilotModel) {
+            modelName = state.copilotModel;
+        }
+        else if (state.aiProvider === 'openrouter' && state.openrouterModel) {
+            modelName = state.openrouterModel;
+        }
+        else if (state.aiProvider === 'gemini') {
+            modelName = state.geminiModel ?? DEFAULT_GEMINI_MODEL;
+        }
+        if (correction)
+            console.log('');
+        const sp = new ScrambleProgress();
+        sp.start([
+            `Regenerating with ${getAIProviderShortName(state.aiProvider ?? 'gemini')}${modelName ? ` (${modelName})` : ''}`,
+        ]);
+        try {
+            switch (state.aiProvider) {
+                case 'copilot': {
+                    const { generateCommitMessage } = await import('../api/copilot.js');
+                    aiResult = await generateCommitMessage(diff, correction, state.copilotModel);
+                    break;
+                }
+                case 'openrouter': {
+                    const { generateCommitMessage } = await import('../api/openrouter.js');
+                    aiResult = await generateCommitMessage(diff, correction, state.openrouterModel);
+                    break;
+                }
+                case 'gemini': {
+                    const { generateCommitMessage } = await import('../api/gemini.js');
+                    aiResult = await generateCommitMessage(diff, correction, state.geminiModel);
+                    break;
+                }
+                default: {
+                    aiResult = null;
+                    break;
+                }
+            }
+            sp.stop();
+        }
+        catch {
+            sp.stop();
+            aiResult = null;
+        }
+        if (!aiResult && attempt < maxAttempts - 1) {
+            log.ai('Regenerate returned no suggestion; retrying...');
+        }
     }
+    return aiResult;
+};
+// ── Extracted workflow steps ───────────────────────────────────────
+/**
+ * Show commit log with format consistency indicators and let user
+ * pick which commits to reword. Returns sorted (oldest-first) array
+ * or null when nothing was selected.
+ */
+const selectCommitsToReword = async (ctx) => {
+    const { commits, repoUrl } = ctx;
     // Detect commit format consistency (skip merge commits)
     const isMerge = (subject) => /^Merge\s/.test(subject);
     const formats = commits.map((c) => (isMerge(c.subject) ? null : detectCommitFormat(c.subject)));
@@ -298,20 +368,16 @@ export const handleReword = async () => {
     }
     // Priority-based inconsistency detection:
     // conventional (1st) > bracket-tag (2nd) > no-prefix / other (3rd)
-    // - conventional: NEVER gets ⚠ (gold standard)
-    // - bracket-tag: ⚠ only when conventional is the majority
-    // - no-prefix/other: ⚠ when ANY conventional or bracket-tag exists
     const hasConventional = (formatCounts.get('conventional') ?? 0) > 0;
     const hasBracketTag = (formatCounts.get('bracket-tag') ?? 0) > 0;
     const hasStructured = hasConventional || hasBracketTag;
     const isInconsistent = (fmt) => {
         if (fmt === null)
-            return false; // merge commits — always skip
+            return false;
         if (fmt === 'conventional')
-            return false; // gold standard — never flag
+            return false;
         if (fmt === 'bracket-tag')
-            return majorityFormat === 'conventional'; // only flag if conventional is majority
-        // no-prefix / other: flag if any structured format exists
+            return majorityFormat === 'conventional';
         return hasStructured;
     };
     const inconsistentCount = formats.filter((f) => isInconsistent(f)).length;
@@ -319,35 +385,30 @@ export const handleReword = async () => {
     if (inconsistentCount > 0) {
         console.log(`  ${colors.yellow}⚠${colors.reset} ${inconsistentCount} inconsistent commit(s) detected`);
         console.log(`  ${colors.gray}Team pattern: ${formatLabel(majorityFormat)} (${majorityCount}/${totalNonMerge})${colors.reset}`);
-        // If bracket-tag is majority, gently suggest conventional commits
         if (majorityFormat === 'bracket-tag' && !hasConventional) {
             console.log(`  ${colors.gray}💡 Tip: conventional commits is the recommended project standard${colors.reset}`);
         }
         console.log('');
     }
     else if (majorityFormat !== 'conventional' && totalNonMerge > 0) {
-        // No inconsistencies but not using conventional — soft tip
         console.log(`  ${colors.gray}💡 Tip: conventional commits is the recommended project standard${colors.reset}`);
         console.log('');
     }
     // Compute column widths
     const maxHash = Math.max(...commits.map((c) => c.shortHash.length));
-    const repoUrl = getRepoUrl();
     // Build multi-select options
     const options = commits.map((c, i) => {
         const hashCol = c.shortHash.padEnd(maxHash);
         const refs = formatRefs(c.refs);
         const subj = c.subject.length > 60 ? c.subject.slice(0, 57) + '...' : c.subject;
-        // Show indicator only when inconsistencies exist
         const fmt = formats[i] ?? null;
         const indicator = inconsistentCount > 0
             ? isInconsistent(fmt)
                 ? `${colors.red}⚠${colors.reset} `
                 : fmt === null
-                    ? '  ' // merge commit — no indicator
+                    ? '  '
                     : `${colors.green}✓${colors.reset} `
             : '';
-        // Wrap hash in OSC 8 hyperlink when repo URL is available
         const hashDisplay = repoUrl
             ? hyperlink(`${repoUrl}/commit/${c.hash}`, `${colors.yellow}${hashCol}${colors.reset}`)
             : `${colors.yellow}${hashCol}${colors.reset}`;
@@ -374,7 +435,7 @@ export const handleReword = async () => {
     const selected = await multiSelect('Select commits to edit:', options);
     if (selected.length === 0) {
         log.info('No commits selected.');
-        return;
+        return null;
     }
     // Sort selected: oldest first (for rebase ordering)
     const filtered = commits.filter((c) => selected.includes(c.hash));
@@ -384,11 +445,18 @@ export const handleReword = async () => {
         if (item)
             selectedCommits.push(item);
     }
-    // Collect new messages for each commit
+    return selectedCommits;
+};
+/**
+ * For each selected commit, let the user choose AI / manual / skip
+ * and collect new commit messages. Returns a Map of hash → new message.
+ */
+const generateNewMessages = async (selectedCommits, ctx) => {
+    const { repoUrl, branch } = ctx;
+    const newMessages = new Map();
     console.log('');
     log.info(`Editing ${selectedCommits.length} commit message(s)...`);
     console.log('');
-    const newMessages = new Map();
     // Load provider/model state for AI generation
     const state = loadState() ?? {
         step: 0,
@@ -451,44 +519,20 @@ export const handleReword = async () => {
             continue;
         }
         // Determine current provider/model
-        let currentProvider = (state.aiProvider === 'manual' ? undefined : state.aiProvider) ?? 'gemini';
-        let currentModel;
-        if (currentProvider === 'copilot') {
-            currentModel = state.copilotModel;
-        }
-        else if (currentProvider === 'openrouter') {
-            currentModel = state.openrouterModel;
-        }
-        else {
-            currentModel = state.geminiModel ?? DEFAULT_GEMINI_MODEL;
-        }
+        let { provider: currentProvider, model: currentModel } = resolveAIProvider(state);
         // Initial AI generation
         let correction = editGuidance.trim();
         let initialAiResult = null;
         const spinner = new ScrambleProgress();
         try {
             spinner.start([
-                'analyzing commit diff...',
-                `generating commit message with ${getAIProviderShortName(currentProvider)}${currentModel ? ` (${currentModel})` : ''}...`,
-                'formatting conventional commit...',
+                `Generating commit message with ${getAIProviderShortName(currentProvider)}${currentModel ? ` (${currentModel})` : ''}`,
             ]);
-            if (currentProvider === 'copilot') {
-                const { generateCommitMessage } = await import('../api/copilot.js');
-                initialAiResult = await generateCommitMessage(diff, correction, state.copilotModel);
-            }
-            else if (currentProvider === 'openrouter') {
-                const { generateCommitMessage } = await import('../api/openrouter.js');
-                initialAiResult = await generateCommitMessage(diff, correction, state.openrouterModel);
-            }
-            else {
-                const { generateCommitMessage } = await import('../api/gemini.js');
-                initialAiResult = await generateCommitMessage(diff, correction, state.geminiModel);
-            }
+            initialAiResult = await generateCommitMessageWithProvider(currentProvider, diff, correction, state.copilotModel, state.openrouterModel, state.geminiModel);
             spinner.stop();
         }
         catch {
-            spinner.stop();
-            log.warn('AI generation failed, falling back to manual edit');
+            spinner.fail('AI generation failed, falling back to manual edit');
             const edited = await editInline(currentMsg, `Edit: ${commit.shortHash} ${commit.subject}`);
             if (edited && edited.trim() !== currentMsg.trim()) {
                 newMessages.set(commit.hash, edited.trim());
@@ -515,60 +559,7 @@ export const handleReword = async () => {
                 aiResult = initialAiResult;
             }
             else if (forceDirect) {
-                let directAttempt = 0;
-                const maxDirectAttempts = 2;
-                while (directAttempt < maxDirectAttempts && !aiResult) {
-                    let directModelName = '';
-                    if (state.aiProvider === 'copilot' && state.copilotModel) {
-                        directModelName = state.copilotModel;
-                    }
-                    else if (state.aiProvider === 'openrouter' && state.openrouterModel) {
-                        directModelName = state.openrouterModel;
-                    }
-                    else if (state.aiProvider === 'gemini') {
-                        directModelName = state.geminiModel ?? DEFAULT_GEMINI_MODEL;
-                    }
-                    if (correction)
-                        console.log('');
-                    const sp = new ScrambleProgress();
-                    sp.start([
-                        'reviewing feedback...',
-                        `regenerating with ${getAIProviderShortName(state.aiProvider ?? 'gemini')}${directModelName ? ` (${directModelName})` : ''}...`,
-                        'formatting conventional commit...',
-                    ]);
-                    try {
-                        switch (state.aiProvider) {
-                            case 'copilot': {
-                                const { generateCommitMessage } = await import('../api/copilot.js');
-                                aiResult = await generateCommitMessage(diff, correction, state.copilotModel);
-                                break;
-                            }
-                            case 'openrouter': {
-                                const { generateCommitMessage } = await import('../api/openrouter.js');
-                                aiResult = await generateCommitMessage(diff, correction, state.openrouterModel);
-                                break;
-                            }
-                            case 'gemini': {
-                                const { generateCommitMessage } = await import('../api/gemini.js');
-                                aiResult = await generateCommitMessage(diff, correction, state.geminiModel);
-                                break;
-                            }
-                            default: {
-                                aiResult = null;
-                                break;
-                            }
-                        }
-                        sp.stop();
-                    }
-                    catch {
-                        sp.stop();
-                        aiResult = null;
-                    }
-                    directAttempt += 1;
-                    if (!aiResult && directAttempt < maxDirectAttempts) {
-                        log.ai('Regenerate returned no suggestion; retrying...');
-                    }
-                }
+                aiResult = await regenerateDirect(state, diff, correction);
             }
             else {
                 const provForFallback = (state.aiProvider ?? 'gemini');
@@ -655,22 +646,7 @@ export const handleReword = async () => {
             }
             switch (acceptChoice) {
                 case 'accept': {
-                    const normalized = normalizeAIOutput(commitMessage);
-                    const extracted = extractCommitTitle(normalized);
-                    let title;
-                    let bodyText = null;
-                    if (extracted) {
-                        title = extracted;
-                        bodyText = extractCommitBody(normalized, title);
-                        if (bodyText)
-                            bodyText = formatCommitBody(bodyText);
-                    }
-                    else {
-                        const first = normalized.split('\n').find((l) => l.trim());
-                        title = first?.trim() ?? normalized;
-                    }
-                    const finalMsg = bodyText ? `${title}\n\n${bodyText}` : title;
-                    newMessages.set(commit.hash, finalMsg.trim());
+                    newMessages.set(commit.hash, buildFinalMessage(commitMessage).trim());
                     log.success(`Message set for ${commit.shortHash}`);
                     commitDone = true;
                     break;
@@ -776,22 +752,7 @@ export const handleReword = async () => {
                 case 'edit': {
                     const edited = await editInline(commitMessage, `Edit: ${commit.shortHash}`);
                     if (edited?.trim()) {
-                        const editedNorm = normalizeAIOutput(edited.trim());
-                        const editedTitle = extractCommitTitle(editedNorm);
-                        let title;
-                        let bodyText = null;
-                        if (editedTitle) {
-                            title = editedTitle;
-                            bodyText = extractCommitBody(editedNorm, title);
-                            if (bodyText)
-                                bodyText = formatCommitBody(bodyText);
-                        }
-                        else {
-                            const first = editedNorm.split('\n').find((l) => l.trim());
-                            title = first?.trim() ?? editedNorm;
-                        }
-                        const finalMsg = bodyText ? `${title}\n\n${bodyText}` : title;
-                        newMessages.set(commit.hash, finalMsg.trim());
+                        newMessages.set(commit.hash, buildFinalMessage(edited.trim()).trim());
                         log.success(`Message set for ${commit.shortHash}`);
                         commitDone = true;
                     }
@@ -804,12 +765,16 @@ export const handleReword = async () => {
         }
         console.log('');
     }
-    if (newMessages.size === 0) {
-        log.info('No messages changed.');
-        return;
-    }
+    return newMessages;
+};
+/**
+ * Preview proposed changes, confirm with the user, then execute
+ * git rebase -i with auto-generated editor scripts.
+ */
+const executeRebase = async (selectedCommits, newMessages, ctx) => {
+    const { commits, repoUrl, branch, isProtected } = ctx;
     // Preview changes — complete before/after summary
-    const line = '─'.repeat(56);
+    const line = '─'.repeat(BOX_W);
     console.log('');
     console.log(`  ${colors.cyan}┌${line}┐${colors.reset}`);
     console.log(`  ${colors.cyan}│${colors.reset} ${colors.bright}Changes to apply (${newMessages.size} commit${newMessages.size > 1 ? 's' : ''})${colors.reset}`);
@@ -900,7 +865,6 @@ export const handleReword = async () => {
         parentRef = execSilent(`git rev-parse ${oldestHash}^`).trim();
     }
     catch {
-        // Oldest commit might be the root commit
         parentRef = '--root';
     }
     // Execute rebase
@@ -915,7 +879,6 @@ export const handleReword = async () => {
         const result = spawnSync('git', ['rebase', '-i', rebaseTarget], { stdio: 'inherit', env });
         if (result.status === 0) {
             log.success(`Reworded ${newMessages.size} commit(s)!`);
-            // Show updated commits
             for (const [hash] of newMessages) {
                 const short = hash.slice(0, 7);
                 const newMsg = getCommitMessage(hash)?.split('\n')[0];
@@ -923,7 +886,7 @@ export const handleReword = async () => {
                     console.log(`  ${colors.green}✓${colors.reset} ${colors.yellow}${short}${colors.reset} ${newMsg}`);
                 }
             }
-            // Offer force push (reword requires force push to update remote)
+            // Offer force push
             console.log('');
             const shouldPush = confirm('Force push to update remote? (recommended)');
             if (shouldPush) {
@@ -933,11 +896,7 @@ export const handleReword = async () => {
                 else {
                     console.log('');
                     const pushProgress = new ScrambleProgress();
-                    pushProgress.start([
-                        'preparing force push...',
-                        'pushing to remote...',
-                        'confirming remote state...',
-                    ]);
+                    pushProgress.start([`Force pushing to origin/${branch}`]);
                     try {
                         await execAsync(`git push --force-with-lease origin "${branch}"`, true);
                         pushProgress.succeed(`Force pushed ${branch} to remote`);
@@ -950,7 +909,7 @@ export const handleReword = async () => {
                     }
                 }
             }
-            // Team warning — history has been rewritten
+            // Team warning
             console.log('');
             console.log(`  ${colors.yellow}⚠${colors.reset} ${colors.bright}History rewritten!${colors.reset} All commit hashes on ${colors.cyan}${branch}${colors.reset} have changed.`);
             console.log(`  ${colors.gray}If this branch is shared, inform your team to run:${colors.reset}`);
@@ -974,7 +933,6 @@ export const handleReword = async () => {
         log.info('Run: git rebase --abort  to undo');
     }
     finally {
-        // Cleanup temp files
         try {
             fs.rmSync(tmpDir, { recursive: true, force: true });
         }
@@ -983,4 +941,38 @@ export const handleReword = async () => {
         }
     }
 };
+// ── Main handler ───────────────────────────────────────────────────
+export const handleReword = async () => {
+    log.banner();
+    log.step(`${colors.cyan}Edit Commit Messages${colors.reset}\n`);
+    const branch = getCurrentBranch();
+    const isProtected = ['main', 'master', 'develop', 'production', 'staging'].includes(branch);
+    console.log(`  ${colors.gray}Branch: ${branch}${colors.reset}`);
+    if (isProtected) {
+        console.log(`  ${colors.red}⚠${colors.reset} ${colors.bright}Protected branch${colors.reset} — rewriting history here affects all collaborators.`);
+    }
+    // Check working tree
+    if (!isWorkingTreeClean()) {
+        log.error('Working tree has uncommitted changes.');
+        log.info('Please commit or stash changes before rewording.');
+        return;
+    }
+    // Load commits
+    const commits = getRecentCommits(30);
+    if (commits.length === 0) {
+        log.warn('No commits found.');
+        return;
+    }
+    const repoUrl = getRepoUrl();
+    const ctx = { branch, isProtected, commits, repoUrl };
+    const selectedCommits = await selectCommitsToReword(ctx);
+    if (!selectedCommits)
+        return;
+    const newMessages = await generateNewMessages(selectedCommits, ctx);
+    if (newMessages.size === 0) {
+        log.info('No messages changed.');
+        return;
+    }
+    await executeRebase(selectedCommits, newMessages, ctx);
+};
 //# sourceMappingURL=reword.js.map