github-search-cli 9.2.1 → 9.4.0

package/src/markdown-render.ts

@@ -0,0 +1,216 @@
+/**
+ * Minimal markdown-to-terminal-text renderer.
+ *
+ * Renders headings, code blocks, lists, tables, blockquotes, horizontal rules,
+ * bold/italic, and links into a plain-text representation suitable for a
+ * TextRenderable in the TUI.
+ */
+
+interface RenderOptions {
+  /** Terminal width for wrapping and table layout. Default: 80. */
+  width?: number;
+}
+
+/** Render markdown text to terminal-friendly plain text. */
+export function renderMarkdown(md: string, opts: RenderOptions = {}): string {
+  const width = opts.width ?? 80;
+  const lines = md.split("\n");
+  const out: string[] = [];
+  let inCodeBlock = false;
+  let codeLang = "";
+  let codeLines: string[] = [];
+  let inTable = false;
+  let tableRows: string[][] = [];
+
+  function flushCode() {
+    if (codeLines.length === 0) return;
+    const maxLen = Math.max(...codeLines.map((l) => l.length), codeLang.length);
+    const barW = Math.min(maxLen + 4, width - 2);
+    out.push("┌" + "─".repeat(barW) + "┐");
+    if (codeLang) out.push("│ " + codeLang.padEnd(barW - 1) + "│");
+    for (const cl of codeLines) {
+      out.push("│ " + cl.padEnd(barW - 1) + "│");
+    }
+    out.push("└" + "─".repeat(barW) + "┘");
+    out.push("");
+    codeLines = [];
+    codeLang = "";
+  }
+
+  function flushTable() {
+    if (tableRows.length === 0) return;
+    const dataRows = tableRows.filter(
+      (r) => !r.every((c) => /^[\s\-:|]+$/.test(c)),
+    );
+    if (dataRows.length === 0) {
+      tableRows = [];
+      return;
+    }
+    const colCount = Math.max(...dataRows.map((r) => r.length));
+    const colW: number[] = [];
+    for (let ci = 0; ci < colCount; ci++) {
+      colW.push(
+        Math.max(
+          3,
+          ...dataRows.map((r) => (r[ci] ?? "").length),
+        ),
+      );
+    }
+    const totalW = colW.reduce((a, b) => a + b, 0) + colCount * 3 - 1;
+    if (totalW > width) {
+      for (const row of dataRows) {
+        out.push("  " + row.map((c) => c.trim()).join(" │ "));
+      }
+    } else {
+      const sep = "┌" + colW.map((w) => "─".repeat(w + 2)).join("┬") + "┐";
+      const mid = "├" + colW.map((w) => "─".repeat(w + 2)).join("┼") + "┤";
+      const end = "└" + colW.map((w) => "─".repeat(w + 2)).join("┴") + "┘";
+      out.push(sep);
+      dataRows.forEach((row, i) => {
+        const cells = colW.map((w, ci) => (row[ci] ?? "").trim().padEnd(w));
+        out.push("│ " + cells.map((c) => ` ${c} `).join("│") + "│");
+        if (i === 0) out.push(mid);
+      });
+      out.push(end);
+    }
+    out.push("");
+    tableRows = [];
+  }
+
+  function renderInline(line: string): string {
+    // Bold
+    line = line.replace(/\*\*(.+?)\*\*/g, "$1");
+    // Italic (no asterisks)
+    line = line.replace(/\*([^*]+?)\*/g, "$1");
+    // Inline code
+    line = line.replace(/`([^`]+)`/g, "⟨$1⟩");
+    // Links [text](url)
+    line = line.replace(/\[([^\]]+)\]\(([^)]+)\)/g, "$1 ($2)");
+    // Images
+    line = line.replace(/!\[([^\]]*)\]\([^)]+\)/g, "🖼 $1");
+    return line;
+  }
+
+  function wrapLine(line: string, maxW: number): string[] {
+    if (line.length <= maxW) return [line];
+    const parts: string[] = [];
+    let remaining = line;
+    while (remaining.length > maxW) {
+      let breakAt = maxW;
+      const spaceIdx = remaining.lastIndexOf(" ", maxW);
+      if (spaceIdx > maxW / 2) breakAt = spaceIdx;
+      parts.push(remaining.slice(0, breakAt));
+      remaining = remaining.slice(breakAt).replace(/^ /, "");
+    }
+    if (remaining) parts.push(remaining);
+    return parts;
+  }
+
+  for (let i = 0; i < lines.length; i++) {
+    let line = lines[i];
+
+    // Code block boundaries
+    if (/^```/.test(line)) {
+      if (inCodeBlock) {
+        flushCode();
+        inCodeBlock = false;
+      } else {
+        inCodeBlock = true;
+        codeLang = line.slice(3).trim();
+      }
+      continue;
+    }
+    if (inCodeBlock) {
+      codeLines.push(line);
+      continue;
+    }
+
+    // Table row
+    if (line.includes("|")) {
+      const cells = line
+        .split("|")
+        .map((c) => c.trim())
+        .filter((_, idx, arr) => idx > 0 && idx < arr.length - 1);
+      if (cells.length >= 2) {
+        inTable = true;
+        tableRows.push(cells);
+        continue;
+      }
+    } else if (inTable) {
+      flushTable();
+      inTable = false;
+    }
+
+    // Horizontal rule
+    if (/^(\s*[-*_]){3,}\s*$/.test(line)) {
+      out.push("─".repeat(Math.min(width, 40)));
+      out.push("");
+      continue;
+    }
+
+    // Headings
+    const headingMatch = line.match(/^(#{1,6})\s+(.+)/);
+    if (headingMatch) {
+      const level = headingMatch[1].length;
+      const text = renderInline(headingMatch[2]);
+      const prefix = "█ ".repeat(level);
+      out.push("");
+      out.push(prefix + text);
+      out.push("");
+      continue;
+    }
+
+    // Blockquote
+    const bqMatch = line.match(/^>\s?(.*)/);
+    if (bqMatch) {
+      const inner = renderInline(bqMatch[1]);
+      for (const wl of wrapLine(inner, width - 4)) {
+        out.push("│ " + wl);
+      }
+      continue;
+    }
+
+    // Unordered list
+    const ulMatch = line.match(/^(\s*)[-*+]\s+(.*)/);
+    if (ulMatch) {
+      const indent = ulMatch[1].length;
+      const depth = Math.floor(indent / 2);
+      const prefix = "  ".repeat(depth) + "• ";
+      const inner = renderInline(ulMatch[2]);
+      for (const wl of wrapLine(inner, width - prefix.length)) {
+        out.push(prefix + wl);
+      }
+      continue;
+    }
+
+    // Ordered list
+    const olMatch = line.match(/^(\s*)\d+\.\s+(.*)/);
+    if (olMatch) {
+      const indent = olMatch[1].length;
+      const depth = Math.floor(indent / 2);
+      const prefix = "  ".repeat(depth) + "◦ ";
+      const inner = renderInline(olMatch[2]);
+      for (const wl of wrapLine(inner, width - prefix.length)) {
+        out.push(prefix + wl);
+      }
+      continue;
+    }
+
+    // Empty line
+    if (line.trim() === "") {
+      out.push("");
+      continue;
+    }
+
+    // Paragraph
+    const rendered = renderInline(line);
+    for (const wl of wrapLine(rendered, width)) {
+      out.push(wl);
+    }
+  }
+
+  if (inCodeBlock) flushCode();
+  if (inTable) flushTable();
+
+  return out.join("\n");
+}

