github-search-cli 9.3.0 → 9.4.0

package/src/releases.ts

@@ -0,0 +1,144 @@
+/**
+ * Release tracker — checks bookmarked repos for new GitHub releases.
+ *
+ * Decisions (map 003):
+ *   - Signal: new GitHub releases only (`GET /repos/{o}/{r}/releases?per_page=5`).
+ *   - Seen state: `lastSeenAt` per bookmark; "new" = published after it.
+ *   - Rate budget: etag conditional requests + token when present.
+ *   - Prereleases shown (tagged `[pre]`), drafts never.
+ *
+ * ponytail: sequential fetches — fine for ≤100 bookmarks at launch;
+ * parallelize with p-limit if users report slow startup.
+ */
+import type { Bookmark } from "./types";
+import { readJSON, writeJSON } from "./storage";
+import { getBookmarks, getLastSeen, markSeen } from "./bookmarks";
+import { addNotification } from "./notifications";
+import { loadConfig } from "./config";
+
+const RELEASES_FILE = "release-cache.json";
+const PER_REPO = 5;
+
+export interface TrackedRelease {
+  id: number;
+  tagName: string;
+  name: string;
+  url: string;
+  publishedAt: string;
+  prerelease: boolean;
+}
+
+/** Persisted cache: etag + last-known releases per repo. Only what the feed needs. */
+interface RepoReleaseState {
+  etag?: string;
+  checkedAt: number;
+  releases: TrackedRelease[];
+}
+
+type ReleaseCache = Record<string, RepoReleaseState>;
+
+function loadCache(): ReleaseCache {
+  return readJSON<ReleaseCache>(RELEASES_FILE, {});
+}
+
+function saveCache(cache: ReleaseCache): void {
+  writeJSON(RELEASES_FILE, cache);
+}
+
+function toTracked(raw: Array<Record<string, unknown>>): TrackedRelease[] {
+  return raw
+    .filter((r) => r.draft !== true) // drafts: never shown
+    .map((r) => ({
+      id: r.id as number,
+      tagName: r.tag_name as string,
+      name: (r.name as string) || (r.tag_name as string),
+      url: r.html_url as string,
+      publishedAt: (r.published_at as string) || "",
+      prerelease: r.prerelease === true,
+    }));
+}
+
+/** Fetch /releases for one repo using its cached etag. */
+async function fetchReleases(
+  fullName: string,
+  etag: string | undefined,
+  token: string | undefined,
+): Promise<{ status: number; etag?: string; releases?: TrackedRelease[] }> {
+  const headers: Record<string, string> = { Accept: "application/vnd.github+json" };
+  if (etag) headers["If-None-Match"] = etag;
+  if (token) headers["Authorization"] = `Bearer ${token}`;
+  const res = await fetch(`https://api.github.com/repos/${fullName}/releases?per_page=${PER_REPO}`, { headers });
+  if (res.status === 304 || !res.ok) return { status: res.status };
+  return {
+    status: 200,
+    etag: res.headers.get("etag") ?? undefined,
+    releases: toTracked((await res.json()) as Array<Record<string, unknown>>),
+  };
+}
+
+/**
+ * Check all bookmarks for releases newer than their lastSeenAt.
+ * Returns one result per bookmark so callers can render feeds or counts.
+ */
+export async function checkReleases(
+  opts: { token?: string } = {},
+): Promise<Array<{ fullName: string; newReleases: TrackedRelease[]; error?: string }>> {
+  const bookmarks = getBookmarks();
+  const cache = loadCache();
+  const config = loadConfig();
+  const token = opts.token ?? config.githubToken ?? process.env.GITHUB_TOKEN;
+  const results: Array<{ fullName: string; newReleases: TrackedRelease[]; error?: string }> = [];
+
+  for (const bm of bookmarks) {
+    try {
+      const prev = cache[bm.repo.fullName];
+      const lastSeen = getLastSeen(bm.repo.fullName);
+      const isNew = (r: TrackedRelease) =>
+        !r.publishedAt || new Date(r.publishedAt).getTime() > lastSeen;
+
+      const { status, etag, releases } = await fetchReleases(bm.repo.fullName, prev?.etag, token);
+
+      if (status === 304 && prev) {
+        // Unchanged upstream; recompute against lastSeenAt (it may have moved).
+        results.push({ fullName: bm.repo.fullName, newReleases: prev.releases.filter(isNew) });
+        continue;
+      }
+      if (status !== 200 || !releases) {
+        results.push({ fullName: bm.repo.fullName, newReleases: [], error: `HTTP ${status}` });
+        continue;
+      }
+      cache[bm.repo.fullName] = { checkedAt: Date.now(), etag, releases };
+      results.push({ fullName: bm.repo.fullName, newReleases: releases.filter(isNew) });
+    } catch (err) {
+      results.push({ fullName: bm.repo.fullName, newReleases: [], error: (err as Error).message });
+    }
+  }
+
+  saveCache(cache);
+  return results;
+}
+
+/** Check + push unseen releases into the notification center, then mark them seen. Returns per-repo results. */
+export async function checkAndNotify(opts: { token?: string } = {}): Promise<Array<{ fullName: string; newReleases: TrackedRelease[]; error?: string }>> {
+  const results = await checkReleases(opts);
+  for (const r of results) {
+    for (const rel of r.newReleases) {
+      addNotification(
+        "release",
+        `${r.fullName} released ${rel.tagName}${rel.prerelease ? " [pre]" : ""}`,
+      );
+    }
+    if (r.newReleases.length > 0) markSeen(r.fullName);
+  }
+  return results;
+}
+
+/** All cached releases across bookmarks, newest first (for the Releases panel / CLI). */
+export function allCachedReleases(): Array<TrackedRelease & { fullName: string }> {
+  const cache = loadCache();
+  const bookmarks = getBookmarks();
+  return Object.entries(cache)
+    .filter(([fullName]) => bookmarks.some((b) => b.repo.fullName === fullName))
+    .flatMap(([fullName, s]) => s.releases.map((r) => ({ ...r, fullName })))
+    .sort((a, b) => new Date(b.publishedAt).getTime() - new Date(a.publishedAt).getTime());
+}

