feat: warn on timestamp-like branch names, include rebase abort error in PR comment

Co-Authored-By: Niels Swimberghe <3382717+Swimburger@users.noreply.github.com>

Author: devin-ai-integration[bot]

dist/index.js

@@ -39329,6 +39329,7 @@ async function run() {
         if (!token) {
             throw new Error("GitHub token is required. Please provide a token with appropriate permissions.");
         }
+        warnIfDynamicBranchName(branch);
         if (updateFromSource) {
             await updateFromSourceSpec(token, branch, autoMerge);
         }
@@ -39519,6 +39520,28 @@ async function syncChanges(options) {
         throw new Error(`Failed to sync changes: ${error instanceof Error ? error.message : "Unknown error"}`);
     }
 }
+// Warn if the branch name appears to contain a dynamic/timestamp component,
+// which would prevent PR deduplication from working.
+function warnIfDynamicBranchName(branch) {
+    // Match common timestamp patterns in branch names:
+    // - ISO-like dates: 2026-02-25, 2026-02-25T00-27-08
+    // - Unix timestamps: 1772467782 (10+ digits)
+    // - Date segments: 20260225, 202602
+    const timestampPatterns = [
+        /\d{4}-\d{2}-\d{2}/, // ISO date: 2026-02-25
+        /\d{4}-\d{2}-\d{2}T\d{2}/, // ISO datetime: 2026-02-25T00
+        /\d{10,}/, // Unix timestamp: 1772467782
+        /\d{8,}/, // Compact date: 20260225
+    ];
+    for (const pattern of timestampPatterns) {
+        if (pattern.test(branch)) {
+            core.warning(`Branch name '${branch}' appears to contain a timestamp or date. ` +
+                `Using dynamic branch names means each run creates a new branch and a new PR. ` +
+                `For PR deduplication to work, use a stable branch name (e.g., 'update-api').`);
+            return;
+        }
+    }
+}
 async function branchExists(owner, repo, branchName, octokit) {
     try {
         await octokit.rest.git.getRef({

src/sync.test.ts

@@ -4,6 +4,7 @@ import { describe, it, expect, vi, beforeEach } from "vitest";
 const state = {
     infoCalls: [] as string[],
     setFailedCalls: [] as string[],
+    warningCalls: [] as string[],
     execCalls: [] as [string, string[] | undefined, unknown][], // [cmd, args, opts]
     getInputImpl: (_name: string): string => "",
     getBooleanInputImpl: (_name: string): boolean => false,
@@ -42,6 +43,9 @@ vi.mock("@actions/core", () => ({
     setFailed: vi.fn((msg: string) => {
         state.setFailedCalls.push(msg);
     }),
+    warning: vi.fn((msg: string) => {
+        state.warningCalls.push(msg);
+    }),
 }));
 
 vi.mock("@actions/github", () => ({
@@ -84,6 +88,7 @@ function setupMocks({
     // Reset shared state
     state.infoCalls = [];
     state.setFailedCalls = [];
+    state.warningCalls = [];
     state.execCalls = [];
 
     // Setup input implementations
@@ -153,6 +158,7 @@ beforeEach(() => {
     vi.clearAllMocks();
     state.infoCalls = [];
     state.setFailedCalls = [];
+    state.warningCalls = [];
     state.execCalls = [];
 });
 
@@ -323,10 +329,12 @@ describe("updateFromSourceSpec", () => {
                 }),
             );
 
-            // Comment body should mention sync failed
+            // Comment body should mention sync failed and include error details
             const commentCall = mockIssuesCreateComment.mock.calls[0][0];
             expect(commentCall.body).toContain("Sync failed");
             expect(commentCall.body).toContain("merge conflicts");
+            expect(commentCall.body).toContain("Rebase error:");
+            expect(commentCall.body).toContain("merge conflict");
 
             // Action should still fail (not silently succeed)
             expect(state.setFailedCalls).toEqual(
@@ -362,6 +370,72 @@ describe("updateFromSourceSpec", () => {
                 ]),
             );
         });
+
+        it("should include rebase abort error in PR comment when abort fails", async () => {
+            setupMocks({ hasChanges: true, existingPRNumber: 42 });
+            state.execImpl = async (
+                cmd: string,
+                args?: string[],
+            ): Promise<number> => {
+                if (
+                    cmd === "git" &&
+                    Array.isArray(args) &&
+                    (args.includes("push") ||
+                        (args.includes("pull") && args.includes("--rebase")))
+                ) {
+                    throw new Error("merge conflict");
+                }
+                if (
+                    cmd === "git" &&
+                    Array.isArray(args) &&
+                    args.includes("rebase") &&
+                    args.includes("--abort")
+                ) {
+                    throw new Error("no rebase in progress");
+                }
+                return 0;
+            };
+            await importAndRun();
+
+            const commentCall = mockIssuesCreateComment.mock.calls[0][0];
+            expect(commentCall.body).toContain("Rebase error:");
+            expect(commentCall.body).toContain("merge conflict");
+            expect(commentCall.body).toContain("Rebase abort error:");
+            expect(commentCall.body).toContain("no rebase in progress");
+        });
+    });
+
+    describe("dynamic branch name warning", () => {
+        it("should warn when branch name contains an ISO date", async () => {
+            setupMocks({ hasChanges: false });
+            state.getInputImpl = (name: string): string => {
+                const inputs: Record<string, string> = {
+                    token: "fake-token",
+                    branch: "update-openapi-spec-2026-02-25T00-27-08-474Z",
+                    auto_merge: "false",
+                    update_from_source: "true",
+                };
+                return inputs[name] || "";
+            };
+            await importAndRun();
+
+            expect(state.warningCalls).toEqual(
+                expect.arrayContaining([
+                    expect.stringContaining("appears to contain a timestamp"),
+                ]),
+            );
+        });
+
+        it("should not warn for a stable branch name", async () => {
+            setupMocks({ hasChanges: false });
+            await importAndRun();
+
+            expect(state.warningCalls).not.toEqual(
+                expect.arrayContaining([
+                    expect.stringContaining("appears to contain a timestamp"),
+                ]),
+            );
+        });
     });
 
     describe("when auto_merge is true", () => {

src/sync.ts

@@ -36,6 +36,8 @@ export async function run(): Promise<void> {
             );
         }
 
+        warnIfDynamicBranchName(branch);
+
         if (updateFromSource) {
             await updateFromSourceSpec(token, branch, autoMerge);
         } else {
@@ -340,6 +342,32 @@ async function syncChanges(options: SyncOptions): Promise<void> {
     }
 }
 
+// Warn if the branch name appears to contain a dynamic/timestamp component,
+// which would prevent PR deduplication from working.
+function warnIfDynamicBranchName(branch: string): void {
+    // Match common timestamp patterns in branch names:
+    // - ISO-like dates: 2026-02-25, 2026-02-25T00-27-08
+    // - Unix timestamps: 1772467782 (10+ digits)
+    // - Date segments: 20260225, 202602
+    const timestampPatterns = [
+        /\d{4}-\d{2}-\d{2}/, // ISO date: 2026-02-25
+        /\d{4}-\d{2}-\d{2}T\d{2}/, // ISO datetime: 2026-02-25T00
+        /\d{10,}/, // Unix timestamp: 1772467782
+        /\d{8,}/, // Compact date: 20260225
+    ];
+
+    for (const pattern of timestampPatterns) {
+        if (pattern.test(branch)) {
+            core.warning(
+                `Branch name '${branch}' appears to contain a timestamp or date. ` +
+                    `Using dynamic branch names means each run creates a new branch and a new PR. ` +
+                    `For PR deduplication to work, use a stable branch name (e.g., 'update-api').`,
+            );
+            return;
+        }
+    }
+}
+
 async function branchExists(
     owner: string,
     repo: string,