github-search-cli 9.7.1 → 9.8.1

package/src/markdown-view.ts

@@ -0,0 +1,316 @@
+/**
+ * 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;
+
+/** Cap on memoised rasters — a resize session re-keys on width, so this
+ *  would otherwise grow without bound. */
+const RASTER_CACHE_LIMIT = 32;
+
+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);
+    // Map iteration order is insertion order, so the first key is the oldest.
+    // Unbounded growth would re-rasterize every image on every resize.
+    while (rasterCache.size > RASTER_CACHE_LIMIT) {
+      const oldest = rasterCache.keys().next().value;
+      if (oldest === undefined) break;
+      rasterCache.delete(oldest);
+    }
+    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) => {
+        // 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) => {
+        // Swallow: a failed image should not crash the view.
+        void 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;
+      // Finalize streaming so the last tokens are no longer marked unstable.
+      // Without this, OpenTUI keeps the trailing 2 blocks perpetually
+      // unstable in streaming mode, which recreates image render nodes (and
+      // their pending fetch promises) on every render cycle — the promise
+      // resolves after the loop idles and never settles.
+      renderable.streaming = false;
+      renderable.requestRender();
+    },
+    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

@@ -17,6 +17,7 @@
  *   ghfind_deep_dive            deepdive.ts
  *   ghfind_bookmarked_releases  releases.ts + bookmarks.ts (read-only)
  *   ghfind_skill                agent-skill.ts
+ *   ghfind_skill_search         skill-finder.ts (local scan | skills.sh HTTP)
  *
  * Only the tools capability is declared (no prompts/resources yet), so those
  * methods fall through to "Method not found".
@@ -47,6 +48,12 @@ import { getBookmarks } from "./bookmarks";
 import { appendHistory } from "./history";
 import { loadConfig } from "./config";
 import { ensureBuiltinSkill, getSkill } from "./agent-skill";
+import {
+  formatSkillSearchText,
+  searchSkills,
+  type SkillSearchResult,
+  type SkillSource,
+} from "./skill-finder";
 import { getVersion } from "./version";
 
 // ─── Protocol constants ────────────────────────────────────────────────
@@ -212,6 +219,8 @@ const TRENDING_QUERY = { keywords: [], qualifiers: [], raw: "trending" };
 // ─── Tool registry ─────────────────────────────────────────────────────
 
 const REPO_SORTS = ["best-match", "stars", "updated", "forks"] as const;
+/** Skill search sources: this machine, or the public skills.sh ecosystem. */
+const SKILL_SOURCES = ["local", "registry"] as const;
 const TRENDING_SINCE = ["daily", "weekly", "monthly"] as const;
 const PKG_SORTS = ["best-match", "score", "downloads", "name"] as const;
 
@@ -599,6 +608,56 @@ const TOOLS: ToolDefinition[] = [
       };
     },
   },
+  {
+    name: "ghfind_skill_search",
+    title: "Search agent skills",
+    description:
+      "Search installed agent skills (SKILL.md files under the user's skill directories) or the public skills.sh ecosystem by keyword, and return matching skills with their descriptions. Read-only: it never installs anything - registry hits include the `npx skills add` command for the user to run deliberately. Use when the user asks to find a skill for a task, or asks what skills are available.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description:
+            'Keyword to match against skill names and descriptions, e.g. "changelog" or "testing" (2+ characters).',
+        },
+        source: {
+          type: "string",
+          description:
+            "Where to search: 'local' for skills installed on this machine (default), 'registry' for the public skills.sh ecosystem.",
+          enum: [...SKILL_SOURCES],
+        },
+        limit: {
+          type: "number",
+          description: "Max results, 1-100 (default 20).",
+          minimum: 1,
+          maximum: 100,
+        },
+      },
+      required: ["query"],
+    },
+    async run(args) {
+      const source = coerceEnum<SkillSource>(
+        args.source,
+        SKILL_SOURCES,
+        "local",
+      );
+      const limit = coerceInt(args.limit, 20, 1, 100);
+      const result: SkillSearchResult = await searchSkills(
+        String(args.query ?? ""),
+        { source, limit },
+      );
+      const where =
+        result.source === "local"
+          ? "installed skills on this machine"
+          : "the public skills.sh ecosystem";
+      const header = `${result.count} match(es) for "${result.query}" in ${where}:`;
+      return {
+        text: `${header}\n\n${formatSkillSearchText(result)}`,
+        data: { ...result },
+      };
+    },
+  },
 ];
 
 /** Tools/list payload (name, title, description, inputSchema only). */
@@ -737,6 +796,7 @@ export async function processServerLine(
           },
           instructions:
             "ghfind gives agents GitHub search: repositories, trending, npm packages, org/user profiles, repo comparison and deep-dives. " +
+            "ghfind_skill_search finds agent skills, either installed on this machine or in the public skills.sh ecosystem. " +
             "Call ghfind_skill for the full CLI guide. Unauthenticated requests are rate-limited to 60/hr; pass a token or set GITHUB_TOKEN for 5,000/hr.",
         }),
       );

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;
+}