package/src/tips.ts

@@ -1,6 +1,26 @@
 /**
  * Startup tips — rotate through helpful hints.
  */
+
+/** Rotates tips without repeating the same one twice in a row. */
+export class TipRotator {
+  private tips: string[];
+  private lastIndex = -1;
+
+  constructor(tips?: string[]) {
+    this.tips = tips ?? TIPS;
+  }
+
+  next(): string {
+    let idx: number;
+    do {
+      idx = Math.floor(Math.random() * this.tips.length);
+    } while (idx === this.lastIndex && this.tips.length > 1);
+    this.lastIndex = idx;
+    return this.tips[idx];
+  }
+}
+
 const TIPS = [
   "💡 Tip: Press ? to see all keyboard shortcuts",
   "💡 Tip: Use Ctrl+R to recall past searches",
@@ -14,14 +34,9 @@ const TIPS = [
   "💡 Tip: Press Ctrl+P to copy a repo link to clipboard",
 ];
 
-let lastIndex = -1;
+export const defaultRotator = new TipRotator();
 
 /** Get the next tip (never repeats the same tip twice in a row). */
 export function nextTip(): string {
-  let idx: number;
-  do {
-    idx = Math.floor(Math.random() * TIPS.length);
-  } while (idx === lastIndex && TIPS.length > 1);
-  lastIndex = idx;
-  return TIPS[idx];
+  return defaultRotator.next();
 }

package/src/toast.ts

@@ -0,0 +1,69 @@
+/** Toast popup — absolute-positioned card pinned top-right, auto-hides. */
+import { BoxRenderable, TextRenderable } from "@opentui/core";
+
+/** Only the color keys the toast reads (lazily, so runtime theme swaps apply). */
+export interface ToastColors {
+  green: string;
+  yellow: string;
+  text: string;
+  surfaceDim: string;
+}
+
+export function createToast(
+  renderer: Parameters<BoxRenderable["constructor"]>[0],
+  root: { add(child: unknown): unknown },
+  colors: ToastColors,
+) {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const box = new BoxRenderable(renderer, {
+    visible: false,
+    position: "absolute",
+    top: 1,
+    right: 2,
+    height: 3,
+    border: true,
+    borderStyle: "rounded",
+    borderColor: colors.green,
+    backgroundColor: colors.surfaceDim,
+    zIndex: 100,
+  });
+  const text = new TextRenderable(renderer, {
+    content: "",
+    color: colors.text,
+    backgroundColor: colors.surfaceDim,
+    height: 1,
+  });
+  box.add(text);
+  root.add(box);
+
+  return {
+    /** Show a message; accent picks the border color. Re-showing resets the timer. */
+    show(msg: string, ms = 2000, accent?: string): void {
+      text.content = msg;
+      box.borderColor = accent ?? colors.green;
+      // Message + paddingX(2) + side borders(2)
+      box.width = msg.length + 4;
+      box.visible = true;
+      renderer.requestRender();
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        box.visible = false;
+        renderer.requestRender();
+      }, ms);
+    },
+    hide(): void {
+      clearTimeout(timer);
+      if (!box.visible) return;
+      box.visible = false;
+      renderer.requestRender();
+    },
+    get visible(): boolean {
+      return box.visible;
+    },
+    get borderColor(): string {
+      return box.borderColor as string;
+    },
+  };
+}
+
+export type Toast = ReturnType<typeof createToast>;

