edsger 0.48.0 → 0.48.1

package/dist/phases/run-sheet/index.d.ts

@@ -10,6 +10,7 @@
  * template_snapshot + tag and no clone error, we short-circuit without
  * re-cloning. Pass `{ force: true }` to regenerate anyway.
  */
+import { type RunSheet } from '../../api/run-sheets.js';
 export interface RunSheetOptions {
     releaseId: string;
     force?: boolean;
@@ -27,6 +28,18 @@ export interface RunSheetResult {
     commitsTruncated?: boolean;
     isDraft?: boolean;
 }
+/**
+ * Draft releases have no stored `diff_summary` / `diff_stats` (those are
+ * only written by smoke-test against a cut tag). Compute a lightweight
+ * substitute on the fly so draft templates that reference `{{diff_summary}}`
+ * or `{{diff_stats.*}}` still render something useful.
+ *
+ * Exported for unit tests.
+ */
+export declare function fetchDraftDiff(owner: string, repo: string, base: string | null, head: string, token: string): Promise<{
+    summary: string | null;
+    stats: Record<string, unknown> | null;
+}>;
 /**
  * Atomic-create a `.lock` file alongside the workspace dir. Returns
  * true if we acquired the lock, false if another CLI instance holds a
@@ -51,4 +64,6 @@ export declare function releaseFileLock(lockPath: string): void;
 export declare function pruneStaleRunSheetWorkspaces(workspaceRoot: string, now?: number, maxAgeMs?: number): {
     removed: string[];
 };
+/** Exported for unit tests; not part of the public CLI surface. */
+export declare function runSheetIsFresh(existing: RunSheet | null, template: string, tag: string): boolean;
 export declare function runRunSheet(options: RunSheetOptions): Promise<RunSheetResult>;

package/dist/phases/run-sheet/index.js

@@ -19,7 +19,7 @@ import { getRelease } from '../../api/releases.js';
 import { getRunSheetByRelease, upsertRunSheet, } from '../../api/run-sheets.js';
 import { logError, logInfo, logSuccess, logWarning, } from '../../utils/logger.js';
 import { cloneFeatureRepo, ensureWorkspaceDir, getFeatureRepoPath, syncRepoToRef, } from '../../workspace/workspace-manager.js';
-import { fetchAllCompareCommits, getDefaultBranchHead, } from '../release-sync/github.js';
+import { fetchAllCompareCommits, fetchCompare, getDefaultBranchHead, summariseStats, } from '../release-sync/github.js';
 import { isSafeGitRef, renderTemplate } from './render.js';
 async function fetchCommitsBetween(owner, repo, base, head, token) {
     if (!base) {
@@ -48,6 +48,30 @@ async function fetchCommitsBetween(owner, repo, base, head, token) {
         return { text: '', list: [], truncated: false, error: message };
     }
 }
+/**
+ * Draft releases have no stored `diff_summary` / `diff_stats` (those are
+ * only written by smoke-test against a cut tag). Compute a lightweight
+ * substitute on the fly so draft templates that reference `{{diff_summary}}`
+ * or `{{diff_stats.*}}` still render something useful.
+ *
+ * Exported for unit tests.
+ */
+export async function fetchDraftDiff(owner, repo, base, head, token) {
+    if (!base) {
+        return { summary: null, stats: null };
+    }
+    try {
+        const compare = await fetchCompare(owner, repo, base, head, token);
+        const stats = summariseStats(compare);
+        const summary = `Draft diff from ${base} to ${head}: ${stats.total_commits} commit(s), ${stats.files_changed} file(s) changed (+${stats.additions}/-${stats.deletions}).`;
+        return { summary, stats: stats };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        logWarning(`Could not compute draft diff summary: ${message}`);
+        return { summary: null, stats: null };
+    }
+}
 // Stale locks (e.g. left behind by a crashed or SIGKILLed CLI) are
 // considered abandoned after this many ms.
 const LOCK_STALE_MS = 15 * 60 * 1000;
@@ -205,7 +229,8 @@ function computeInputHash(parts) {
     h.update(`commits:${parts.commitShas.join(',')}\n`);
     return h.digest('hex');
 }
-function runSheetIsFresh(existing, template, tag) {
+/** Exported for unit tests; not part of the public CLI surface. */
+export function runSheetIsFresh(existing, template, tag) {
     if (!existing || !existing.content) {
         return false;
     }
@@ -219,6 +244,12 @@ function runSheetIsFresh(existing, template, tag) {
     if (meta.clone_error) {
         return false;
     }
+    // Drafts are rendered from the default branch HEAD, which moves. Always
+    // regenerate so `{{commits}}` / `{{diff_summary}}` reflect the current
+    // branch tip rather than a stale snapshot.
+    if (meta.is_draft) {
+        return false;
+    }
     return true;
 }
 // eslint-disable-next-line complexity -- orchestration with cache, clone, lock, render
@@ -289,6 +320,10 @@ export async function runRunSheet(options) {
     // both the checkout and the commits compare.
     let isDraft = false;
     let draftBaseRef = null;
+    // Draft-only: live-computed diff stats/summary (DB columns are empty
+    // until smoke-test runs against a real tag).
+    let draftDiffSummary = null;
+    let draftDiffStats = null;
     if (repoConfigured && gh.owner && gh.repo && gh.token) {
         const { owner, repo, token } = gh;
         // Serialise concurrent CLI invocations for the *same release* by
@@ -320,24 +355,47 @@ export async function runRunSheet(options) {
             // we don't want to inherit that bug here.)
             const { repoPath } = cloneFeatureRepo(workspaceRoot, workspaceName, owner, repo, token);
             repoDir = repoPath;
-            try {
-                syncRepoToRef(repoPath, { tag: release.tag }, token);
-            }
-            catch (err) {
-                const tagErr = err instanceof Error ? err.message : String(err);
-                logWarning(`Tag ${release.tag} not found — generating draft run sheet from default branch.`);
+            // SNAPSHOT releases (those discovered via `release-sync`'s snapshot
+            // detection) have no GitHub release object backing them, so
+            // `published_at` is null. Use that as a free local signal to skip
+            // the tag-checkout entirely — no extra GitHub round-trip, no
+            // misleading "Failed to checkout refs/tags/..." cloneError. For
+            // real releases (`published_at` set) we still attempt the tag and
+            // fall back if the checkout itself fails (deleted tag, network).
+            const expectDraft = release.published_at == null;
+            if (expectDraft) {
+                logInfo(`Tag ${release.tag} not yet cut (no published_at) — generating draft run sheet from default branch.`);
                 try {
                     const { branch } = await getDefaultBranchHead(owner, repo, token);
                     syncRepoToRef(repoPath, { branch }, token);
                     isDraft = true;
                     draftBaseRef = branch;
-                    cloneError = `Tag ${release.tag} not found; fell back to default branch ${branch}. (${tagErr})`;
                 }
                 catch (fallbackErr) {
-                    cloneError = `Could not checkout tag ${release.tag} or fall back to default branch: ${fallbackErr instanceof Error ? fallbackErr.message : String(fallbackErr)}`;
+                    cloneError = `Could not check out default branch for draft run sheet: ${fallbackErr instanceof Error ? fallbackErr.message : String(fallbackErr)}`;
                     logWarning(cloneError);
                 }
             }
+            else {
+                try {
+                    syncRepoToRef(repoPath, { tag: release.tag }, token);
+                }
+                catch (err) {
+                    const tagErr = err instanceof Error ? err.message : String(err);
+                    logWarning(`Tag ${release.tag} checkout failed — falling back to default branch.`);
+                    try {
+                        const { branch } = await getDefaultBranchHead(owner, repo, token);
+                        syncRepoToRef(repoPath, { branch }, token);
+                        isDraft = true;
+                        draftBaseRef = branch;
+                        cloneError = `Tag ${release.tag} could not be checked out; fell back to default branch ${branch}. (${tagErr})`;
+                    }
+                    catch (fallbackErr) {
+                        cloneError = `Could not checkout tag ${release.tag} or fall back to default branch: ${fallbackErr instanceof Error ? fallbackErr.message : String(fallbackErr)}`;
+                        logWarning(cloneError);
+                    }
+                }
+            }
         }
         catch (err) {
             cloneError = err instanceof Error ? err.message : String(err);
@@ -349,6 +407,11 @@ export async function runRunSheet(options) {
         commitsList = c.list;
         commitsTruncated = c.truncated;
         commitsError = c.error ?? null;
+        if (isDraft) {
+            const d = await fetchDraftDiff(owner, repo, release.previous_tag, head, token);
+            draftDiffSummary = d.summary;
+            draftDiffStats = d.stats;
+        }
     }
     else {
         cloneError = 'Product is not linked to a GitHub repository';
@@ -367,8 +430,12 @@ export async function runRunSheet(options) {
         published_at: release.published_at,
         previous_tag: release.previous_tag,
         previous_published_at: release.previous_published_at,
-        diff_summary: release.diff_summary,
-        diff_stats: release.diff_stats ?? {},
+        diff_summary: isDraft
+            ? (draftDiffSummary ?? release.diff_summary)
+            : release.diff_summary,
+        diff_stats: isDraft
+            ? (draftDiffStats ?? release.diff_stats ?? {})
+            : (release.diff_stats ?? {}),
     }, repoDir, commits, draftNotice, commitsList);
     const inputHash = computeInputHash({
         template,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edsger",
-  "version": "0.48.0",
+  "version": "0.48.1",
   "type": "module",
   "bin": {
     "edsger": "dist/index.js"