@plannotator/pi-extension 0.28.37 → 0.28.38

package/generated/guide-viewer-manifest.ts

@@ -6,9 +6,9 @@
 import type { GuideViewerAssets } from "./guide-format.ts";
 
 export const GUIDE_VIEWER_MANIFEST: Omit<GuideViewerAssets, "baseUrl"> = {
-  js: "viewer.SgPt8W-S.js",
+  js: "viewer.BqcO9v_d.js",
   css: "viewer.DejL7_DK.css",
-  jsIntegrity: "sha384-P3KhhgeAgJGa3CTHbXg0ZuIN5F703EFwTG7ont4K08zzCQtJS6EP55W2uRIsdItJ",
+  jsIntegrity: "sha384-hv0Y+2gJFlY9p99fic5BMf0H8suh2cpCqppFI1GPYYBfCbMLs/4fTmf3astg5o8b",
   cssIntegrity: "sha384-RC1v6OjikD4krGxtTP5dn1SNTtuT4wQWdRSS5HSVrmAdJk97gNs5wbKca+3/0Hdl",
   langs: {
     "astro": "chunks/astro.Ts5EKq2l.js",

package/generated/project.ts

@@ -22,8 +22,9 @@ export function sanitizeTag(name: string): string | null {
     .replace(/[\s_]+/g, "-")      // spaces/underscores -> hyphens
     .replace(/[^a-z0-9-]/g, "")   // remove special chars
     .replace(/-+/g, "-")          // collapse multiple hyphens
-    .replace(/^-|-$/g, "")        // trim leading/trailing hyphens
-    .slice(0, 30);                // max 30 chars
+    .replace(/^-/, "")            // trim leading hyphen
+    .slice(0, 30)                 // max 30 chars
+    .replace(/-$/, "");           // trim trailing hyphen, after the cut so the result is idempotent
 
   return sanitized.length >= 2 ? sanitized : null;
 }

package/generated/update-check.ts

@@ -84,6 +84,15 @@ const RELEASE_CHECK_TIMEOUT_MS = 8_000;
  */
 export const RELEASE_ASSETS_FETCH_INTERVAL_MS = 24 * 60 * 60 * 1000;
 export const RELEASE_ASSETS_FETCH_RETRY_MS = 6 * 60 * 60 * 1000;
+/**
+ * A release's notes answered with no "What's New" part while the release is
+ * young (published under RELEASE_NOTES_YOUNG_MS ago): GitHub's generated
+ * body, read in the minutes before the written notes replaced it. Asked again
+ * after this instead of RELEASE_ASSETS_FETCH_INTERVAL_MS, so the "What's new"
+ * link shows within the hour, not a day later.
+ */
+export const RELEASE_NOTES_PENDING_RETRY_MS = 15 * 60 * 1000;
+export const RELEASE_NOTES_YOUNG_MS = 2 * 24 * 60 * 60 * 1000;
 /** "Remind me tomorrow" in the Inbox. */
 export const UPDATE_SNOOZE_MS = 24 * 60 * 60 * 1000;
 /** The terminal hint shows at most this often. */
@@ -145,6 +154,19 @@ export function releaseUrlFor(version: string): string {
 // State (update-state.json, shared with auto-update)
 // ---------------------------------------------------------------------------
 
+/** One version's notes fetch (`notesFetch[<version>]`). */
+export interface NotesFetchRecord {
+  attemptedAt: number;
+  failedAt?: number;
+  error?: string;
+  /**
+   * The release's `published_at` (epoch ms), kept when its answer carried no
+   * "What's New" part: while it is under RELEASE_NOTES_YOUNG_MS old, the next
+   * try waits RELEASE_NOTES_PENDING_RETRY_MS instead of a day.
+   */
+  publishedAt?: number;
+}
+
 export interface UpdateState {
   /** Auto-update's install window (epoch ms of the last check that got past its gates). */
   lastCheckAt?: number;
@@ -221,7 +243,7 @@ export interface UpdateState {
    * One release's notes fetched by its tag (fetchReleaseNotesFor), per
    * version: claimed before the request, so concurrent processes ask once.
    */
-  notesFetch?: Record<string, { attemptedAt: number; failedAt?: number; error?: string }>;
+  notesFetch?: Record<string, NotesFetchRecord>;
   /**
    * The Inbox's fetch of one release's images (packages/server/inbox-whats-new-images.ts),
    * per version, with the same claim and back-off as `notesFetch`. Only the
@@ -1045,17 +1067,28 @@ export function scheduleReleaseCheck(deps: ReleaseCheckDeps, then?: (outcome: Re
 /** How many versions `notesFetch` remembers. */
 const NOTES_FETCH_REMEMBERED = 10;
 
+/** The record names a release young enough for the quick retry (a clock far off either way does not). */
+function isYoungRelease(record: NotesFetchRecord, now: number): boolean {
+  const published = record.publishedAt;
+  return typeof published === "number" && Number.isFinite(published) && Math.abs(now - published) < RELEASE_NOTES_YOUNG_MS;
+}
+
 /**
  * Whether one version's notes may be asked for now: once, then after a
  * failure no sooner than 6 h, and after an answer that carried no "What's
- * New" part no sooner than 24 h (the release body is edited after publishing).
- * Never in a loop.
+ * New" part no sooner than 15 minutes while the release is under 2 days old
+ * (the release body is edited after publishing), else 24 h. Never in a loop.
  */
 export function isNotesFetchDue(state: UpdateState, version: string, now: number): boolean {
   const record = state.notesFetch?.[version];
   const at = record?.attemptedAt;
   if (!record || typeof at !== "number" || !Number.isFinite(at) || at > now) return true;
-  return now - at >= (record.failedAt ? RELEASE_ASSETS_FETCH_RETRY_MS : RELEASE_ASSETS_FETCH_INTERVAL_MS);
+  const wait = record.failedAt
+    ? RELEASE_ASSETS_FETCH_RETRY_MS
+    : isYoungRelease(record, now)
+      ? RELEASE_NOTES_PENDING_RETRY_MS
+      : RELEASE_ASSETS_FETCH_INTERVAL_MS;
+  return now - at >= wait;
 }
 
 export interface ReleaseNotesFetchDeps {
@@ -1088,7 +1121,7 @@ export async function fetchReleaseNotesFor(deps: ReleaseNotesFetchDeps): Promise
   if (hasReleaseNotesContent(stored)) return { outcome: "present", notes: stored };
   if (!deps.enabled()) return { outcome: "disabled" };
   const now = (deps.now ?? Date.now)();
-  const record = (patch: { attemptedAt: number; failedAt?: number; error?: string }) =>
+  const record = (patch: NotesFetchRecord) =>
     patchUpdateState((s) => {
       const entries = Object.entries({ ...(s.notesFetch ?? {}), [version]: patch })
         .filter(([, r]) => r && typeof r.attemptedAt === "number")
@@ -1096,10 +1129,16 @@ export async function fetchReleaseNotesFor(deps: ReleaseNotesFetchDeps): Promise
         .slice(0, NOTES_FETCH_REMEMBERED);
       return { ...s, notesFetch: Object.fromEntries(entries) };
     }, dataDir);
+  let pendingBefore = false;
   try {
-    if (!isNotesFetchDue(readUpdateState(dataDir), version, now)) return { outcome: "not-due" };
-    // Claim the attempt before the network call so concurrent processes ask once.
-    record({ attemptedAt: now });
+    const state = readUpdateState(dataDir);
+    if (!isNotesFetchDue(state, version, now)) return { outcome: "not-due" };
+    // Claim the attempt before the network call so concurrent processes ask
+    // once. A young release's date is kept, so an attempt that never finished
+    // (the process quit) is tried again on the quick cadence, not in a day.
+    const previous = state.notesFetch?.[version];
+    pendingBefore = !!previous && !previous.failedAt && isYoungRelease(previous, now);
+    record({ attemptedAt: now, ...(pendingBefore && { publishedAt: previous!.publishedAt }) });
   } catch (err) {
     const error = err instanceof Error ? err.message : String(err);
     updateLog(`could not write update-state.json: ${error}`, dataDir);
@@ -1123,6 +1162,19 @@ export async function fetchReleaseNotesFor(deps: ReleaseNotesFetchDeps): Promise
   } catch (err) {
     updateLog(`could not save the release notes: ${err instanceof Error ? err.message : String(err)}`, dataDir);
   }
+  if (!notes) {
+    // GitHub's generated body, read before the written notes replaced it (or
+    // a release with none): a young release is asked again in 15 minutes.
+    const published = release.publishedAt ? Date.parse(release.publishedAt) : NaN;
+    const pending: NotesFetchRecord = { attemptedAt: now, ...(Number.isFinite(published) && { publishedAt: published }) };
+    try {
+      record(pending);
+    } catch {}
+    // One line per version, not one per retry.
+    if (isYoungRelease(pending, now) && !pendingBefore) {
+      updateLog(`the release notes for ${version} have no "What's New" part yet; next try in ${formatWait(RELEASE_NOTES_PENDING_RETRY_MS)}`, dataDir);
+    }
+  }
   // The release page names no publish date: take this answer's for the latest release.
   if (release.publishedAt) {
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plannotator/pi-extension",
-  "version": "0.28.37",
+  "version": "0.28.38",
   "type": "module",
   "description": "Plannotator Pi extension - interactive plan review with annotations, annotate agent messages, and review code/PRs",
   "author": "backnotprop",