package/src/tui.ts

@@ -113,6 +113,9 @@ import {
   snoozeUpdateNotices,
   suppressUpdateNotices,
   performUpdate,
+  fetchReleaseNotes,
+  readUpdateState,
+  recordPreUpdateState,
 } from "./update-check";
 import { debugLog } from "./storage";
 const colors = {
@@ -1527,6 +1530,33 @@ export async function launchBrowser(theme_override?: string): Promise<void> {
     showOverlay("leader");
   }
 
+  // ponytail: post-upgrade panel — fires when lastInstalledVersion != current version
+  // (no network, just reads bundled release notes for the new version)
+  function checkPostUpgradePanel() {
+    const state = readUpdateState();
+    if (state.suppressed) return;
+    if (!cachedVersion) {
+      try {
+        const pkg = JSON.parse(readFileSync(join(PKG_DIR, "package.json"), "utf-8"));
+        cachedVersion = pkg.version;
+      } catch {
+        return;
+      }
+    }
+    const currentVersion = cachedVersion;
+    if (!state.lastInstalledVersion) return;
+    if (state.lastInstalledVersion === currentVersion) return;
+    // We just upgraded — show notes for the new version
+    const notes = fetchReleaseNotes(currentVersion);
+    const notesBlock = notes
+      ? renderMarkdown(notes, { width: 60 })
+      : "  No release notes found for this version.";
+    updateSelectedOption = 0;
+    updateText.content = `  Updated ghfind ${state.lastInstalledVersion} → ${currentVersion}\n\n${notesBlock}`;
+    renderUpdateOptions();
+    showOverlay("update");
+  }
+
   async function checkForUpdateAndShow(force: boolean = false) {
     if (!force && !shouldCheckUpdate()) return;
     if (cachedVersion === null) {
@@ -1544,7 +1574,11 @@ export async function launchBrowser(theme_override?: string): Promise<void> {
     markUpdateChecked(latest ?? undefined);
     if (latest) {
       updateSelectedOption = 0;
-      updateText.content = `  A new version is available\n\n  Current: ${currentVersion}\n  Latest:   ${latest}\n\n  Run "npm install -g ghfind"`;
+      const notes = fetchReleaseNotes(latest);
+      const notesBlock = notes
+        ? renderMarkdown(notes, { width: 60 })
+        : `  A new version is available\n\n  Current: ${currentVersion}\n  Latest:   ${latest}\n\n  Run "npm install -g ghfind"`;
+      updateText.content = `  A new version is available\n\n  Current: ${currentVersion}\n  Latest:   ${latest}\n\n${notesBlock}`;
       renderUpdateOptions();
       showOverlay("update");
     } else {
@@ -2577,6 +2611,8 @@ ${pack.description ?? ""}`;
           const action = ["now", "later", "never"][updateSelectedOption] as "now" | "later" | "never" | undefined;
           if (action === "now") {
             showOverlay("none");
+            // ponytail: record the running version so the next launch detects the upgrade
+            recordPreUpdateState(cachedVersion ?? "");
             performUpdate().then((ok) => {
               if (ok) {
                 setStatus("✓ Update complete — restart ghfind");
@@ -2772,6 +2808,7 @@ ${pack.description ?? ""}`;
     showLanding(true);
   }
   checkForUpdateAndShow();
+  checkPostUpgradePanel();
   renderer.start();
   if (session && session.mode) {
     if (currentMode === "trending") {

package/src/types.ts

@@ -104,6 +104,8 @@ export interface Bookmark {
   savedAt: number;
   tags: string[];
   notes?: string;
+  /** Releases published after this are "unseen". Set when the Releases panel is viewed. */
+  lastSeenAt?: number;
 }
 
 /** A named, saved search. */
@@ -120,7 +122,7 @@ export interface SavedSearch {
 
 /** Session state restored on startup. */
 export interface SessionState {
-  mode: "search" | "trending" | "packages";
+  mode: "search" | "trending" | "packages" | "bookmarks";
   query: string;
   sort: SortStrategy;
   limit: number;

package/src/update-check.ts

@@ -6,10 +6,15 @@
  */
 import { readJSON, writeJSON, debugLog } from "./storage";
 import { stateDir } from "./config";
+import { readFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
 
 const REGISTRY_URL = "https://registry.npmjs.org/github-search-cli/latest";
 const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000; // 24 hours
 const REQUEST_TIMEOUT_MS = 5000;
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PKG_DIR = join(__dirname, "..");
 
 export interface UpdateState {
   /** Timestamp of last successful check. */
@@ -20,6 +25,8 @@ export interface UpdateState {
   suppressed: boolean;
   /** Latest version found on last check (for display). */
   latestVersion?: string;
+  /** Version at time of last successful install (populated before performUpdate). */
+  lastInstalledVersion?: string;
 }
 
 const STATE_FILE = "update-state.json";
@@ -160,3 +167,49 @@ export async function performUpdate(): Promise<boolean> {
     return false;
   }
 }
+
+
+/**
+ * Record the current version as "last installed" before performing an update.
+ * This lets the post-upgrade startup detect the version change and show notes.
+ */
+export function recordPreUpdateState(currentVersion: string): void {
+  writeUpdateState({
+    ...readUpdateState(),
+    lastInstalledVersion: currentVersion,
+  });
+}
+
+/**
+ * Fetch release notes for a given version.
+ * Tries release-notes/<version>.md first, then falls back to CHANGELOG.md section.
+ * Returns the markdown text or null if not found.
+ */
+export function fetchReleaseNotes(version: string): string | null {
+  // ponytail: embedded notes are the primary source — they ship in the tarball, no network
+  try {
+    const notesPath = join(PKG_DIR, "release-notes", `${version}.md`);
+    const md = readFileSync(notesPath, "utf-8");
+    if (md.trim().length > 0) return md;
+  } catch {
+    // File doesn't exist for this version — fall through to CHANGELOG
+  }
+
+  // ponytail: CHANGELOG.md fallback — parse section for this version
+  try {
+    const changelogPath = join(PKG_DIR, "CHANGELOG.md");
+    const changelog = readFileSync(changelogPath, "utf-8");
+    // ponytail: find "## [version]" header, slice until next "## "
+    const header = "## [" + version + "]";
+    const start = changelog.indexOf(header);
+    if (start === -1) return null;
+    const bodyStart = start + header.length;
+    const rest = changelog.substring(bodyStart);
+    const nextHeaderIdx = rest.indexOf("\n## ");
+    const end = nextHeaderIdx === -1 ? changelog.length : bodyStart + nextHeaderIdx;
+    return changelog.substring(bodyStart, end).trim();
+  } catch {
+    // CHANGELOG.md doesn't exist either
+  }
+  return null;
+}