@promptai.credit/cli 0.4.0 → 0.4.2

package/claude-plugin/hooks/logo.ts

@@ -0,0 +1,167 @@
+/**
+ * Brand logo → terminal cells for the AbovePrompt card.
+ *
+ * Works in any terminal (Apple Terminal included): the logo becomes a
+ * `Raster` of half-block glyphs, two pixels per cell. Everything here fails
+ * open — a missing converter, a slow CDN or an odd format just means the card
+ * draws without a logo.
+ *
+ * Pure image code only: the host pipeline (curl → svg→png → bmp) lives in
+ * ads.tsx, because every `$.noun.method()` call has to sit in the hooks module.
+ */
+export interface LogoCells {
+  columns: number;
+  rows: number;
+  /** Raster `cells`: base64 of little-endian u32 [codePoint, fg, bg] triplets. */
+  cells: string;
+}
+
+/** Working size handed to the converters; downscaled to the cell grid here. */
+export const WORK_PX = 64;
+const DEFAULT_COLOR = 0x01000000;
+const B64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+export function encodeBase64(bytes: Uint8Array): string {
+  let out = "";
+  for (let i = 0; i < bytes.length; i += 3) {
+    const a = bytes[i];
+    const b = i + 1 < bytes.length ? bytes[i + 1] : 0;
+    const c = i + 2 < bytes.length ? bytes[i + 2] : 0;
+    out += B64[a >> 2] + B64[((a & 3) << 4) | (b >> 4)];
+    out += i + 1 < bytes.length ? B64[((b & 15) << 2) | (c >> 6)] : "=";
+    out += i + 2 < bytes.length ? B64[c & 63] : "=";
+  }
+  return out;
+}
+
+export function decodeBase64(text: string): Uint8Array {
+  const bin = atob(text);
+  const out = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
+  return out;
+}
+
+export interface Bitmap {
+  width: number;
+  height: number;
+  /** RGBA, row-major, top-down. */
+  rgba: Uint8Array;
+}
+
+/** Uncompressed 24/32-bit BMP (what sips and ImageMagick's BMP3 write). */
+export function parseBmp(bytes: Uint8Array): Bitmap | null {
+  if (bytes.length < 54 || bytes[0] !== 0x42 || bytes[1] !== 0x4d) return null;
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const dataOffset = view.getUint32(10, true);
+  const width = view.getInt32(18, true);
+  const rawHeight = view.getInt32(22, true);
+  const bpp = view.getUint16(28, true);
+  const compression = view.getUint32(30, true);
+  const height = Math.abs(rawHeight);
+  const topDown = rawHeight < 0;
+  if (width <= 0 || height <= 0 || width > 4096 || height > 4096) return null;
+  if ((bpp !== 24 && bpp !== 32) || (compression !== 0 && compression !== 3)) return null;
+
+  const bytesPerPx = bpp / 8;
+  const stride = ((width * bpp + 31) >> 5) << 2;
+  if (dataOffset + stride * height > bytes.length) return null;
+
+  const rgba = new Uint8Array(width * height * 4);
+  let anyAlpha = false;
+  for (let y = 0; y < height; y++) {
+    const srcRow = dataOffset + (topDown ? y : height - 1 - y) * stride;
+    for (let x = 0; x < width; x++) {
+      const s = srcRow + x * bytesPerPx;
+      const d = (y * width + x) * 4;
+      rgba[d] = bytes[s + 2];
+      rgba[d + 1] = bytes[s + 1];
+      rgba[d + 2] = bytes[s];
+      const a = bpp === 32 ? bytes[s + 3] : 255;
+      rgba[d + 3] = a;
+      if (a !== 0) anyAlpha = true;
+    }
+  }
+  // A 32-bit BMP whose alpha byte is all zero is XRGB padding, not "invisible".
+  if (!anyAlpha) for (let i = 3; i < rgba.length; i += 4) rgba[i] = 255;
+  return { width, height, rgba };
+}
+
+/**
+ * Fit `bmp` into columns × (rows*2) pixels (aspect kept, centred, area
+ * averaged) and pack half-block cells. Transparent pixels stay the terminal's
+ * own background, so the logo sits on the card, not on a colored square.
+ */
+export function bitmapToCells(bmp: Bitmap, columns: number, rows: number): LogoCells {
+  const W = columns;
+  const H = rows * 2;
+  const scale = Math.min(W / bmp.width, H / bmp.height);
+  const fitW = Math.max(1, Math.round(bmp.width * scale));
+  const fitH = Math.max(1, Math.round(bmp.height * scale));
+  const offX = Math.floor((W - fitW) / 2);
+  const offY = Math.floor((H - fitH) / 2);
+
+  // One RGB (or null for transparent) per target pixel.
+  const px: Array<number | null> = new Array(W * H).fill(null);
+  for (let ty = 0; ty < fitH; ty++) {
+    const y0 = Math.floor((ty * bmp.height) / fitH);
+    const y1 = Math.max(y0 + 1, Math.floor(((ty + 1) * bmp.height) / fitH));
+    for (let tx = 0; tx < fitW; tx++) {
+      const x0 = Math.floor((tx * bmp.width) / fitW);
+      const x1 = Math.max(x0 + 1, Math.floor(((tx + 1) * bmp.width) / fitW));
+      let r = 0;
+      let g = 0;
+      let b = 0;
+      let a = 0;
+      let n = 0;
+      for (let y = y0; y < y1; y++) {
+        for (let x = x0; x < x1; x++) {
+          const i = (y * bmp.width + x) * 4;
+          const alpha = bmp.rgba[i + 3];
+          r += bmp.rgba[i] * alpha;
+          g += bmp.rgba[i + 1] * alpha;
+          b += bmp.rgba[i + 2] * alpha;
+          a += alpha;
+          n++;
+        }
+      }
+      if (a / n < 90) continue; // mostly transparent
+      const R = Math.round(r / a);
+      const G = Math.round(g / a);
+      const B = Math.round(b / a);
+      px[(offY + ty) * W + (offX + tx)] = (R << 16) | (G << 8) | B;
+    }
+  }
+
+  const words = new Uint32Array(columns * rows * 3);
+  for (let row = 0; row < rows; row++) {
+    for (let col = 0; col < columns; col++) {
+      const top = px[row * 2 * W + col];
+      const bottom = px[(row * 2 + 1) * W + col];
+      let glyph = 0x20;
+      let fg = DEFAULT_COLOR;
+      let bg = DEFAULT_COLOR;
+      if (top !== null && bottom !== null) {
+        glyph = 0x2580; // ▀
+        fg = top;
+        bg = bottom;
+      } else if (top !== null) {
+        glyph = 0x2580;
+        fg = top;
+      } else if (bottom !== null) {
+        glyph = 0x2584; // ▄
+        fg = bottom;
+      }
+      const at = (row * columns + col) * 3;
+      words[at] = glyph;
+      words[at + 1] = fg;
+      words[at + 2] = bg;
+    }
+  }
+  return { columns, rows, cells: encodeBase64(new Uint8Array(words.buffer)) };
+}
+
+export function hashKey(text: string): string {
+  let h = 5381;
+  for (let i = 0; i < text.length; i++) h = ((h * 33) ^ text.charCodeAt(i)) >>> 0;
+  return h.toString(36);
+}