feat(rebase): add classic terminal interactive rebase mode (#58)

Add a gitGraphPlus.interactiveRebase.mode setting ("ui" | "classic",
default "ui"). In classic mode the graph's interactive-rebase entry points
post a runClassicRebase message instead of opening the GUI modal, and the
extension runs `git rebase -i <base>` in a dedicated "Git Graph+ Rebase"
integrated terminal so the user's own Git editor edits the rebase-todo. The
existing .git file-watcher handles the refresh and conflict/continue banner.

The mode is mirrored to the webview (init + config change), like the locale
pattern. A pure buildClassicRebaseCommand validates the base as a hex hash
(injection guard) and uses bare `git` on PATH, which works across
PowerShell/bash/cmd. The "ui" default keeps existing behavior unchanged.

Author: the0807

package.json

@@ -409,6 +409,16 @@
           "minimum": 1,
           "markdownDescription": "Number of additional commits fetched each time the **Load more commits** button is clicked."
         },
+        "gitGraphPlus.interactiveRebase.mode": {
+          "type": "string",
+          "enum": ["ui", "classic"],
+          "enumDescriptions": [
+            "Open the built-in graphical interactive-rebase editor",
+            "Run git rebase -i in the integrated terminal using your configured Git editor"
+          ],
+          "default": "ui",
+          "markdownDescription": "How **Interactive Rebase** opens: the built-in GUI editor (`ui`), or the classic `git rebase -i` flow in the integrated terminal (`classic`), which uses your configured Git editor (e.g. vim, nano, `code --wait`)."
+        },
         "gitGraphPlus.graphSortOrder": {
           "type": "string",
           "enum": [

src/git/__tests__/classic-rebase.test.ts

@@ -0,0 +1,29 @@
+import { describe, it, expect } from 'vitest';
+import { normalizeInteractiveRebaseMode, buildClassicRebaseCommand } from '../classic-rebase';
+
+describe('normalizeInteractiveRebaseMode', () => {
+  it('returns "classic" only for the exact string', () => {
+    expect(normalizeInteractiveRebaseMode('classic')).toBe('classic');
+  });
+  it('falls back to "ui" for anything else', () => {
+    expect(normalizeInteractiveRebaseMode('ui')).toBe('ui');
+    expect(normalizeInteractiveRebaseMode('CLASSIC')).toBe('ui');
+    expect(normalizeInteractiveRebaseMode(undefined)).toBe('ui');
+    expect(normalizeInteractiveRebaseMode(42)).toBe('ui');
+  });
+});
+
+describe('buildClassicRebaseCommand', () => {
+  it('builds a bare-git rebase -i command for a valid hash', () => {
+    expect(buildClassicRebaseCommand('a1b2c3d')).toBe('git rebase -i a1b2c3d');
+  });
+  it('accepts a full 40-char hash', () => {
+    const full = '0123456789abcdef0123456789abcdef01234567';
+    expect(buildClassicRebaseCommand(full)).toBe(`git rebase -i ${full}`);
+  });
+  it('returns null for non-hash input (injection guard)', () => {
+    expect(buildClassicRebaseCommand('a1b2c3d; rm -rf /')).toBeNull();
+    expect(buildClassicRebaseCommand('main')).toBeNull();
+    expect(buildClassicRebaseCommand('')).toBeNull();
+  });
+});

src/git/classic-rebase.ts

@@ -0,0 +1,24 @@
+/** Which interactive-rebase experience the user gets. */
+export type InteractiveRebaseMode = 'ui' | 'classic';
+
+/** Map a raw setting value to a valid mode, defaulting to the GUI. */
+export function normalizeInteractiveRebaseMode(raw: unknown): InteractiveRebaseMode {
+  return raw === 'classic' ? 'classic' : 'ui';
+}
+
+/**
+ * Build the shell command for a classic `git rebase -i <base>` run in a
+ * terminal. Returns null when `base` is not a commit hash - the value is
+ * spliced into a shell command, so anything else is rejected as an injection
+ * guard. `base` always comes from our own commit data in the normal path.
+ *
+ * Uses bare `git` (resolved on the terminal's PATH) rather than an absolute
+ * binary path: a quoted, spaced path is parsed as a string literal in
+ * PowerShell (VS Code's default Windows shell) and silently never runs. Bare
+ * `git` works across PowerShell/bash/cmd, and a missing git surfaces a visible
+ * "command not found" instead of a silent no-op.
+ */
+export function buildClassicRebaseCommand(base: string): string | null {
+  if (!/^[0-9a-fA-F]{4,40}$/.test(base)) { return null; }
+  return `git rebase -i ${base}`;
+}

src/panels/MainPanel.ts

@@ -5,7 +5,8 @@ import { GitService, GitError } from '../git/git-service';
 import { formatGitError, isAuthFailure, transportFromRemoteUrl } from '../git/git-error-formatter';
 import { splitUpstreamRef } from '../git/git-parser';
 import { samePath } from '../utils/path';
-import { readTimeoutMs, readInitialCommitCount, readLoadMoreCommitCount } from '../utils/config';
+import { readTimeoutMs, readInitialCommitCount, readLoadMoreCommitCount, readInteractiveRebaseMode } from '../utils/config';
+import { buildClassicRebaseCommand } from '../git/classic-rebase';
 import { buildFullGraph } from '../git/git-graph-builder';
 import { compileBranchColorRules, makeBranchColorResolver } from '../git/branch-color-resolver';
 import { resolveGraphColors } from '../git/graph-colors';
@@ -213,6 +214,9 @@ export class MainPanel {
           const locale = localeSetting === 'auto' ? (vscode.env.language || 'en') : localeSetting;
           this.post({ type: 'setLocale', payload: { locale } });
         }
+        if (e.affectsConfiguration('gitGraphPlus.interactiveRebase.mode')) {
+          this.post({ type: 'setInteractiveRebaseMode', payload: { mode: readInteractiveRebaseMode() } });
+        }
         if (e.affectsConfiguration('gitGraphPlus.defaults')) {
           this.post({ type: 'setDefaults', payload: this.readModalDefaults() });
         }
@@ -251,6 +255,7 @@ export class MainPanel {
     this.post({ type: 'setBadgeBarThickness', payload: { width: this.readBadgeBarWidth() } });
     this.post({ type: 'setGraphColors', payload: { colors: this.readGraphColors() } });
     this.post({ type: 'setLoadMoreCount', payload: { count: readLoadMoreCommitCount() } });
+    this.post({ type: 'setInteractiveRebaseMode', payload: { mode: readInteractiveRebaseMode() } });
     void this.postCommitLinkRules();
 
     this.panel.webview.onDidReceiveMessage(
@@ -958,6 +963,17 @@ export class MainPanel {
           await this.refreshAll();
           break;
         }
+        case 'runClassicRebase': {
+          const command = buildClassicRebaseCommand(message.payload.base);
+          if (!command) { break; }
+          const name = 'Git Graph+ Rebase';
+          const terminal =
+            vscode.window.terminals.find(t => t.name === name && t.exitStatus === undefined)
+            ?? vscode.window.createTerminal({ name, cwd: this.repoPath });
+          terminal.show();
+          terminal.sendText(command, true);
+          break;
+        }
         case 'getRebaseCommits': {
           const rebaseCommits = await this.gitService.getRebaseCommits(message.payload.base);
           this.post({ type: 'rebaseCommitsData', payload: { base: message.payload.base, commits: rebaseCommits } });

src/utils/config.ts

@@ -1,4 +1,5 @@
 import * as vscode from 'vscode';
+import { normalizeInteractiveRebaseMode, type InteractiveRebaseMode } from '../git/classic-rebase';
 
 /**
  * Reads the `gitGraphPlus.timeout` setting (in seconds) and returns the
@@ -35,3 +36,14 @@ export function readInitialCommitCount(): number {
 export function readLoadMoreCommitCount(): number {
   return readPositiveIntSetting('loadMoreCommitCount', DEFAULT_LOAD_MORE_COMMIT_COUNT);
 }
+
+/**
+ * Reads `gitGraphPlus.interactiveRebase.mode` — whether interactive rebase
+ * opens the GUI editor (`ui`, default) or runs classic `git rebase -i` in the
+ * integrated terminal (`classic`).
+ */
+export function readInteractiveRebaseMode(): InteractiveRebaseMode {
+  return normalizeInteractiveRebaseMode(
+    vscode.workspace.getConfiguration('gitGraphPlus').get<string>('interactiveRebase.mode', 'ui'),
+  );
+}

src/utils/message-bus.ts

@@ -49,6 +49,7 @@ export type WebviewMessage =
   | { type: 'continueRebase' }
   | { type: 'skipRebase' }
   | { type: 'interactiveRebase'; payload: { base: string; todos: Array<{ action: string; hash: string; subject: string; message?: string }>; squashCount?: number } }
+  | { type: 'runClassicRebase'; payload: { base: string } }
   | { type: 'getRebaseCommits'; payload: { base: string } }
   | { type: 'reset'; payload: { ref: string; mode: 'soft' | 'mixed' | 'hard' } }
   | { type: 'push'; payload: { remote?: string; branch?: string; force?: 'with-lease' | 'force'; setUpstream?: boolean } }
@@ -151,6 +152,7 @@ export type ExtensionMessage =
   | { type: 'lfsData'; payload: { files: Array<{ oid: string; path: string }>; locks: Array<{ path: string; owner: string; id: string }> } }
   | { type: 'tagDetailsData'; payload: { name: string; hash: string; message?: string; isAnnotated: boolean } }
   | { type: 'setLocale'; payload: { locale: string; homeDir?: string } }
+  | { type: 'setInteractiveRebaseMode'; payload: { mode: 'ui' | 'classic' } }
   | { type: 'setDefaults'; payload: ModalDefaults }
   | { type: 'setLoadMoreCount'; payload: { count: number } }
   | { type: 'setBadgeBarThickness'; payload: { width: number } }

webview-ui/src/App.svelte

@@ -113,6 +113,9 @@ import AmendModal from './components/modals/AmendModal.svelte';
         case 'setLoadMoreCount':
           uiStore.loadMoreCount = msg.payload.count;
           break;
+        case 'setInteractiveRebaseMode':
+          uiStore.interactiveRebaseMode = msg.payload.mode;
+          break;
         case 'setGraphColors':
           graphColorsStore.set(msg.payload.colors);
           break;

webview-ui/src/components/graph/CommitGraph.svelte

@@ -33,6 +33,7 @@
   import { resolveDrop, dragRebaseMessage, dragMergeMessage } from '../../lib/utils/dragDrop';
   import { computeNavigationTarget, computeScrollTop, computeJumpTarget, isRowOffscreen, type ScrollAlign } from '../../lib/graph-navigation';
   import LinkifiedText from '../common/LinkifiedText.svelte';
+  import { dispatchInteractiveRebase } from '../../lib/interactive-rebase';
 
 
   /**
@@ -694,6 +695,15 @@
     }
   }
 
+  // Route an interactive-rebase request to the GUI modal or the classic
+  // terminal flow, per the gitGraphPlus.interactiveRebase.mode setting.
+  function openInteractiveRebase(base: string) {
+    dispatchInteractiveRebase(base, uiStore.interactiveRebaseMode, {
+      openModal: (b) => { interactiveRebaseBase = b; },
+      runClassic: (b) => vscode.postMessage({ type: 'runClassicRebase', payload: { base: b } }),
+    });
+  }
+
   // Entry for "Interactive Rebase selected commits". `chain` is oldest→newest
   // (getSquashChain); base = parent of the oldest selected commit.
   function startSelectionRebase(chain: Commit[], candidates: string[]) {
@@ -705,7 +715,7 @@
       // stash before a no-op switch).
       const hasUncommitted = commitStore.commits.some(c => c.hash === 'UNCOMMITTED');
       if (!hasUncommitted) {
-        interactiveRebaseBase = base;
+        openInteractiveRebase(base);
         uiStore.exitMultiSelect();
         contextMenuHash = null;
       } else {
@@ -726,8 +736,9 @@
       const msg = event.data;
       if (!pendingRebaseBase) { return; }
       if (msg?.type === 'operationComplete' && msg.payload?.operation === 'checkout') {
-        interactiveRebaseBase = pendingRebaseBase;
+        const resumeBase = pendingRebaseBase;
         pendingRebaseBase = null;
+        openInteractiveRebase(resumeBase);
         uiStore.exitMultiSelect();
         contextMenuHash = null;
       } else if (msg?.type === 'error') {
@@ -1047,7 +1058,7 @@
       if (!isOnCurrentBranch) {
         branchOps.push({ label: t('graph.rebaseTo', { branch: currentBranch }), action: () => { rebaseTarget = commit.hash; showRebaseModal = true; } });
       }
-      branchOps.push({ label: t('graph.interactiveRebaseTo', { branch: currentBranch }), action: () => { interactiveRebaseBase = commit.hash; } });
+      branchOps.push({ label: t('graph.interactiveRebaseTo', { branch: currentBranch }), action: () => { openInteractiveRebase(commit.hash); } });
       groups.push(branchOps);
 
       // ── Reset ──

webview-ui/src/lib/__tests__/interactive-rebase.test.ts

@@ -0,0 +1,20 @@
+import { describe, it, expect, vi } from 'vitest';
+import { dispatchInteractiveRebase } from '../interactive-rebase';
+
+describe('dispatchInteractiveRebase', () => {
+  it('opens the modal in ui mode and does not run classic', () => {
+    const openModal = vi.fn();
+    const runClassic = vi.fn();
+    dispatchInteractiveRebase('abc1234', 'ui', { openModal, runClassic });
+    expect(openModal).toHaveBeenCalledWith('abc1234');
+    expect(runClassic).not.toHaveBeenCalled();
+  });
+
+  it('runs classic in classic mode and does not open the modal', () => {
+    const openModal = vi.fn();
+    const runClassic = vi.fn();
+    dispatchInteractiveRebase('abc1234', 'classic', { openModal, runClassic });
+    expect(runClassic).toHaveBeenCalledWith('abc1234');
+    expect(openModal).not.toHaveBeenCalled();
+  });
+});

webview-ui/src/lib/interactive-rebase.ts

@@ -0,0 +1,15 @@
+import type { InteractiveRebaseMode } from './types';
+
+/**
+ * Route an interactive-rebase request to the GUI modal or the classic terminal
+ * flow based on the user's mode. Keeps the branch logic out of the component so
+ * it is unit-testable.
+ */
+export function dispatchInteractiveRebase(
+  base: string,
+  mode: InteractiveRebaseMode,
+  handlers: { openModal: (base: string) => void; runClassic: (base: string) => void },
+): void {
+  if (mode === 'classic') { handlers.runClassic(base); }
+  else { handlers.openModal(base); }
+}