smart-git-undo 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Larsen Cundric
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,120 @@
+# smart-git-undo
+
+A smart CLI tool that figures out what you probably want to undo. Just type `git undo`.
+
+No flags to remember, no man pages to read. It looks at your recent git state and does the right thing.
+
+## What it does
+
+```
+$ git commit -m "whoops"
+$ git undo
+
+🔍 Detected: Revert commit a1b2c3d ("whoops")
+   Type: commit
+
+✅ Reverted commit a1b2c3d ("whoops"). Changes are preserved in your working tree.
+```
+
+It detects and undoes these situations:
+
+| You just did... | `git undo` will... |
+|---|---|
+| `git add` files | Unstage them |
+| Started a merge with conflicts | `git merge --abort` |
+| Completed a rebase | Restore pre-rebase state from reflog |
+| Merged a branch | Undo the merge commit |
+| Deleted a branch | Restore it from reflog |
+| Made a commit | Soft reset (keeps your changes) |
+
+Detection is prioritized in that order — if you staged files and also have a recent commit, it unstages first.
+
+## Install
+
+```bash
+npm install -g smart-git-undo
+```
+
+Or run without installing:
+
+```bash
+npx smart-git-undo
+```
+
+Once installed, git finds it automatically as a subcommand:
+
+```bash
+git undo          # undo the last thing
+git redo          # went too far? redo it
+git undo --dry-run    # see what it would do without doing it
+git undo --history    # see your undo/redo history
+```
+
+## Usage
+
+### Undo
+
+```bash
+git undo
+```
+
+Analyzes your recent git state and performs the most likely undo. Commits are soft-reset so your changes stay in the working tree.
+
+### Dry run
+
+```bash
+git undo --dry-run
+```
+
+Shows what would be undone and the exact git command, without changing anything.
+
+```
+👁️  Dry run — nothing will be changed
+
+🔍 Detected: Revert commit a1b2c3d ("bad commit")
+   Type: commit
+
+   Would execute: git reset --soft HEAD~1
+```
+
+### Redo
+
+```bash
+git redo
+```
+
+Reverses the last undo. Useful when you undo too far.
+
+### History
+
+```bash
+git undo --history
+```
+
+Shows your full undo/redo timeline:
+
+```
+📜 Undo/Redo History
+
+   Actions (newest first):
+   ↪️  Redo: Reverted commit a1b2c3d: "bad commit" — 4/2/2026, 3:21:00 PM
+   ↩️  Reverted commit a1b2c3d: "bad commit" — 4/2/2026, 3:20:58 PM
+```
+
+## How it works
+
+1. **Detector** (`src/detector.js`) checks git state in priority order: staged files → in-progress merge → recent rebase → merge commit → deleted branch → recent commit
+2. **Actions** (`src/actions.js`) performs the undo safely — commits use soft reset to preserve changes, merges and rebases use hard reset
+3. **Stack** (`src/stack.js`) records every undo in `.git/undo-stack/stack.json` so redo and history work across sessions
+
+The undo stack lives inside `.git/` so it's per-repo and never gets committed.
+
+## Platform support
+
+- **macOS** — supported
+- **Linux** — supported
+- **Windows** — should work in Git Bash / WSL (not tested)
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "smart-git-undo",
+  "version": "1.0.0",
+  "description": "Smart CLI tool — type 'git undo' and it figures out what you probably want to undo",
+  "type": "module",
+  "keywords": [
+    "git",
+    "undo",
+    "redo",
+    "cli",
+    "revert",
+    "reset",
+    "developer-tools",
+    "terminal",
+    "reflog"
+  ],
+  "author": "Larsen Cundric",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/LarsenCundric/smart-git-undo.git"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "src/"
+  ],
+  "bin": {
+    "git-undo": "./src/index.js",
+    "git-redo": "./src/redo.js"
+  },
+  "scripts": {
+    "start": "node src/index.js",
+    "demo": "bash demo.sh"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0"
+  }
+}

package/src/actions.js

