github-search-cli 9.7.0 → 9.8.0

package/src/markdown-view.ts

@@ -0,0 +1,300 @@
+/**
+ * Full markdown view for OpenTUI.
+ *
+ * A real `MarkdownRenderable` with a theme-derived syntax style, themed
+ * headings, and inline images drawn as half blocks. Used by the README
+ * viewer and by the update modal's release notes.
+ */
+import {
+  BoxRenderable,
+  MarkdownRenderable,
+  RGBA,
+  StyledText,
+  SyntaxStyle,
+  TextRenderable,
+  createTextAttributes,
+  type CliRenderer,
+  type RenderNodeContext,
+  type Renderable,
+  type TextChunk,
+} from "@opentui/core";
+import {
+  rasterizeImage,
+  toImageRuns,
+  type HalfBlockImage,
+  type Rgb,
+} from "./image-render";
+import { resolveReadmeImageUrl } from "./image-loader";
+import {
+  extractImageRefs,
+  inlinePlainText,
+  type BlockTokenLike,
+  type ImageRef,
+} from "./markdown-images";
+
+/** Tallest inline image, in terminal cells. */
+export const MAX_IMAGE_ROWS = 24;
+
+export interface MarkdownViewOptions {
+  renderer: CliRenderer;
+  /** Theme palette (see src/themes.ts). */
+  colors: Record<string, string>;
+  /** URL of the markdown document, used to resolve relative image paths. */
+  imageBase?: string;
+  /** Panel background, painted behind text, captions and images. Default: colors.bg. */
+  background?: string;
+  /** Render inline images. Default: true. */
+  images?: boolean;
+  /** Fetches bytes for a resolved image URL. */
+  loadImage?: (url: string) => Promise<Uint8Array | null>;
+  /** Width available for an image, in cells. */
+  getImageWidth?: () => number;
+  /** Height cap for one image, in cells. Default: MAX_IMAGE_ROWS. */
+  maxImageRows?: number;
+}
+
+export interface MarkdownView {
+  readonly renderable: MarkdownRenderable;
+  readonly imagesEnabled: boolean;
+  /** Replace the document; relative images resolve against `imageBase`. */
+  setContent(markdown: string, imageBase?: string): void;
+  /** Turn inline images on/off and rebuild the document. */
+  setImagesEnabled(enabled: boolean): void;
+}
+
+/** Syntax style for the markdown grammar's highlight groups. */
+export function createMarkdownStyle(
+  colors: Record<string, string>,
+): SyntaxStyle {
+  const surface = colors.surface ?? colors.bg;
+  return SyntaxStyle.fromStyles({
+    default: { fg: colors.text ?? "#ffffff" },
+    conceal: { fg: colors.muted ?? "#888888" },
+    "markup.heading": { fg: colors.accent ?? colors.blue, bold: true },
+    "markup.strong": { fg: colors.text ?? "#ffffff", bold: true },
+    "markup.italic": { fg: colors.text ?? "#ffffff", italic: true },
+    "markup.strikethrough": { fg: colors.muted ?? "#888888", dim: true },
+    "markup.raw": { fg: colors.green ?? "#a6e3a1", bg: surface },
+    "markup.raw.block": { fg: colors.green ?? "#a6e3a1" },
+    "markup.link": { fg: colors.accent ?? colors.blue },
+    "markup.link.label": {
+      fg: colors.accent ?? colors.blue,
+      underline: true,
+    },
+    "markup.link.url": { fg: colors.muted ?? "#888888", underline: true },
+    "markup.quote": { fg: colors.muted ?? "#888888", italic: true },
+    "markup.list": { fg: colors.blue ?? colors.accent },
+  });
+}
+
+function hexToRgb(hex: string | undefined): Rgb {
+  const fallback: Rgb = [0, 0, 0];
+  if (!hex) return fallback;
+  const match = /^#?([0-9a-f]{6})$/i.exec(hex.trim());
+  if (!match) return fallback;
+  const value = Number.parseInt(match[1], 16);
+  return [(value >> 16) & 0xff, (value >> 8) & 0xff, value & 0xff];
+}
+
+function rgba(color: Rgb): RGBA {
+  return RGBA.fromValues(color[0], color[1], color[2], 255);
+}
+
+/** Half-block rows as one styled-text block (one line per image row). */
+function imageStyledText(image: HalfBlockImage): StyledText {
+  const chunks: TextChunk[] = [];
+  toImageRuns(image).forEach((runs, rowIndex) => {
+    if (rowIndex > 0) chunks.push({ __isChunk: true, text: "\n" });
+    for (const run of runs) {
+      chunks.push({
+        __isChunk: true,
+        text: run.text,
+        fg: rgba(run.top),
+        bg: rgba(run.bottom),
+      });
+    }
+  });
+  return new StyledText(chunks);
+}
+
+/**
+ * Build the markdown renderable and its block renderers.
+ *
+ * Two OpenTUI quirks shape the options below:
+ *
+ * - `streaming`: without a loaded tree-sitter markdown grammar a finished
+ *   block has no highlights to draw and renders as blank lines, so the
+ *   styled initial text has to be kept alive instead.
+ * - `internalBlockMode: "top-level"`: in the default coalesced mode every
+ *   style refresh re-renders blocks with the built-in renderers, which
+ *   throws away the custom heading/image renderables created here.
+ */
+export function createMarkdownView(opts: MarkdownViewOptions): MarkdownView {
+  const { renderer, colors } = opts;
+  const maxImageRows = opts.maxImageRows ?? MAX_IMAGE_ROWS;
+  const rasterCache = new Map<string, Promise<HalfBlockImage | null>>();
+  let imagesEnabled = opts.images ?? true;
+  let imageBase = opts.imageBase;
+
+  const text = () => colors.text ?? "#ffffff";
+  const bg = () => opts.background ?? colors.bg ?? "#000000";
+  const muted = () => colors.muted ?? "#888888";
+
+  const renderable = new MarkdownRenderable(renderer, {
+    content: "",
+    syntaxStyle: createMarkdownStyle(colors),
+    fg: text(),
+    bg: bg(),
+    conceal: true,
+    streaming: true,
+    internalBlockMode: "top-level",
+    // Borderless columns are the top-level default; boxed tables read better
+    // for the multi-column tables READMEs use.
+    tableOptions: { style: "grid" },
+    width: "100%",
+  });
+
+  const caption = (label: string, color = muted()) =>
+    new TextRenderable(renderer, {
+      content: `  ${label}`,
+      fg: color,
+      bg: bg(),
+      wrapMode: "word",
+      flexShrink: 0,
+      width: "100%",
+    });
+
+  const rasterize = (url: string): Promise<HalfBlockImage | null> => {
+    // Size is part of the key: a resized terminal needs fresh cells.
+    const maxCols = Math.max(8, Math.floor(opts.getImageWidth?.() ?? 100));
+    const key = `${maxCols}|${url}`;
+    const cached = rasterCache.get(key);
+    if (cached) return cached;
+    const pending = (async () => {
+      const loader = opts.loadImage;
+      if (!loader) return null;
+      const bytes = await loader(url);
+      if (!bytes) return null;
+      return rasterizeImage(bytes, {
+        maxCols,
+        maxRows: maxImageRows,
+        background: hexToRgb(bg()),
+      });
+    })();
+    rasterCache.set(key, pending);
+    return pending;
+  };
+
+  const imageNode = (image: ImageRef): Renderable => {
+    const label = `🖼  ${image.alt.trim() || "image"}`;
+    const url = imageBase ? resolveReadmeImageUrl(image.href, imageBase) : null;
+    if (!imagesEnabled || !url || !opts.loadImage) return caption(label);
+
+    const container = new BoxRenderable(renderer, {
+      flexDirection: "column",
+      flexShrink: 0,
+      width: "100%",
+    });
+    const placeholder = caption(`${label}  (loading…)`);
+    container.add(placeholder);
+
+    void rasterize(url).then(
+      (cells) => {
+        console.error(
+          `[dbg] image resolved: cells=${cells ? `${cells.cols}x${cells.rows}` : "null"} destroyed=${container.isDestroyed} parent=${!!container.parent} enabled=${imagesEnabled}`,
+        );
+        // The document may have been replaced (or the overlay closed) while
+        // the image was downloading.
+        if (container.isDestroyed || !container.parent) return;
+        container.remove(placeholder);
+        placeholder.destroy();
+        container.add(caption(label));
+        if (cells) {
+          container.add(
+            new TextRenderable(renderer, {
+              content: imageStyledText(cells),
+              bg: bg(),
+              wrapMode: "none",
+              selectable: false,
+              flexShrink: 0,
+            }),
+          );
+        }
+        renderable.requestRender();
+      },
+      (err) => {
+        console.error("[dbg] image promise rejected:", err);
+      },
+    );
+    return container;
+  };
+
+  const headingNode = (token: BlockTokenLike): Renderable | undefined => {
+    const heading = inlinePlainText(token.tokens).trim();
+    if (!heading) return undefined;
+    const depth = token.depth ?? 1;
+    const color = depth <= 2 ? colors.accent : (colors.teal ?? colors.accent);
+    return new TextRenderable(renderer, {
+      content: new StyledText([
+        {
+          __isChunk: true,
+          text: heading,
+          fg: RGBA.fromHex(color ?? "#ffffff"),
+          attributes: createTextAttributes({
+            bold: true,
+            underline: depth === 1,
+          }),
+        },
+      ]),
+      bg: bg(),
+      wrapMode: "word",
+      flexShrink: 0,
+      width: "100%",
+    });
+  };
+
+  const buildRenderNode =
+    () =>
+    (
+      token: BlockTokenLike,
+      _context: RenderNodeContext,
+    ): Renderable | undefined => {
+      if (token.type === "heading") return headingNode(token);
+      const images = extractImageRefs(token);
+      if (images && images.length > 0) {
+        const box = new BoxRenderable(renderer, {
+          flexDirection: "column",
+          flexShrink: 0,
+          width: "100%",
+          marginTop: 1,
+        });
+        for (const image of images) box.add(imageNode(image));
+        return box;
+      }
+      return undefined;
+    };
+
+  renderable.renderNode = buildRenderNode();
+
+  return {
+    renderable,
+    get imagesEnabled() {
+      return imagesEnabled;
+    },
+    setContent(markdown: string, base?: string) {
+      if (base !== undefined) imageBase = base;
+      // Rebuild the style so theme switches (which mutate `colors`) apply.
+      renderable.syntaxStyle = createMarkdownStyle(colors);
+      renderable.fg = text();
+      renderable.bg = bg();
+      renderable.content = markdown;
+    },
+    setImagesEnabled(enabled: boolean) {
+      if (imagesEnabled === enabled) return;
+      imagesEnabled = enabled;
+      // A fresh renderNode identity forces a full block rebuild.
+      renderable.renderNode = buildRenderNode();
+      renderable.requestRender();
+    },
+  };
+}