package/src/notifications.ts

@@ -3,7 +3,7 @@ import { readJSON, writeJSON } from "./storage";
 
 export interface Notification {
   id: number;
-  type: "info" | "warning" | "rate-limit" | "watch-change" | "upgrade";
+  type: "info" | "warning" | "rate-limit" | "watch-change" | "upgrade" | "release";
   icon: string;
   message: string;
   timestamp: number;
@@ -39,6 +39,7 @@ function iconFor(type: Notification["type"]): string {
     case "rate-limit": return "🚫";
     case "watch-change": return "🔔";
     case "upgrade": return "📦";
+    case "release": return "🚀";
   }
 }
 

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

@@ -79,6 +79,7 @@ import {
 import { saveSession, restoreSession } from "./session";
 import { fetchDeepDive, buildDeepDiveText } from "./deepdive";
 import { buildComparisonTable } from "./compare";
+import { renderMarkdown } from "./markdown-render";
 import { fetchTopics, type TopicItem } from "./explore";
 import { exportToFile, type ExportFormat } from "./output";
 import { listThemes, loadTheme } from "./themes";
@@ -112,6 +113,9 @@ import {
   snoozeUpdateNotices,
   suppressUpdateNotices,
   performUpdate,
+  fetchReleaseNotes,
+  readUpdateState,
+  recordPreUpdateState,
 } from "./update-check";
 import { debugLog } from "./storage";
 const colors = {
@@ -1526,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) {
@@ -1543,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 {
@@ -1709,17 +1744,8 @@ export async function launchBrowser(theme_override?: string): Promise<void> {
       if (!text) {
         readmeText.content = `  (no README found for ${repo.fullName})`;
       } else {
-        // ponytail: just strip markdown formatting, show full text
-        const stripped = text
-          .replace(/```[\s\S]*?```/g, "[code block]")
-          .replace(/#{1,6}\s/g, "")
-          .replace(/\*\*(.+?)\*\*/g, "$1")
-          .replace(/\[(.+?)\]\(.+?\)/g, "$1")
-          .replace(/`([^`]+)`/g, "$1")
-          .split("\n")
-          .map((l) => l.trimEnd())
-          .join("\n");
-        readmeText.content = stripped;
+        const termW = Math.max(40, (process.stdout.columns || 80) - 4);
+        readmeText.content = renderMarkdown(text, { width: termW });
       }
     } catch {
       readmeText.content = "  Failed to load README";
@@ -2585,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");
@@ -2646,6 +2674,8 @@ ${pack.description ?? ""}`;
         showLeaderMenu();
       }
       return;
+    }
+
     // 't' toggles theme and persists to config
     if (key.name === "t" && !searchInput.focused) {
       const current = config.theme;
@@ -2659,7 +2689,6 @@ ${pack.description ?? ""}`;
       renderer.requestRender();
       return;
     }
-    }
 
     // 'c' toggles compare on selected repo (when not typing in search)
     if (key.name === "c" && !searchInput.focused) {
@@ -2779,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;