@@ -0,0 +1,132 @@
+import { git, getHeadSha, getShortSha, getCurrentBranch } from './git.js';
+import { recordUndo, recordRedo } from './stack.js';
+
+export function undoStaged(details) {
+  const { files } = details;
+  git('reset HEAD -- ' + files.map(f => `"${f}"`).join(' '));
+
+  recordUndo({
+    type: 'staged',
+    description: `Unstaged ${files.length} file(s)`,
+    restore: { files },
+  });
+
+  return `Unstaged ${files.length} file(s).`;
+}
+
+export function undoInProgressMerge(details) {
+  const { mergeHead, branch } = details;
+  git('merge --abort');
+
+  recordUndo({
+    type: 'in-progress-merge',
+    description: `Aborted merge from ${branch}`,
+    restore: { mergeHead, branch },
+  });
+
+  return `Aborted in-progress merge from ${branch}.`;
+}
+
+export function undoRebase(details) {
+  const { preRebaseSha, currentSha } = details;
+  const branch = getCurrentBranch();
+  git(`reset --hard ${preRebaseSha}`);
+
+  recordUndo({
+    type: 'rebase',
+    description: `Undid rebase on ${branch}`,
+    restore: { postRebaseSha: currentSha, branch },
+  });
+
+  return `Restored ${branch} to pre-rebase state (${getShortSha(preRebaseSha)}).`;
+}
+
+export function undoMerge(details) {
+  const { sha, message } = details;
+  git('reset --hard HEAD~1');
+
+  recordUndo({
+    type: 'merge',
+    description: `Undid merge: "${message}"`,
+    restore: { sha },
+  });
+
+  return `Undid merge commit (${getShortSha(sha)}): "${message}".`;
+}
+
+export function undoDeletedBranch(details) {
+  const { sha, branch } = details;
+  git(`branch ${branch} ${sha}`);
+
+  recordUndo({
+    type: 'deleted-branch',
+    description: `Restored branch "${branch}"`,
+    restore: { sha, branch },
+  });
+
+  return `Restored branch "${branch}" at ${getShortSha(sha)}.`;
+}
+
+export function undoCommit(details) {
+  const { sha, parentSha, message, shortSha } = details;
+  git('reset --soft HEAD~1');
+
+  recordUndo({
+    type: 'commit',
+    description: `Reverted commit ${shortSha}: "${message}"`,
+    restore: { sha, message },
+  });
+
+  return `Reverted commit ${shortSha} ("${message}"). Changes are preserved in your working tree.`;
+}
+
+export function redo(entry) {
+  const { type, restore } = entry;
+  let result;
+
+  switch (type) {
+    case 'staged':
+      git('add -- ' + restore.files.map(f => `"${f}"`).join(' '));
+      result = `Re-staged ${restore.files.length} file(s).`;
+      break;
+    case 'in-progress-merge':
+      git(`merge ${restore.mergeHead}`);
+      result = `Re-started merge from ${restore.branch}.`;
+      break;
+    case 'rebase':
+      git(`reset --hard ${restore.postRebaseSha}`);
+      result = `Restored post-rebase state on ${restore.branch}.`;
+      break;
+    case 'merge':
+      git(`reset --hard ${restore.sha}`);
+      result = `Restored merge commit ${getShortSha(restore.sha)}.`;
+      break;
+    case 'deleted-branch':
+      git(`branch -D ${restore.branch}`);
+      result = `Re-deleted branch "${restore.branch}".`;
+      break;
+    case 'commit':
+      git(`commit -m "${restore.message.replace(/"/g, '\\"')}"`);
+      result = `Re-committed: "${restore.message}".`;
+      break;
+    default:
+      return `Unknown undo type "${type}" — cannot redo.`;
+  }
+
+  recordRedo({ type, description: `Redo: ${entry.description}`, restore });
+  return result;
+}
+
+export function performUndo(detection) {
+  const { type, details } = detection;
+
+  switch (type) {
+    case 'staged': return undoStaged(details);
+    case 'in-progress-merge': return undoInProgressMerge(details);
+    case 'rebase': return undoRebase(details);
+    case 'merge': return undoMerge(details);
+    case 'deleted-branch': return undoDeletedBranch(details);
+    case 'commit': return undoCommit(details);
+    default: return `Unknown action type: ${type}`;
+  }
+}

