Refine workspace git panel interactions

Author: pallyoung

packages/core/src/domain/types.ts

@@ -103,9 +103,20 @@ export interface GitStatus {
   deleted: GitFileChange[];
 }
 
+export type GitChangeStatus = "added" | "modified" | "deleted" | "renamed" | "untracked";
+
 export interface GitFileChange {
   path: string;
   oldPath?: string; // for renames
+  status?: GitChangeStatus;
+}
+
+export interface GitCommitSummary {
+  sha: string;
+  shortSha: string;
+  subject: string;
+  authorName: string;
+  authoredAt: number;
 }
 
 export interface GitBranch {

packages/server/src/__tests__/git-commands.test.ts

@@ -131,6 +131,64 @@ describe("Git Commands", () => {
     expect((result.data as { diff: string }).diff).toContain("+notes");
   });
 
+  it("returns recent commit history for git.log", async () => {
+    await execFileAsync("git", ["add", "."], { cwd: testDir });
+    await execFileAsync("git", ["commit", "-m", "Refresh command surface"], { cwd: testDir });
+
+    const result = await dispatch(
+      {
+        kind: "command",
+        id: "git-log-1",
+        op: "git.log",
+        args: {
+          workspaceId,
+          limit: 5,
+        },
+      },
+      ctx
+    );
+
+    expect(result.ok).toBe(true);
+    expect(result.data).toEqual(
+      expect.objectContaining({
+        entries: expect.arrayContaining([
+          expect.objectContaining({
+            subject: "Refresh command surface",
+            authorName: "Test",
+          }),
+        ]),
+      })
+    );
+  });
+
+  it("returns a commit patch for git.show", async () => {
+    await execFileAsync("git", ["add", "."], { cwd: testDir });
+    await execFileAsync("git", ["commit", "-m", "Refresh command surface"], { cwd: testDir });
+    const { stdout: headSha } = await execFileAsync("git", ["rev-parse", "HEAD"], { cwd: testDir });
+
+    const result = await dispatch(
+      {
+        kind: "command",
+        id: "git-show-1",
+        op: "git.show",
+        args: {
+          workspaceId,
+          sha: headSha.trim(),
+        },
+      },
+      ctx
+    );
+
+    expect(result.ok).toBe(true);
+    expect(result.data).toEqual(
+      expect.objectContaining({
+        diff: expect.stringContaining("Refresh command surface"),
+      })
+    );
+    expect((result.data as { diff: string }).diff).toContain("+export const value = 2;");
+    expect((result.data as { diff: string }).diff).toContain("-export const value = 1;");
+  });
+
   it("discards modified tracked files", async () => {
     const result = await dispatch(
       {

packages/server/src/__tests__/git/cli.test.ts

@@ -11,6 +11,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import {
   classifyGitAuthFailure,
   GitError,
+  getGitHistory,
   getGitStatus,
   runGit,
   runGitFetch,
@@ -71,7 +72,7 @@ describe("runGit", () => {
 
     const status = await getGitStatus(testDir);
 
-    expect(status.deleted).toEqual([{ path: "docs/验收报告/phase 1/a b.txt" }]);
+    expect(status.deleted).toEqual([{ path: "docs/验收报告/phase 1/a b.txt", status: "deleted" }]);
     await expect(
       execFileAsync("git", ["add", "--", status.deleted[0]?.path ?? ""], { cwd: testDir })
     ).resolves.toBeDefined();
@@ -638,8 +639,8 @@ describe("getGitStatus", () => {
     const status = await getGitStatus(testDir);
 
     expect(status.untracked).toEqual([
-      { path: "docs/help/README.md" },
-      { path: "docs/help/assets/logo.png" },
+      { path: "docs/help/README.md", status: "untracked" },
+      { path: "docs/help/assets/logo.png", status: "untracked" },
     ]);
 
     await rm(testDir, { recursive: true, force: true });
@@ -681,6 +682,82 @@ describe("getGitStatus", () => {
   });
 });
 
+describe("getGitHistory", () => {
+  it("returns recent commits in reverse chronological order with author and timestamp", async () => {
+    const testDir = await mkdtemp(join(tmpdir(), "git-history-"));
+    await execFileAsync("git", ["init"], { cwd: testDir });
+    await execFileAsync("git", ["config", "user.name", "Test"], { cwd: testDir });
+    await execFileAsync("git", ["config", "user.email", "test@example.com"], { cwd: testDir });
+
+    await writeFile(join(testDir, "file.txt"), "one\n");
+    await execFileAsync("git", ["add", "."], { cwd: testDir });
+    await execFileAsync("git", ["commit", "-m", "first commit"], { cwd: testDir });
+
+    await writeFile(join(testDir, "file.txt"), "two\n");
+    await execFileAsync("git", ["add", "."], { cwd: testDir });
+    await execFileAsync("git", ["commit", "-m", "second commit"], { cwd: testDir });
+
+    const history = await getGitHistory(testDir, 5);
+
+    expect(history).toHaveLength(2);
+    expect(history[0]).toEqual(
+      expect.objectContaining({
+        subject: "second commit",
+        authorName: "Test",
+      })
+    );
+    expect(history[0]?.sha).toHaveLength(40);
+    expect(history[0]?.shortSha).toHaveLength(7);
+    expect(history[0]?.authoredAt).toBeTypeOf("number");
+    expect(history[0]!.authoredAt).toBeGreaterThanOrEqual(history[1]!.authoredAt);
+    expect(history[1]).toEqual(
+      expect.objectContaining({
+        subject: "first commit",
+        authorName: "Test",
+      })
+    );
+
+    await rm(testDir, { recursive: true, force: true });
+  });
+
+  it("returns an empty list for repositories without commits", async () => {
+    const testDir = await mkdtemp(join(tmpdir(), "git-history-empty-"));
+    await execFileAsync("git", ["init"], { cwd: testDir });
+
+    await expect(getGitHistory(testDir, 5)).resolves.toEqual([]);
+
+    await rm(testDir, { recursive: true, force: true });
+  });
+});
+
+describe("getGitCommitDiff", () => {
+  it("returns the requested commit patch with metadata", async () => {
+    const testDir = await mkdtemp(join(tmpdir(), "git-show-"));
+    await execFileAsync("git", ["init"], { cwd: testDir });
+    await execFileAsync("git", ["config", "user.name", "Test"], { cwd: testDir });
+    await execFileAsync("git", ["config", "user.email", "test@example.com"], { cwd: testDir });
+
+    await writeFile(join(testDir, "file.txt"), "one\n");
+    await execFileAsync("git", ["add", "."], { cwd: testDir });
+    await execFileAsync("git", ["commit", "-m", "first commit"], { cwd: testDir });
+
+    await writeFile(join(testDir, "file.txt"), "two\n");
+    await execFileAsync("git", ["add", "."], { cwd: testDir });
+    await execFileAsync("git", ["commit", "-m", "second commit"], { cwd: testDir });
+
+    const { stdout } = await execFileAsync("git", ["rev-parse", "HEAD"], { cwd: testDir });
+    const { getGitCommitDiff } = await import("../../git/cli.js");
+    const diff = await getGitCommitDiff(testDir, stdout.trim());
+
+    expect(diff).toContain("second commit");
+    expect(diff).toContain("diff --git a/file.txt b/file.txt");
+    expect(diff).toContain("-one");
+    expect(diff).toContain("+two");
+
+    await rm(testDir, { recursive: true, force: true });
+  });
+});
+
 describe("runGitCheckout", () => {
   let testDir: string;
   let remoteDir: string;

packages/server/src/__tests__/git/status-parser.test.ts

@@ -42,7 +42,9 @@ describe("parseStatus", () => {
     const status = parseStatus(porcelain);
     expect(status.untracked).toHaveLength(2);
     expect(status.untracked[0].path).toBe("file1.txt");
+    expect(status.untracked[0].status).toBe("untracked");
     expect(status.untracked[1].path).toBe("file2.txt");
+    expect(status.untracked[1].status).toBe("untracked");
   });
 
   it("should parse modified files", () => {
@@ -51,6 +53,7 @@ describe("parseStatus", () => {
     const status = parseStatus(porcelain);
     expect(status.modified).toHaveLength(1);
     expect(status.modified[0].path).toBe("file.txt");
+    expect(status.modified[0].status).toBe("modified");
   });
 
   it("should parse staged files", () => {
@@ -59,6 +62,7 @@ describe("parseStatus", () => {
     const status = parseStatus(porcelain);
     expect(status.staged).toHaveLength(1);
     expect(status.staged[0].path).toBe("file.txt");
+    expect(status.staged[0].status).toBe("modified");
   });
 
   it("should parse unstaged deleted files", () => {
@@ -67,6 +71,7 @@ describe("parseStatus", () => {
     const status = parseStatus(porcelain);
     expect(status.deleted).toHaveLength(1);
     expect(status.deleted[0].path).toBe("file.txt");
+    expect(status.deleted[0].status).toBe("deleted");
   });
 
   it("should treat staged deletions as staged changes", () => {
@@ -75,6 +80,7 @@ describe("parseStatus", () => {
     const status = parseStatus(porcelain);
     expect(status.staged).toHaveLength(1);
     expect(status.staged[0].path).toBe("file.txt");
+    expect(status.staged[0].status).toBe("deleted");
     expect(status.deleted).toHaveLength(0);
   });
 
@@ -85,6 +91,7 @@ describe("parseStatus", () => {
     expect(status.staged).toHaveLength(1);
     expect(status.staged[0].path).toBe("new.txt");
     expect(status.staged[0].oldPath).toBe("old.txt");
+    expect(status.staged[0].status).toBe("renamed");
   });
 
   it("should parse NUL-delimited records with raw paths", () => {
@@ -100,8 +107,10 @@ describe("parseStatus", () => {
     expect(status.branch).toBe("main");
     expect(status.ahead).toBe(1);
     expect(status.behind).toBe(2);
-    expect(status.deleted).toEqual([{ path: "docs/验收报告/phase 1/a b.txt" }]);
-    expect(status.untracked).toEqual([{ path: "docs/验收报告/phase 1/c d.txt" }]);
+    expect(status.deleted).toEqual([{ path: "docs/验收报告/phase 1/a b.txt", status: "deleted" }]);
+    expect(status.untracked).toEqual([
+      { path: "docs/验收报告/phase 1/c d.txt", status: "untracked" },
+    ]);
   });
 
   it("should parse NUL-delimited renamed files with spaces and non-ascii paths", () => {
@@ -117,6 +126,20 @@ describe("parseStatus", () => {
       {
         path: "docs/验收报告/phase 1/c d.txt",
         oldPath: "docs/验收报告/phase 1/a b.txt",
+        status: "renamed",
+      },
+    ]);
+  });
+
+  it("parses staged additions with an added status marker", () => {
+    const porcelain = `# branch.head main
+1 A. N... 000000 100644 100644 000000 abc123 new-file.ts`;
+    const status = parseStatus(porcelain);
+
+    expect(status.staged).toEqual([
+      {
+        path: "new-file.ts",
+        status: "added",
       },
     ]);
   });

packages/server/src/commands/git.ts

@@ -7,6 +7,8 @@ import {
   commitChanges,
   discardChanges,
   GitAuthError,
+  getGitCommitDiff,
+  getGitHistory,
   getGitStatus,
   runGitCheckout,
   runGitCreateBranch,
@@ -96,6 +98,44 @@ registerCommand(
   }
 );
 
+// git.log
+registerCommand(
+  "git.log",
+  z.object({
+    workspaceId: z.string(),
+    limit: z.number().int().min(1).max(50).optional(),
+  }),
+  async (args, ctx) => {
+    const workspace = ctx.workspaceMgr.get(args.workspaceId);
+    if (!workspace) {
+      throw { code: "workspace_not_found", message: `Workspace not found: ${args.workspaceId}` };
+    }
+
+    return {
+      entries: await getGitHistory(workspace.path, args.limit ?? 5),
+    };
+  }
+);
+
+// git.show
+registerCommand(
+  "git.show",
+  z.object({
+    workspaceId: z.string(),
+    sha: z.string().min(1),
+  }),
+  async (args, ctx) => {
+    const workspace = ctx.workspaceMgr.get(args.workspaceId);
+    if (!workspace) {
+      throw { code: "workspace_not_found", message: `Workspace not found: ${args.workspaceId}` };
+    }
+
+    return {
+      diff: await getGitCommitDiff(workspace.path, args.sha),
+    };
+  }
+);
+
 // git.unstage
 registerCommand(
   "git.unstage",

packages/server/src/git/cli.ts

@@ -2,7 +2,7 @@
  * Git CLI operations - Wrapper around git commands.
  */
 
-import type { GitBranch, GitStatus } from "@coder-studio/core";
+import type { GitBranch, GitCommitSummary, GitStatus } from "@coder-studio/core";
 import { execFile } from "child_process";
 import { mkdir, mkdtemp, rm, writeFile } from "fs/promises";
 import os from "os";
@@ -173,6 +173,50 @@ export async function getGitStatus(cwd: string): Promise<GitStatus> {
   };
 }
 
+/**
+ * Get recent commit history for the current HEAD.
+ */
+export async function getGitHistory(cwd: string, limit = 5): Promise<GitCommitSummary[]> {
+  try {
+    const { stdout } = await runGit(cwd, [
+      "log",
+      `--max-count=${Math.max(1, limit)}`,
+      "--format=%H%x1f%h%x1f%s%x1f%an%x1f%at%x1e",
+    ]);
+
+    return stdout
+      .split("\x1e")
+      .map((record) => record.trim())
+      .filter((record) => record.length > 0)
+      .map((record) => {
+        const [sha = "", shortSha = "", subject = "", authorName = "", authoredAt = "0"] =
+          record.split("\x1f");
+        return {
+          sha,
+          shortSha,
+          subject,
+          authorName,
+          authoredAt: Number.parseInt(authoredAt, 10) * 1000,
+        };
+      })
+      .filter((entry) => entry.sha && entry.subject);
+  } catch (error) {
+    if (error instanceof GitError && /does not have any commits yet/i.test(error.stderr)) {
+      return [];
+    }
+
+    throw error;
+  }
+}
+
+/**
+ * Get the full patch for a specific commit.
+ */
+export async function getGitCommitDiff(cwd: string, sha: string): Promise<string> {
+  const { stdout } = await runGit(cwd, ["show", "--format=medium", "--no-color", sha]);
+  return stdout;
+}
+
 /**
  * Get compact git status text for supervisor evaluation prompts.
  */