feat: amend the last commit from the graph

Add an amend flow reachable from two entry points — right-clicking the
uncommitted-changes row ("Amend '<branch/sha>'") or the most recent commit
row ("Amend Commit"). Both open a shared AmendModal and reveal the SCM view
(returning focus to the webview so the modal stays keyboard-interactive).

The modal lets the user keep or edit the message, set the date to now
(--date=now), reset the author (--reset-author), and exclude staged changes
(--only). It shows a live staged-file count styled like the conflict-detection
status (warning when 0), refreshed whenever the index changes, and warns in red
when the commit is already pushed.

Backend: GitService.amendCommit + amendCommit message/handler; openDiff gains a
staged flag; openScmView gains returnFocus.

Author: the0807

l10n/bundle.l10n.json

@@ -9,6 +9,7 @@
   "pushing": "Pushing...",
   "pushFailed": "Push failed: {0}",
   "checkedOut": "Checked out {0}",
+  "commitAmended": "Last commit amended",
   "checkoutFailed": "Checkout failed: {0}",
   "enterBranchName": "Enter branch name",
   "branchPlaceholder": "feature/my-branch",

l10n/bundle.l10n.ko.json

@@ -9,6 +9,7 @@
   "pushing": "Push 중...",
   "pushFailed": "Push 실패: {0}",
   "checkedOut": "{0}(으)로 checkout 완료",
+  "commitAmended": "마지막 커밋을 amend 했습니다",
   "checkoutFailed": "Checkout 실패: {0}",
   "enterBranchName": "브랜치 이름 입력",
   "branchPlaceholder": "feature/my-branch",

l10n/bundle.l10n.zh-cn.json

@@ -9,6 +9,7 @@
   "pushing": "正在推送...",
   "pushFailed": "推送失败：{0}",
   "checkedOut": "已检出 {0}",
+  "commitAmended": "已修正上一次提交",
   "checkoutFailed": "检出失败：{0}",
   "enterBranchName": "输入分支名称",
   "branchPlaceholder": "feature/my-branch",

src/git/__tests__/integration/mutations.integration.test.ts

@@ -134,6 +134,66 @@ describe('GitService integration — state mutations', () => {
     });
   });
 