package/src/detector.js

@@ -0,0 +1,189 @@
+import { git, gitLines, getCurrentBranch, getHeadSha, getShortSha, getCommitMessage } from './git.js';
+
+/**
+ * Analyzes recent git state and returns the most likely "undo" action.
+ * Priority order:
+ *   1. Staged files (user just ran git add)
+ *   2. In-progress merge (MERGE_HEAD exists)
+ *   3. Recent rebase (check reflog for rebase entries)
+ *   4. Recent merge commit (HEAD is a merge)
+ *   5. Recent branch deletion (check reflog)
+ *   6. Recent commit (most common case)
+ *
+ * Returns: { type, description, details } or null
+ */
+export function detect() {
+  // 1. Staged files?
+  const staged = detectStaged();
+  if (staged) return staged;
+
+  // 2. In-progress merge? (MERGE_HEAD present)
+  const mergingNow = detectInProgressMerge();
+  if (mergingNow) return mergingNow;
+
+  // 3. Recent rebase?
+  const rebase = detectRebase();
+  if (rebase) return rebase;
+
+  // 4. HEAD is a merge commit?
+  const merge = detectMergeCommit();
+  if (merge) return merge;
+
+  // 5. Deleted branch recently?
+  const branch = detectDeletedBranch();
+  if (branch) return branch;
+
+  // 6. Recent commit
+  const commit = detectCommit();
+  if (commit) return commit;
+
+  return null;
+}
+
+function detectStaged() {
+  const staged = gitLines('diff --cached --name-only', { allowFailure: true });
+  if (staged.length === 0) return null;
+
+  return {
+    type: 'staged',
+    description: `Unstage ${staged.length} file${staged.length > 1 ? 's' : ''}`,
+    details: { files: staged },
+  };
+}
+
+function detectInProgressMerge() {
+  const mergeHead = git('rev-parse MERGE_HEAD', { silent: true, allowFailure: true });
+  if (!mergeHead) return null;
+
+  const branch = git('name-rev --name-only --no-undefined MERGE_HEAD', { silent: true, allowFailure: true }) || getShortSha(mergeHead);
+
+  return {
+    type: 'in-progress-merge',
+    description: `Abort in-progress merge from ${branch}`,
+    details: { mergeHead, branch },
+  };
+}
+
+function detectRebase() {
+  // Check reflog for recent rebase finish (within last 10 entries)
+  const reflog = gitLines('reflog --format=%H:%gs -n 10', { allowFailure: true });
+
+  for (let i = 0; i < reflog.length; i++) {
+    const [sha, ...msgParts] = reflog[i].split(':');
+    const msg = msgParts.join(':');
+
+    if (/rebase.*finished|rebase.*onto/.test(msg)) {
+      // Find the pre-rebase state: the entry right before the rebase started
+      // Look for the reflog entry before the rebase sequence
+      const preRebase = findPreRebaseState(reflog, i);
+      if (preRebase) {
+        return {
+          type: 'rebase',
+          description: 'Undo recent rebase',
+          details: { preRebaseSha: preRebase, currentSha: getHeadSha() },
+        };
+      }
+    }
+  }
+
+  return null;
+}
+
+function findPreRebaseState(reflog, rebaseIdx) {
+  // Walk backwards from the rebase to find where HEAD was before
+  for (let i = rebaseIdx + 1; i < reflog.length; i++) {
+    const [sha, ...msgParts] = reflog[i].split(':');
+    const msg = msgParts.join(':');
+    // The entry just before the rebase operations is the pre-rebase state
+    if (!/rebase/.test(msg)) {
+      return sha;
+    }
+  }
+  // If all 10 entries are rebase, look further back
+  const deeper = gitLines('reflog --format=%H:%gs -n 50', { allowFailure: true });
+  for (const line of deeper) {
+    const [sha, ...msgParts] = line.split(':');
+    const msg = msgParts.join(':');
+    if (!/rebase/.test(msg)) {
+      return sha;
+    }
+  }
+  return null;
+}
+
+function detectMergeCommit() {
+  const parents = git('cat-file -p HEAD', { silent: true, allowFailure: true });
+  if (!parents) return null;
+
+  const parentLines = parents.split('\n').filter(l => l.startsWith('parent '));
+  if (parentLines.length < 2) return null; // not a merge
+
+  const headSha = getHeadSha();
+  const msg = getCommitMessage(headSha);
+
+  return {
+    type: 'merge',
+    description: `Undo merge commit: "${msg}"`,
+    details: { sha: headSha, message: msg },
+  };
+}
+
+function detectDeletedBranch() {
+  // Look in reflog for recent branch deletions
+  // When a branch is deleted, there's usually a reflog entry referencing it
+  const reflog = gitLines('reflog --format=%H:%gs -n 20', { allowFailure: true });
+
+  for (const line of reflog) {
+    const [sha, ...msgParts] = line.split(':');
+    const msg = msgParts.join(':');
+
+    // Branch delete shows up via the branch's last known reflog
+    // But we can also check stale branch references
+  }
+
+  // Better approach: check for recently deleted branches from all reflogs
+  const allRefs = git('for-each-ref --sort=-committerdate --format=%(refname:short) refs/heads/', { silent: true, allowFailure: true });
+
+  // Check if there are orphaned reflog entries that don't have matching branches
+  // This is complex — we'll look for the pattern in `git reflog` that mentions branch deletion
+  const fullReflog = gitLines('reflog --all --format=%gd:%H:%gs -n 30', { allowFailure: true });
+
+  for (const line of fullReflog) {
+    const parts = line.split(':');
+    if (parts.length >= 3) {
+      const msg = parts.slice(2).join(':');
+      if (/Branch: deleted/.test(msg) || /branch: Reset.*delete/.test(msg)) {
+        const sha = parts[1];
+        const branchMatch = msg.match(/refs\/heads\/(\S+)/);
+        const branchName = branchMatch ? branchMatch[1] : null;
+        if (branchName && sha) {
+          return {
+            type: 'deleted-branch',
+            description: `Restore deleted branch "${branchName}"`,
+            details: { sha, branch: branchName },
+          };
+        }
+      }
+    }
+  }
+
+  return null;
+}
+
+function detectCommit() {
+  const headSha = getHeadSha();
+  if (!headSha) return null;
+
+  // Make sure there's a parent (not the initial commit)
+  const parentSha = git('rev-parse HEAD~1', { silent: true, allowFailure: true });
+  if (!parentSha) return null;
+
+  const msg = getCommitMessage(headSha);
+  const short = getShortSha(headSha);
+
+  return {
+    type: 'commit',
+    description: `Revert commit ${short} ("${msg}")`,
+    details: { sha: headSha, parentSha, message: msg, shortSha: short },
+  };
+}

