fix: fetch previous release commit for proper commit range in set-commits --auto

Without previousCommit, Sentry has no baseline and reports 0 commits.
Fetch the previous release's last commit via the /previous-with-commits/
endpoint (same as the reference sentry-cli) and pass it as previousCommit
in the refs payload. Gracefully degrades if no previous release exists.

Author: BYK

src/lib/api/releases.ts

@@ -271,6 +271,41 @@ export async function createReleaseDeploy(
   return data as unknown as DeployResponse;
 }
 
+/**
+ * Get the last commit SHA from the previous release that has commits.
+ *
+ * Uses the undocumented `/previous-with-commits/` endpoint (same as the
+ * reference sentry-cli) to determine the commit baseline for range-based
+ * commit association. Without this, Sentry can't compute which commits
+ * are new in the current release and reports 0 commits.
+ *
+ * @param orgSlug - Organization slug
+ * @param version - Current release version
+ * @returns Previous release's last commit SHA, or undefined if no previous release
+ */
+async function getPreviousReleaseCommit(
+  orgSlug: string,
+  version: string
+): Promise<string | undefined> {
+  try {
+    const regionUrl = await resolveOrgRegion(orgSlug);
+    const encodedVersion = encodeURIComponent(version);
+    const { data } = await apiRequestToRegion<{
+      lastCommit?: { id: string } | null;
+    }>(
+      regionUrl,
+      `organizations/${orgSlug}/releases/${encodedVersion}/previous-with-commits/`,
+      { method: "GET" }
+    );
+    return data?.lastCommit?.id;
+  } catch {
+    // Not critical — if we can't get the previous commit, we still send
+    // refs without previousCommit. Sentry will try to determine the range
+    // from its own data (may result in 0 commits for first releases).
+    return;
+  }
+}
+
 /**
  * Set commits on a release using auto-discovery mode.
  *
@@ -323,9 +358,16 @@ export async function setCommitsAuto(
     );
     if (match) {
       const headCommit = getHeadCommit(cwd);
-      return setCommitsWithRefs(orgSlug, version, [
-        { repository: match.name, commit: headCommit },
-      ]);
+      const previousCommit = await getPreviousReleaseCommit(orgSlug, version);
+      const ref: {
+        repository: string;
+        commit: string;
+        previousCommit?: string;
+      } = { repository: match.name, commit: headCommit };
+      if (previousCommit) {
+        ref.previousCommit = previousCommit;
+      }
+      return setCommitsWithRefs(orgSlug, version, [ref]);
     }
 
     if (!result.nextCursor) {

test/isolated/set-commits-auto.test.ts

@@ -77,15 +77,15 @@ afterEach(() => {
 });
 
 describe("setCommitsAuto", () => {
-  test("lists repos, discovers HEAD, and sends refs to the API", async () => {
+  test("lists repos, discovers HEAD, fetches previous commit, and sends refs", async () => {
     const withCommits = { ...SAMPLE_RELEASE, commitCount: 5 };
     const requests: { method: string; url: string }[] = [];
 
     globalThis.fetch = mockFetch(async (input, init) => {
       const req = new Request(input!, init);
       requests.push({ method: req.method, url: req.url });
 
-      // First request: list org repositories (SDK uses /repos/ endpoint)
+      // List org repositories (SDK uses /repos/ endpoint)
       if (req.url.includes("/repos/")) {
         expect(req.method).toBe("GET");
         return new Response(JSON.stringify([SAMPLE_REPO]), {
@@ -94,16 +94,32 @@ describe("setCommitsAuto", () => {
         });
       }
 
-      // Second request: PUT refs on the release
+      // Previous release commit lookup
+      if (req.url.includes("/previous-with-commits/")) {
+        expect(req.method).toBe("GET");
+        return new Response(
+          JSON.stringify({
+            lastCommit: { id: "prev000000000000000000000000000000000000" },
+          }),
+          { status: 200, headers: { "Content-Type": "application/json" } }
+        );
+      }
+
+      // PUT refs on the release
       expect(req.method).toBe("PUT");
       expect(req.url).toContain("/releases/1.0.0/");
       const body = (await req.json()) as {
-        refs: Array<{ repository: string; commit: string }>;
+        refs: Array<{
+          repository: string;
+          commit: string;
+          previousCommit?: string;
+        }>;
       };
       expect(body.refs).toEqual([
         {
           repository: "getsentry/cli",
           commit: "abc123def456789012345678901234567890abcd",
+          previousCommit: "prev000000000000000000000000000000000000",
         },
       ]);
       return new Response(JSON.stringify(withCommits), {
@@ -115,7 +131,6 @@ describe("setCommitsAuto", () => {
     const release = await setCommitsAuto("test-org", "1.0.0", "/tmp");
 
     expect(release.commitCount).toBe(5);
-    expect(requests).toHaveLength(2);
   });
 
   test("throws ApiError when org has no repositories", async () => {
@@ -174,6 +189,14 @@ describe("setCommitsAuto", () => {
         });
       }
 
+      // Previous release commit lookup (no previous release)
+      if (req.url.includes("/previous-with-commits/")) {
+        return new Response(JSON.stringify({}), {
+          status: 200,
+          headers: { "Content-Type": "application/json" },
+        });
+      }
+
       // PUT refs on the release
       return new Response(JSON.stringify(withCommits), {
         status: 200,