+  describe('amendCommit', () => {
+    it('rewrites the last commit message when editing', async () => {
+      commit(repo.path, 'original message', { 'a.txt': 'a\n' });
+      await svc.amendCommit({ message: 'amended message' });
+      const tip = (await svc.log()).find(c => c.hash !== 'UNCOMMITTED')!;
+      expect(tip.subject).toBe('amended message');
+    });
+
+    it('folds staged changes into the last commit and keeps the message', async () => {
+      commit(repo.path, 'base', { 'a.txt': 'a\n' });
+      writeFileSync(join(repo.path, 'b.txt'), 'b\n');
+      runGit(repo.path, ['add', 'b.txt']);
+      await svc.amendCommit({ keepMessage: true });
+      const files = (await svc.showCommitFiles('HEAD')).map(f => f.path);
+      expect(files).toContain('b.txt');
+      const tip = (await svc.log()).find(c => c.hash !== 'UNCOMMITTED')!;
+      expect(tip.subject).toBe('base');
+    });
+
+    it('leaves unstaged changes out of the amend', async () => {
+      commit(repo.path, 'base', { 'a.txt': 'a\n' });
+      writeFileSync(join(repo.path, 'unstaged.txt'), 'u\n'); // never staged
+      await svc.amendCommit({ keepMessage: true });
+      const files = (await svc.showCommitFiles('HEAD')).map(f => f.path);
+      expect(files).not.toContain('unstaged.txt');
+    });
+
+    it('resets the author date to now with resetDate', async () => {
+      // helpers commit with GIT_AUTHOR_DATE=2024-01-01.
+      commit(repo.path, 'old', { 'a.txt': 'a\n' });
+      await svc.amendCommit({ keepMessage: true, resetDate: true });
+      const tip = (await svc.log()).find(c => c.hash !== 'UNCOMMITTED')!;
+      expect(tip.author.date.startsWith('2024-01-01')).toBe(false);
+    });
+
+    it('resets the author identity with resetAuthor', async () => {
+      // helpers author commits as author@example.com; repo config user is test@example.com.
+      commit(repo.path, 'by someone else', { 'a.txt': 'a\n' });
+      await svc.amendCommit({ keepMessage: true, resetAuthor: true });
+      const tip = (await svc.log()).find(c => c.hash !== 'UNCOMMITTED')!;
+      expect(tip.author.email).toBe('test@example.com');
+    });
+
+    it('excludes staged changes when only is set (message/metadata only)', async () => {
+      commit(repo.path, 'base', { 'a.txt': 'a\n' });
+      writeFileSync(join(repo.path, 'staged.txt'), 's\n');
+      runGit(repo.path, ['add', 'staged.txt']);
+      await svc.amendCommit({ message: 'reworded', only: true });
+      const files = (await svc.showCommitFiles('HEAD')).map(f => f.path);
+      expect(files).not.toContain('staged.txt');
+      const tip = (await svc.log()).find(c => c.hash !== 'UNCOMMITTED')!;
+      expect(tip.subject).toBe('reworded');
+    });
+
+    it('rejects an empty message when not keeping the message', async () => {
+      commit(repo.path, 'base', { 'a.txt': 'a\n' });
+      await expect(svc.amendCommit({ message: '   ' })).rejects.toThrow();
+    });
+  });
+
   describe('tag CRUD', () => {
     it('createTag (lightweight) at HEAD', async () => {
       commit(repo.path, 'init');

src/git/git-service.ts

@@ -1241,6 +1241,40 @@ export class GitService {
     await this.exec(['reset', `--${mode}`, ref]);
   }
 
+  /**
+   * Amend the last commit (HEAD). Folds whatever is currently staged into HEAD
+   * (standard `git commit --amend`); unstaged changes are left untouched.
+   * - keepMessage → `--no-edit` (reuse the existing message)
+   * - otherwise the (required) message replaces it via `-m`
+   * - resetDate → `--date=now` (author date to now)
+   * - resetAuthor → `--reset-author` (author identity + date to the current user/now)
+   * - only → `--only` (amend message/metadata only; do NOT fold staged changes in)
+   */
+  async amendCommit(options?: { message?: string; keepMessage?: boolean; resetDate?: boolean; resetAuthor?: boolean; only?: boolean }): Promise<void> {
+    const args = ['commit', '--amend'];
+    if (options?.only) {
+      args.push('--only');
+    }
+    if (options?.keepMessage) {
+      args.push('--no-edit');
+    } else {
+      const msg = (options?.message ?? '').trim();
+      if (!msg) {
+        throw new GitError('Commit message is required to amend', null, ['commit', '--amend']);
+      }
+      // A single -m value keeps embedded newlines verbatim (subject + body),
+      // and spawn passes it as one argv entry so no shell escaping is needed.
+      args.push('-m', msg);
+    }
+    if (options?.resetDate) {
+      args.push('--date=now');
+    }
+    if (options?.resetAuthor) {
+      args.push('--reset-author');
+    }
+    await this.exec(args);
+  }
+
   async stageFile(filePath: string): Promise<void> {
     this.assertSafePath(filePath, 'add');
     await this.exec(['add', '--', filePath]);

src/panels/MainPanel.ts

@@ -540,6 +540,22 @@ export class MainPanel {
         }
         case 'openScmView': {
           await vscode.commands.executeCommand('workbench.view.scm');
+          // When opened alongside the amend modal, return focus to the webview
+          // so the modal stays keyboard-interactive (Escape to close, typing in
+          // the message). Without this, focus stays in the SCM view.
+          if (message.payload?.returnFocus) {
+            this.panel.reveal(this.panel.viewColumn, false);
+          }
+          break;
+        }
+        case 'amendCommit': {
+          await this.gitService.amendCommit(message.payload);
+          this.post({
+            type: 'operationComplete',
+            payload: { operation: 'amendCommit', success: true },
+          });
+          vscode.window.showInformationMessage(vscode.l10n.t('commitAmended'));
+          await this.refreshAll();
           break;
         }
         case 'fetch': {

src/utils/message-bus.ts

@@ -36,7 +36,8 @@ export type WebviewMessage =
   | { type: 'removeRemote'; payload: { name: string } }
   | { type: 'openDiff'; payload: { file: string; commitHash?: string; ref1?: string; ref2?: string; staged?: boolean } }
   | { type: 'openFile'; payload: { file: string } }
-  | { type: 'openScmView' }
+  | { type: 'openScmView'; payload?: { returnFocus?: boolean } }
+  | { type: 'amendCommit'; payload: { message?: string; keepMessage?: boolean; resetDate?: boolean; resetAuthor?: boolean; only?: boolean } }
   | { type: 'stashDrop'; payload: { index: number } }
   | { type: 'stashRename'; payload: { index: number; message: string } }
   | { type: 'worktreeAdd'; payload: { path: string; branch?: string; newBranch?: string } }

webview-ui/src/App.svelte

@@ -24,6 +24,7 @@
   import StashApplyModal from './components/modals/StashApplyModal.svelte';
   import StashRenameModal from './components/modals/StashRenameModal.svelte';
   import StashSaveModal from './components/modals/StashSaveModal.svelte';
+import AmendModal from './components/modals/AmendModal.svelte';
   import RenameBranchModal from './components/modals/RenameBranchModal.svelte';
   import DeleteRemoteBranchModal from './components/modals/DeleteRemoteBranchModal.svelte';
   import DeleteRemoteTagModal from './components/modals/DeleteRemoteTagModal.svelte';
@@ -543,6 +544,17 @@
   />
 {/if}
 
+{#if modalStore.amend.show}
+  <AmendModal
+    hash={modalStore.amend.hash}
+    subject={modalStore.amend.subject}
+    message={modalStore.amend.message}
+    isPushed={modalStore.amend.isPushed}
+    onClose={() => { modalStore.closeAmend(); }}
+    onAmend={(opts) => { modalStore.closeAmend(); vscode.postMessage({ type: 'amendCommit', payload: opts }); }}
+  />
+{/if}
+
 {#if modalStore.checkoutRemote.show}
   <CheckoutRemoteModal
     remoteName={modalStore.checkoutRemote.remoteName}

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

@@ -644,6 +644,20 @@
         groups.push([{ label: t('graph.resetBranchToHere', { branch: currentBranch }), action: () => { resetTarget = commit.hash; resetMode = 'mixed'; showResetModal = true; } }]);
       }
 
+      // ── Amend (most recent commit / HEAD) ──
+      if (isHead) {
+        const fullMessage = commit.body ? `${commit.subject}\n\n${commit.body}` : commit.subject;
+        const cur = branchStore.currentBranch;
+        const isPushed = !!cur?.upstream && !cur?.upstreamGone && (cur?.ahead ?? 0) === 0;
+        groups.push([{
+          label: t('graph.amendCommit'),
+          action: () => {
+            modalStore.openAmend({ hash: commit.hash, subject: commit.subject, message: fullMessage, isPushed });
+            vscode.postMessage({ type: 'openScmView', payload: { returnFocus: true } });
+          },
+        }]);
+      }
+
       // ── Commit operations ──
       groups.push([
         {
@@ -732,6 +746,30 @@
     contextMenu = { x: e.clientX, y: e.clientY, items };
   }
 
+  // Context menu for the uncommitted-changes row: amend the last commit.
+  function onUncommittedContextMenu(e: MouseEvent) {
+    e.preventDefault();
+    const headCommit = commitStore.commits.find(c => c.refs.some(r => r.type === 'head'));
+    if (!headCommit) return; // nothing to amend (empty repo / no HEAD loaded)
+    const cur = branchStore.currentBranch;
+    // HEAD is "pushed" when the branch tracks an existing upstream and is not ahead of it.
+    const isPushed = !!cur?.upstream && !cur?.upstreamGone && (cur?.ahead ?? 0) === 0;
+    const fullMessage = headCommit.body ? `${headCommit.subject}\n\n${headCommit.body}` : headCommit.subject;
+    const ref = cur?.name ?? headCommit.abbreviatedHash;
+    contextMenu = {
+      x: e.clientX,
+      y: e.clientY,
+      items: [{
+        label: t('graph.amendRef', { ref }),
+        action: () => {
+          contextMenu = null;
+          modalStore.openAmend({ hash: headCommit.hash, subject: headCommit.subject, message: fullMessage, isPushed });
+          vscode.postMessage({ type: 'openScmView', payload: { returnFocus: true } });
+        },
+      }],
+    };
+  }
+
   function formatDate(dateStr: string): string {
     const d = new Date(dateStr);
     const year = d.getFullYear();
@@ -906,7 +944,7 @@
                 }
               }
             }}
-            oncontextmenu={(e) => { if (commit.hash !== 'UNCOMMITTED') onCommitContextMenu(e, commit); }}
+            oncontextmenu={(e) => { if (commit.hash === 'UNCOMMITTED') onUncommittedContextMenu(e); else onCommitContextMenu(e, commit); }}
             use:tooltip={commit.hash === 'UNCOMMITTED' ? t('graph.clickToOpenScm') : ''}
             role="row"
             tabindex={0}

webview-ui/src/components/graph/__tests__/CommitGraph.test.ts

@@ -104,6 +104,60 @@ describe('CommitGraph smoke', () => {
     expect(uiStore.selectedCommitHash).toBeNull();
   });
 
+  it('right-clicking the UNCOMMITTED row opens an Amend menu, then the amend modal + SCM', async () => {
+    const { modalStore } = await import('../../../lib/stores/modals.svelte');
+    const head = makeCommit('h1', 'first');
+    head.refs = [{ type: 'head', name: 'main' }];
+    commitStore.setData(makeGraphData([
+      makeCommit('UNCOMMITTED', 'Uncommitted changes'),
+      head,
+    ]));
+    branchStore.branches = [
+      { name: 'main', current: true, ahead: 1, behind: 0, hash: 'h1' },
+    ];
+    const { container } = render(CommitGraph, {});
+    await tick();
+    globalThis.__postedMessages = [];
+    const row = container.querySelectorAll<HTMLElement>('.commit-row')[0];
+    await fireEvent.contextMenu(row, { clientX: 10, clientY: 10 });
+    await tick();
+    // The single menu item is "Amend '{ref}'" (ref = current branch); click it.
+    const item = Array.from(container.querySelectorAll<HTMLElement>('*'))
+      .find(el => el.children.length === 0 && /^amend 'main'$/i.test((el.textContent ?? '').trim()));
+    expect(item).toBeTruthy();
+    await fireEvent.click(item!);
+    await tick();
+    expect(modalStore.amend.show).toBe(true);
+    expect(modalStore.amend.hash).toBe('h1');
+    expect(globalThis.__postedMessages.some(m => (m.data as { type?: string }).type === 'openScmView')).toBe(true);
+    modalStore.closeAmend();
+  });
+
+  it('right-clicking the HEAD commit opens the amend modal + SCM', async () => {
+    const { modalStore } = await import('../../../lib/stores/modals.svelte');
+    const head = makeCommit('h2', 'latest', ['h1']);
+    head.refs = [{ type: 'head', name: 'main' }];
+    commitStore.setData(makeGraphData([head, makeCommit('h1', 'first')]));
+    branchStore.branches = [
+      { name: 'main', current: true, ahead: 1, behind: 0, hash: 'h2' },
+    ];
+    const { container } = render(CommitGraph, {});
+    await tick();
+    globalThis.__postedMessages = [];
+    const row = container.querySelectorAll<HTMLElement>('.commit-row')[0]; // HEAD row
+    await fireEvent.contextMenu(row, { clientX: 10, clientY: 10 });
+    await tick();
+    const item = Array.from(container.querySelectorAll<HTMLElement>('*'))
+      .find(el => el.children.length === 0 && /^amend commit$/i.test((el.textContent ?? '').trim()));
+    expect(item).toBeTruthy();
+    await fireEvent.click(item!);
+    await tick();
+    expect(modalStore.amend.show).toBe(true);
+    expect(modalStore.amend.hash).toBe('h2');
+    expect(globalThis.__postedMessages.some(m => (m.data as { type?: string }).type === 'openScmView')).toBe(true);
+    modalStore.closeAmend();
+  });
+
   it('does not crash on a branch-set fingerprint cache hit (same commits, same branch)', async () => {
     // First mount populates the cache.
     commitStore.setData(makeGraphData([