package/src/git.js

@@ -0,0 +1,48 @@
+import { execSync } from 'node:child_process';
+
+export function git(args, { silent = false, allowFailure = false } = {}) {
+  try {
+    return execSync(`git ${args}`, {
+      encoding: 'utf-8',
+      stdio: silent ? 'pipe' : ['pipe', 'pipe', 'pipe'],
+    }).trim();
+  } catch (err) {
+    if (allowFailure) return null;
+    throw err;
+  }
+}
+
+export function gitLines(args, opts) {
+  const out = git(args, { silent: true, ...opts });
+  if (!out) return [];
+  return out.split('\n').filter(Boolean);
+}
+
+export function getGitDir() {
+  return git('rev-parse --git-dir', { silent: true });
+}
+
+export function isInsideWorkTree() {
+  try {
+    git('rev-parse --is-inside-work-tree', { silent: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function getCurrentBranch() {
+  return git('rev-parse --abbrev-ref HEAD', { silent: true, allowFailure: true });
+}
+
+export function getHeadSha() {
+  return git('rev-parse HEAD', { silent: true, allowFailure: true });
+}
+
+export function getShortSha(sha) {
+  return git(`rev-parse --short ${sha}`, { silent: true, allowFailure: true });
+}
+
+export function getCommitMessage(sha) {
+  return git(`log -1 --format=%s ${sha}`, { silent: true, allowFailure: true });
+}

package/src/index.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+
+import { isInsideWorkTree } from './git.js';
+import { detect } from './detector.js';
+import { performUndo } from './actions.js';
+import { getHistory } from './stack.js';
+import { printDetection, printDryRun, printResult, printError, printNothing, printHistory } from './ui.js';
+
+const args = process.argv.slice(2);
+const dryRun = args.includes('--dry-run');
+const showHistory = args.includes('--history');
+
+try {
+  if (!isInsideWorkTree()) {
+    printError('Not inside a git repository.');
+    process.exit(1);
+  }
+
+  if (showHistory) {
+    printHistory(getHistory());
+    process.exit(0);
+  }
+
+  const detection = detect();
+
+  if (!detection) {
+    printNothing();
+    process.exit(0);
+  }
+
+  if (dryRun) {
+    printDryRun(detection);
+    process.exit(0);
+  }
+
+  printDetection(detection);
+  const result = performUndo(detection);
+  printResult(result);
+} catch (err) {
+  printError(err.message || String(err));
+  process.exit(1);
+}

package/src/redo.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+
+import { isInsideWorkTree } from './git.js';
+import { popRedoable } from './stack.js';
+import { redo } from './actions.js';
+import { printRedoResult, printError } from './ui.js';
+
+try {
+  if (!isInsideWorkTree()) {
+    printError('Not inside a git repository.');
+    process.exit(1);
+  }
+
+  const entry = popRedoable();
+
+  if (!entry) {
+    printError('Nothing to redo.');
+    process.exit(0);
+  }
+
+  const result = redo(entry);
+  printRedoResult(result);
+} catch (err) {
+  printError(err.message || String(err));
+  process.exit(1);
+}

package/src/stack.js

@@ -0,0 +1,70 @@
+import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { getGitDir } from './git.js';
+
+function getStackDir() {
+  const dir = join(getGitDir(), 'undo-stack');
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+function readJson(path, fallback) {
+  try {
+    return JSON.parse(readFileSync(path, 'utf-8'));
+  } catch {
+    return fallback;
+  }
+}
+
+function getStackPath() {
+  return join(getStackDir(), 'stack.json');
+}
+
+function loadStack() {
+  return readJson(getStackPath(), { done: [], redoable: [] });
+}
+
+function saveStack(stack) {
+  writeFileSync(getStackPath(), JSON.stringify(stack, null, 2));
+}
+
+/**
+ * Record that an undo was performed. The entry contains info to redo it.
+ * This pushes to the redoable stack (user can redo) and records in done (history).
+ */
+export function recordUndo(entry) {
+  const stack = loadStack();
+  const timestamped = { ...entry, timestamp: new Date().toISOString() };
+  stack.done.push(timestamped);
+  stack.redoable.push(timestamped);
+  saveStack(stack);
+}
+
+/**
+ * Pop the most recent redoable entry. Returns null if nothing to redo.
+ */
+export function popRedoable() {
+  const stack = loadStack();
+  const entry = stack.redoable.pop();
+  if (entry) {
+    saveStack(stack);
+  }
+  return entry || null;
+}
+
+/**
+ * Record that a redo was performed (goes into done history).
+ */
+export function recordRedo(entry) {
+  const stack = loadStack();
+  stack.done.push({ ...entry, timestamp: new Date().toISOString(), action: 'redo' });
+  saveStack(stack);
+}
+
+export function getHistory() {
+  const stack = loadStack();
+  return {
+    done: [...stack.done],
+    redoable: [...stack.redoable],
+  };
+}

package/src/ui.js

@@ -0,0 +1,135 @@
+import chalk from 'chalk';
+
+const ICONS = {
+  detect: '\u{1F50D}',
+  undo: '\u21A9\uFE0F ',
+  redo: '\u21AA\uFE0F ',
+  info: '\u2139\uFE0F ',
+  warn: '\u26A0\uFE0F ',
+  ok: '\u2705',
+  staged: '\u{1F4E6}',
+  commit: '\u{1F4DD}',
+  merge: '\u{1F500}',
+  rebase: '\u{1F504}',
+  branch: '\u{1F33F}',
+  history: '\u{1F4DC}',
+  dry: '\u{1F441}\uFE0F ',
+};
+
+export function printDetection(detection) {
+  const icon = getIcon(detection.type);
+  console.log();
+  console.log(chalk.cyan.bold(`${ICONS.detect} Detected: `) + chalk.white(detection.description));
+  console.log(chalk.dim(`   Type: ${detection.type}`));
+
+  if (detection.type === 'staged' && detection.details.files) {
+    const files = detection.details.files;
+    const shown = files.slice(0, 5);
+    for (const f of shown) {
+      console.log(chalk.dim(`   - ${f}`));
+    }
+    if (files.length > 5) {
+      console.log(chalk.dim(`   ... and ${files.length - 5} more`));
+    }
+  }
+}
+
+export function printDryRun(detection) {
+  console.log();
+  console.log(chalk.yellow.bold(`${ICONS.dry} Dry run — nothing will be changed`));
+  printDetection(detection);
+  console.log();
+  console.log(chalk.yellow(`   Would execute: `) + chalk.white(describeAction(detection)));
+  console.log();
+}
+
+export function printResult(message) {
+  console.log();
+  console.log(chalk.green.bold(`${ICONS.ok} `) + chalk.white(message));
+  console.log();
+}
+
+export function printRedoResult(message) {
+  console.log();
+  console.log(chalk.blue.bold(`${ICONS.redo} Redo: `) + chalk.white(message));
+  console.log();
+}
+
+export function printError(message) {
+  console.log();
+  console.log(chalk.red.bold(`${ICONS.warn} `) + chalk.red(message));
+  console.log();
+}
+
+export function printNothing() {
+  console.log();
+  console.log(chalk.yellow(`${ICONS.info} Nothing to undo.`));
+  console.log(chalk.dim('   No recent git action detected that can be undone.'));
+  console.log();
+}
+
+export function printHistory(history) {
+  const { done, redoable } = history;
+
+  console.log();
+  console.log(chalk.cyan.bold(`${ICONS.history} Undo/Redo History`));
+  console.log();
+
+  if (done.length === 0 && redoable.length === 0) {
+    console.log(chalk.dim('   No history yet.'));
+    console.log();
+    return;
+  }
+
+  if (done.length > 0) {
+    console.log(chalk.green.bold('   Actions') + chalk.dim(' (newest first):'));
+    for (let i = done.length - 1; i >= 0; i--) {
+      const e = done[i];
+      const time = new Date(e.timestamp).toLocaleString();
+      const icon = e.action === 'redo' ? ICONS.redo : ICONS.undo;
+      const color = e.action === 'redo' ? chalk.blue : chalk.green;
+      console.log(color(`   ${icon} ${e.description}`) + chalk.dim(` — ${time}`));
+    }
+    console.log();
+  }
+
+  if (redoable.length > 0) {
+    console.log(chalk.blue.bold('   Available to redo') + chalk.dim(` (${redoable.length}):`));
+    for (let i = redoable.length - 1; i >= 0; i--) {
+      const e = redoable[i];
+      console.log(chalk.blue(`   ${ICONS.redo} ${e.description}`));
+    }
+    console.log();
+  }
+}
+
+function getIcon(type) {
+  const map = {
+    staged: ICONS.staged,
+    'in-progress-merge': ICONS.merge,
+    rebase: ICONS.rebase,
+    merge: ICONS.merge,
+    'deleted-branch': ICONS.branch,
+    commit: ICONS.commit,
+  };
+  return map[type] || ICONS.info;
+}
+
+function describeAction(detection) {
+  switch (detection.type) {
+    case 'staged':
+      return `git reset HEAD -- <${detection.details.files.length} files>`;
+    case 'in-progress-merge':
+      return 'git merge --abort';
+    case 'rebase':
+      return `git reset --hard ${detection.details.preRebaseSha.slice(0, 7)}`;
+    case 'merge':
+      return 'git reset --hard HEAD~1';
+    case 'deleted-branch':
+      return `git branch ${detection.details.branch} ${detection.details.sha.slice(0, 7)}`;
+    case 'commit':
+      return 'git reset --soft HEAD~1';
+    default:
+      return '(unknown)';
+  }
+}