fix: paginate git history on panel scroll

Author: pallyoung

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

@@ -304,6 +304,7 @@ describe("Git Commands", () => {
     expect(result.ok).toBe(true);
     expect(result.data).toEqual(
       expect.objectContaining({
+        hasMore: false,
         entries: expect.arrayContaining([
           expect.objectContaining({
             subject: "Refresh command surface",
@@ -314,6 +315,71 @@ describe("Git Commands", () => {
     );
   });
 
+  it("returns the next git.log page after a cursor", async () => {
+    for (const subject of [
+      "Second command commit",
+      "Third command commit",
+      "Fourth command commit",
+    ]) {
+      await writeFile(join(testDir, "sample.ts"), `${subject}\n`);
+      await execFileAsync("git", ["add", "."], { cwd: testDir });
+      await execFileAsync("git", ["commit", "-m", subject], { cwd: testDir });
+    }
+
+    const firstPage = await dispatch(
+      {
+        kind: "command",
+        id: "git-log-page-1",
+        op: "git.log",
+        args: {
+          workspaceId,
+          limit: 2,
+        },
+      },
+      ctx
+    );
+
+    expect(firstPage.ok).toBe(true);
+    expect(firstPage.data).toEqual(
+      expect.objectContaining({
+        hasMore: true,
+        entries: [
+          expect.objectContaining({ subject: "Fourth command commit" }),
+          expect.objectContaining({ subject: "Third command commit" }),
+        ],
+      })
+    );
+
+    const cursor = (firstPage.data as { entries: Array<{ sha: string }> }).entries[1]!.sha;
+    const secondPage = await dispatch(
+      {
+        kind: "command",
+        id: "git-log-page-2",
+        op: "git.log",
+        args: {
+          workspaceId,
+          limit: 2,
+          afterSha: cursor,
+        },
+      },
+      ctx
+    );
+
+    expect(secondPage.ok).toBe(true);
+    expect(secondPage.data).toEqual(
+      expect.objectContaining({
+        hasMore: false,
+        entries: [
+          expect.objectContaining({ subject: "Second command commit" }),
+          expect.objectContaining({ subject: "Initial commit" }),
+        ],
+      })
+    );
+    expect(
+      (secondPage.data as { entries: Array<{ sha: string }> }).entries.map((entry) => entry.sha)
+    ).not.toContain(cursor);
+  });
+
   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 });

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

@@ -770,18 +770,19 @@ describe("getGitHistory", () => {
 
     const history = await getGitHistory(testDir, 5);
 
-    expect(history).toHaveLength(2);
-    expect(history[0]).toEqual(
+    expect(history.hasMore).toBe(false);
+    expect(history.entries).toHaveLength(2);
+    expect(history.entries[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(history.entries[0]?.sha).toHaveLength(40);
+    expect(history.entries[0]?.shortSha).toHaveLength(7);
+    expect(history.entries[0]?.authoredAt).toBeTypeOf("number");
+    expect(history.entries[0]!.authoredAt).toBeGreaterThanOrEqual(history.entries[1]!.authoredAt);
+    expect(history.entries[1]).toEqual(
       expect.objectContaining({
         subject: "first commit",
         authorName: "Test",
@@ -795,7 +796,45 @@ describe("getGitHistory", () => {
     const testDir = await mkdtemp(join(tmpdir(), "git-history-empty-"));
     await execFileAsync("git", ["init"], { cwd: testDir });
 
-    await expect(getGitHistory(testDir, 5)).resolves.toEqual([]);
+    await expect(getGitHistory(testDir, 5)).resolves.toEqual({
+      entries: [],
+      hasMore: false,
+    });
+
+    await rm(testDir, { recursive: true, force: true });
+  });
+
+  it("returns paged commits after a cursor without duplicating the cursor", async () => {
+    const testDir = await mkdtemp(join(tmpdir(), "git-history-paged-"));
+    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 });
+
+    for (const subject of ["first commit", "second commit", "third commit", "fourth commit"]) {
+      await writeFile(join(testDir, "file.txt"), `${subject}\n`);
+      await execFileAsync("git", ["add", "."], { cwd: testDir });
+      await execFileAsync("git", ["commit", "-m", subject], { cwd: testDir });
+    }
+
+    const firstPage = await getGitHistory(testDir, { limit: 2 });
+
+    expect(firstPage.hasMore).toBe(true);
+    expect(firstPage.entries.map((entry) => entry.subject)).toEqual([
+      "fourth commit",
+      "third commit",
+    ]);
+
+    const secondPage = await getGitHistory(testDir, {
+      limit: 2,
+      afterSha: firstPage.entries[1]!.sha,
+    });
+
+    expect(secondPage.hasMore).toBe(false);
+    expect(secondPage.entries.map((entry) => entry.subject)).toEqual([
+      "second commit",
+      "first commit",
+    ]);
+    expect(secondPage.entries.map((entry) => entry.sha)).not.toContain(firstPage.entries[1]!.sha);
 
     await rm(testDir, { recursive: true, force: true });
   });

packages/server/src/commands/git.ts

@@ -36,6 +36,14 @@ const gitCommitRevisionSchema = z
 
 const GIT_BACKGROUND_FETCH_TIMEOUT_MS = 30 * 1000;
 
+function debugGitHistoryCommand(message: string, details?: Record<string, unknown>) {
+  if (process.env.CODER_STUDIO_DEBUG_GIT_HISTORY !== "1") {
+    return;
+  }
+
+  console.log("[git-history]", message, details);
+}
+
 async function runGitNetworkOperation<T>(
   ctx: CommandContext,
   workspaceId: string,
@@ -131,16 +139,35 @@ registerCommand(
   z.object({
     workspaceId: z.string(),
     limit: z.number().int().min(1).max(50).optional(),
+    afterSha: gitCommitRevisionSchema.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),
-    };
+    debugGitHistoryCommand("command git.log request", {
+      workspaceId: args.workspaceId,
+      workspacePath: workspace.path,
+      limit: args.limit ?? 5,
+      afterSha: args.afterSha,
+    });
+
+    const history = await getGitHistory(workspace.path, {
+      limit: args.limit ?? 5,
+      afterSha: args.afterSha,
+    });
+
+    debugGitHistoryCommand("command git.log response", {
+      workspaceId: args.workspaceId,
+      entryCount: history.entries.length,
+      hasMore: history.hasMore,
+      firstSha: history.entries[0]?.sha,
+      lastSha: history.entries.at(-1)?.sha,
+    });
+
+    return history;
   }
 );
 

packages/server/src/git/cli.ts

@@ -181,18 +181,53 @@ export async function getGitStatus(cwd: string): Promise<GitStatus> {
   };
 }
 
+export interface GitHistoryOptions {
+  limit?: number;
+  afterSha?: string;
+}
+
+export interface GitHistoryResult {
+  entries: GitCommitSummary[];
+  hasMore: boolean;
+}
+
+function debugGitHistory(message: string, details?: Record<string, unknown>) {
+  if (process.env.CODER_STUDIO_DEBUG_GIT_HISTORY !== "1") {
+    return;
+  }
+
+  console.log("[git-history]", message, details);
+}
+
 /**
  * Get recent commit history for the current HEAD.
  */
-export async function getGitHistory(cwd: string, limit = 5): Promise<GitCommitSummary[]> {
+export async function getGitHistory(
+  cwd: string,
+  options: number | GitHistoryOptions = 5
+): Promise<GitHistoryResult> {
+  const limit = Math.max(1, typeof options === "number" ? options : (options.limit ?? 5));
+  const afterSha = typeof options === "number" ? undefined : options.afterSha;
+  const pageSize = limit + 1;
+  const revisionArgs = afterSha ? ["--skip=1", "--end-of-options", afterSha] : [];
+
   try {
+    debugGitHistory("server get history request", {
+      cwd,
+      limit,
+      pageSize,
+      afterSha,
+      revisionArgs,
+    });
+
     const { stdout } = await runGit(cwd, [
       "log",
-      `--max-count=${Math.max(1, limit)}`,
+      `--max-count=${pageSize}`,
       "--format=%H%x1f%h%x1f%s%x1f%an%x1f%at%x1e",
+      ...revisionArgs,
     ]);
 
-    return stdout
+    const entries = stdout
       .split("\x1e")
       .map((record) => record.trim())
       .filter((record) => record.length > 0)
@@ -208,9 +243,30 @@ export async function getGitHistory(cwd: string, limit = 5): Promise<GitCommitSu
         };
       })
       .filter((entry) => entry.sha && entry.subject);
+
+    debugGitHistory("server get history response", {
+      cwd,
+      limit,
+      afterSha,
+      rawRecordCount: stdout.split("\x1e").filter((record) => record.trim().length > 0).length,
+      parsedCount: entries.length,
+      returnedCount: entries.slice(0, limit).length,
+      hasMore: entries.length > limit,
+      firstSha: entries[0]?.sha,
+      lastReturnedSha: entries.slice(0, limit).at(-1)?.sha,
+      extraSha: entries[limit]?.sha,
+    });
+
+    return {
+      entries: entries.slice(0, limit),
+      hasMore: entries.length > limit,
+    };
   } catch (error) {
     if (error instanceof GitError && /does not have any commits yet/i.test(error.stderr)) {
-      return [];
+      return {
+        entries: [],
+        hasMore: false,
+      };
     }
 
     throw error;