package/src/mcp-server.ts

@@ -801,7 +801,7 @@ export async function processServerLine(
 // ─── stdio transport ───────────────────────────────────────────────────
 
 function writeStdout(line: string): void {
-  process.stdout.write(line + "\n");
+  process.stdout.write(`${line}\n`);
 }
 
 /**
@@ -831,8 +831,9 @@ export async function runMcpServer(
   let buffer = "";
   process.stdin.on("data", (chunk: string) => {
     buffer += chunk;
-    let idx: number;
-    while ((idx = buffer.indexOf("\n")) >= 0) {
+    for (;;) {
+      const idx = buffer.indexOf("\n");
+      if (idx < 0) break;
       const line = buffer.slice(0, idx).trim();
       buffer = buffer.slice(idx + 1);
       if (!line) continue;

package/src/open-url.ts

@@ -1,15 +1,26 @@
 /**
- * Open a URL in the user's default browser — platform-aware.
+ * Open a URL in the user's default browser — platform- and runtime-aware.
  *
- * only if the open/xdg-open pattern fails somewhere.
+ * Windows note: `explorer.exe` is used instead of the classic
+ * `cmd /c start "" <url>` idiom. cmd splits the URL at the first unquoted
+ * `&` (a query-string separator) and executes the rest as a command, which
+ * truncated every URL with query params. explorer.exe receives the URL as a
+ * single CreateProcess argument, so `&` is never interpreted.
  */
+import { spawn } from "node:child_process";
 
 export function openUrl(url: string): void {
   try {
     const p = process.platform;
-    if (p === "win32") Bun.spawn(["cmd", "/c", "start", "", url]);
-    else if (p === "darwin") Bun.spawn(["open", url]);
-    else Bun.spawn(["xdg-open", url]);
+    const cmd =
+      p === "win32" ? "explorer" : p === "darwin" ? "open" : "xdg-open";
+    if (typeof Bun !== "undefined") {
+      Bun.spawn([cmd, url]);
+      return;
+    }
+    // Node fallback — detached so the child survives our exit.
+    const child = spawn(cmd, [url], { detached: true, stdio: "ignore" });
+    child.unref();
   } catch {
     // non-critical — user can copy the URL manually
   }

package/src/output.ts

@@ -5,7 +5,7 @@
  * clone-commands, ids) register in a single registry. One `format()` function
  * dispatches. `exportToFile` and `pipeExec` are methods on the same module.
  */
-import { writeFileSync } from "fs";
+import { writeFileSync } from "node:fs";
 import type { Repo } from "./types";
 import { openUrl } from "./open-url";
 

package/src/package-browser.ts

@@ -49,7 +49,7 @@ function formatPackageLine(pack: Package): StyledText {
   const scoreStr = `score ${pack.score.toFixed(2)}`.padEnd(12).slice(0, 12);
   const desc =
     (pack.description ?? "").length > 60
-      ? (pack.description ?? "").slice(0, 57) + "..."
+      ? `${(pack.description ?? "").slice(0, 57)}...`
       : (pack.description ?? "");
   const line1 = t`${bold(fg(C.nameText)(nameStr))}${fg(C.cyan)(dlStr)}${fg(C.gold)(scoreStr)}`;
   const line2 = t`${dim(fg(C.descText)(`     ${desc}`))}`;

package/src/png.ts

@@ -0,0 +1,260 @@
+/**
+ * Minimal PNG decoder — pure TypeScript, no native deps.
+ *
+ * Only used to turn an image into cells we can print, so it covers the
+ * subset every encoder emits: no interlace, all five colour types, bit
+ * depths 1–16, tRNS transparency. Palette + tRNS are expanded to RGBA so
+ * callers only ever see 8-bit RGBA.
+ *
+ * Sources that aren't PNG (JPEG, WebP, GIF, AVIF, …) are normalised
+ * upstream by `Bun.Image` before they get here.
+ */
+import { inflateSync } from "node:zlib";
+
+export interface DecodedImage {
+  width: number;
+  height: number;
+  /** Row-major RGBA, 4 bytes per pixel. */
+  data: Uint8Array;
+}
+
+const PNG_SIGNATURE = [137, 80, 78, 71, 13, 10, 26, 10];
+
+/** Number of samples per pixel for each PNG colour type. */
+function channelsForColorType(colorType: number): number {
+  switch (colorType) {
+    case 0:
+      return 1; // greyscale
+    case 2:
+      return 3; // truecolour
+    case 3:
+      return 1; // palette index
+    case 4:
+      return 2; // greyscale + alpha
+    case 6:
+      return 4; // truecolour + alpha
+    default:
+      throw new Error(`Unsupported PNG colour type ${colorType}`);
+  }
+}
+
+/** Paeth predictor, per the PNG spec (§9.4). */
+function paeth(a: number, b: number, c: number): number {
+  const p = a + b - c;
+  const pa = Math.abs(p - a);
+  const pb = Math.abs(p - b);
+  const pc = Math.abs(p - c);
+  if (pa <= pb && pa <= pc) return a;
+  if (pb <= pc) return b;
+  return c;
+}
+
+/** Reverse the per-scanline filters applied by the encoder. */
+function unfilter(
+  raw: Uint8Array,
+  height: number,
+  bytesPerRow: number,
+  bytesPerPixel: number,
+): Uint8Array {
+  const out = new Uint8Array(height * bytesPerRow);
+  let src = 0;
+  for (let y = 0; y < height; y++) {
+    const filter = raw[src++];
+    const rowStart = y * bytesPerRow;
+    const prevStart = rowStart - bytesPerRow;
+    for (let x = 0; x < bytesPerRow; x++) {
+      const value = raw[src + x];
+      const left = x >= bytesPerPixel ? out[rowStart + x - bytesPerPixel] : 0;
+      const up = y > 0 ? out[prevStart + x] : 0;
+      const upLeft =
+        y > 0 && x >= bytesPerPixel ? out[prevStart + x - bytesPerPixel] : 0;
+      let result: number;
+      switch (filter) {
+        case 0:
+          result = value;
+          break;
+        case 1:
+          result = value + left;
+          break;
+        case 2:
+          result = value + up;
+          break;
+        case 3:
+          result = value + ((left + up) >> 1);
+          break;
+        case 4:
+          result = value + paeth(left, up, upLeft);
+          break;
+        default:
+          throw new Error(`Unsupported PNG filter type ${filter}`);
+      }
+      out[rowStart + x] = result & 0xff;
+    }
+    src += bytesPerRow;
+  }
+  return out;
+}
+
+/** Read the `index`-th sample of a row for sub-byte bit depths. */
+function sampleAt(
+  row: Uint8Array,
+  offsetInRow: number,
+  index: number,
+  bitDepth: number,
+): number {
+  if (bitDepth === 8) return row[offsetInRow + index];
+  if (bitDepth === 16) return row[offsetInRow + index * 2];
+  const bitOffset = index * bitDepth;
+  const byte = row[offsetInRow + (bitOffset >> 3)];
+  const shift = 8 - bitDepth - (bitOffset & 7);
+  return (byte >> shift) & ((1 << bitDepth) - 1);
+}
+
+/** Decode PNG bytes into 8-bit RGBA. Throws on unsupported variants. */
+export function decodePng(bytes: Uint8Array): DecodedImage {
+  if (bytes.length < 8) throw new Error("PNG too short");
+  for (let i = 0; i < PNG_SIGNATURE.length; i++) {
+    if (bytes[i] !== PNG_SIGNATURE[i]) throw new Error("Not a PNG file");
+  }
+
+  let width = 0;
+  let height = 0;
+  let bitDepth = 8;
+  let colorType = 6;
+  let interlace = 0;
+  let palette: Uint8Array | null = null;
+  let transparency: Uint8Array | null = null;
+  const idat: Uint8Array[] = [];
+
+  let offset = 8;
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  while (offset + 8 <= bytes.length) {
+    const length = view.getUint32(offset);
+    const type = String.fromCharCode(
+      bytes[offset + 4],
+      bytes[offset + 5],
+      bytes[offset + 6],
+      bytes[offset + 7],
+    );
+    const dataStart = offset + 8;
+    const dataEnd = dataStart + length;
+    if (dataEnd > bytes.length) throw new Error("Truncated PNG chunk");
+
+    switch (type) {
+      case "IHDR": {
+        width = view.getUint32(dataStart);
+        height = view.getUint32(dataStart + 4);
+        bitDepth = bytes[dataStart + 8];
+        colorType = bytes[dataStart + 9];
+        interlace = bytes[dataStart + 12];
+        break;
+      }
+      case "PLTE":
+        palette = bytes.subarray(dataStart, dataEnd);
+        break;
+      case "tRNS":
+        transparency = bytes.subarray(dataStart, dataEnd);
+        break;
+      case "IDAT":
+        idat.push(bytes.subarray(dataStart, dataEnd));
+        break;
+      default:
+        break;
+    }
+    offset = dataEnd + 4; // skip CRC
+    if (type === "IEND") break;
+  }
+
+  if (width === 0 || height === 0) throw new Error("PNG has no IHDR");
+  if (interlace !== 0) throw new Error("Interlaced PNG is not supported");
+
+  const channels = channelsForColorType(colorType);
+  const bitsPerPixel = channels * bitDepth;
+  const bytesPerRow = Math.ceil((width * bitsPerPixel) / 8);
+  const bytesPerPixel = Math.max(1, Math.ceil(bitsPerPixel / 8));
+
+  const compressed = idat.length === 1 ? idat[0] : concat(idat);
+  const raw = new Uint8Array(inflateSync(compressed));
+  // One filter byte per scanline plus the samples themselves.
+  if (raw.length < height * (bytesPerRow + 1)) {
+    throw new Error("Truncated PNG pixel data");
+  }
+  const rows = unfilter(raw, height, bytesPerRow, bytesPerPixel);
+
+  const out = new Uint8Array(width * height * 4);
+  const maxSample = (1 << Math.min(bitDepth, 8)) - 1;
+  const scale = bitDepth === 16 ? 1 / 257 : 255 / maxSample;
+
+  for (let y = 0; y < height; y++) {
+    const row = rows.subarray(y * bytesPerRow, (y + 1) * bytesPerRow);
+    for (let x = 0; x < width; x++) {
+      const to8 = (sample: number) =>
+        bitDepth === 8 || bitDepth === 16 ? sample : Math.round(sample * scale);
+      let r: number;
+      let g: number;
+      let b: number;
+      let a = 255;
+      switch (colorType) {
+        case 0: {
+          const grey = to8(sampleAt(row, 0, x, bitDepth));
+          r = g = b = grey;
+          break;
+        }
+        case 2:
+          r = to8(sampleAt(row, 0, x * 3, bitDepth));
+          g = to8(sampleAt(row, 0, x * 3 + 1, bitDepth));
+          b = to8(sampleAt(row, 0, x * 3 + 2, bitDepth));
+          break;
+        case 3: {
+          const index = sampleAt(row, 0, x, bitDepth);
+          const p = index * 3;
+          if (!palette || p + 2 >= palette.length)
+            throw new Error("PNG palette entry missing");
+          r = palette[p];
+          g = palette[p + 1];
+          b = palette[p + 2];
+          if (transparency && index < transparency.length)
+            a = transparency[index];
+          break;
+        }
+        case 4: {
+          const grey = to8(sampleAt(row, 0, x * 2, bitDepth));
+          r = g = b = grey;
+          a = to8(sampleAt(row, 0, x * 2 + 1, bitDepth));
+          break;
+        }
+        default: {
+          r = to8(sampleAt(row, 0, x * 4, bitDepth));
+          g = to8(sampleAt(row, 0, x * 4 + 1, bitDepth));
+          b = to8(sampleAt(row, 0, x * 4 + 2, bitDepth));
+          a = to8(sampleAt(row, 0, x * 4 + 3, bitDepth));
+          break;
+        }
+      }
+      if (colorType === 0 && transparency && transparency.length >= 2) {
+        const key = (transparency[0] << 8) | transparency[1];
+        const sample = sampleAt(row, 0, x, bitDepth);
+        if (sample === key) a = 0;
+      }
+      const o = (y * width + x) * 4;
+      out[o] = r;
+      out[o + 1] = g;
+      out[o + 2] = b;
+      out[o + 3] = a;
+    }
+  }
+
+  return { width, height, data: out };
+}
+
+function concat(chunks: Uint8Array[]): Uint8Array {
+  let total = 0;
+  for (const c of chunks) total += c.length;
+  const merged = new Uint8Array(total);
+  let offset = 0;
+  for (const c of chunks) {
+    merged.set(c, offset);
+    offset += c.length;
+  }
+  return merged;
+}

package/src/releases.ts

@@ -1,16 +1,3 @@
-/**
- * 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";
@@ -68,7 +55,7 @@ async function fetchReleases(
     Accept: "application/vnd.github+json",
   };
   if (etag) headers["If-None-Match"] = etag;
-  if (token) headers["Authorization"] = `Bearer ${token}`;
+  if (token) headers.Authorization = `Bearer ${token}`;
   const res = await fetch(
     `https://api.github.com/repos/${fullName}/releases?per_page=${PER_REPO}`,
     { headers },

package/src/search-state.ts

@@ -4,7 +4,7 @@
  * The TUI view layer reads from SearchState and dispatches actions.
  * This module is testable without the OpenTUI renderer.
  */
-import type { Repo, SearchOptions, SortStrategy, SessionState } from "./types";
+import type { Repo, SortStrategy, SessionState } from "./types";
 import type { TabName } from "./trending";
 import { tabSince } from "./trending";
 import {
@@ -24,7 +24,6 @@ import {
   touchSavedSearch,
 } from "./saved-searches";
 import { fetchDeepDive, buildDeepDiveText } from "./deepdive";
-import { fetchTopics } from "./explore";
 import { loadConfig } from "./config";
 
 export type Overlay =
@@ -131,8 +130,6 @@ export class SearchStateManager {
         timestamp: Date.now(),
         resultCount: response.repos.length,
       });
-    } catch (err) {
-      throw err;
     } finally {
       this.state.isLoading = false;
     }