ai-cli 0.0.12 → 0.1.0

package/src/lib/parse.test.ts

@@ -0,0 +1,114 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  parsePositiveInt,
+  parseNonNegativeFloat,
+  parseSize,
+  parseAspectRatio,
+  parseTemperature,
+} from "./parse.js";
+
+describe("parsePositiveInt", () => {
+  test("parses valid positive integers", () => {
+    expect(parsePositiveInt("1", "count")).toBe(1);
+    expect(parsePositiveInt("42", "count")).toBe(42);
+    expect(parsePositiveInt("1000", "count")).toBe(1000);
+  });
+
+  test("throws on zero", () => {
+    expect(() => parsePositiveInt("0", "count")).toThrow("positive integer");
+  });
+
+  test("throws on negative", () => {
+    expect(() => parsePositiveInt("-1", "count")).toThrow("positive integer");
+  });
+
+  test("throws on non-numeric", () => {
+    expect(() => parsePositiveInt("abc", "count")).toThrow("positive integer");
+  });
+
+  test("rejects float string", () => {
+    expect(() => parsePositiveInt("1.5", "count")).toThrow("positive integer");
+  });
+
+  test("rejects string with trailing non-digits", () => {
+    expect(() => parsePositiveInt("10px", "count")).toThrow("positive integer");
+  });
+
+  test("includes flag name in error", () => {
+    expect(() => parsePositiveInt("bad", "max-tokens")).toThrow("--max-tokens");
+  });
+});
+
+describe("parseNonNegativeFloat", () => {
+  test("parses valid non-negative floats", () => {
+    expect(parseNonNegativeFloat("0", "temperature")).toBe(0);
+    expect(parseNonNegativeFloat("1.5", "temperature")).toBe(1.5);
+    expect(parseNonNegativeFloat("2", "temperature")).toBe(2);
+  });
+
+  test("throws on negative", () => {
+    expect(() => parseNonNegativeFloat("-0.1", "temperature")).toThrow(
+      "non-negative"
+    );
+  });
+
+  test("throws on non-numeric", () => {
+    expect(() => parseNonNegativeFloat("abc", "temperature")).toThrow(
+      "non-negative"
+    );
+  });
+
+  test("includes flag name in error", () => {
+    expect(() => parseNonNegativeFloat("bad", "temperature")).toThrow(
+      "--temperature"
+    );
+  });
+});
+
+describe("parseSize", () => {
+  test("parses valid sizes", () => {
+    expect(parseSize("1024x1024")).toBe("1024x1024");
+    expect(parseSize("512x768")).toBe("512x768");
+  });
+
+  test("rejects invalid formats", () => {
+    expect(() => parseSize("abc")).toThrow("WxH format");
+    expect(() => parseSize("1024")).toThrow("WxH format");
+    expect(() => parseSize("1024x")).toThrow("WxH format");
+    expect(() => parseSize("16:9")).toThrow("WxH format");
+  });
+});
+
+describe("parseAspectRatio", () => {
+  test("parses valid ratios", () => {
+    expect(parseAspectRatio("16:9")).toBe("16:9");
+    expect(parseAspectRatio("1:1")).toBe("1:1");
+    expect(parseAspectRatio("4:3")).toBe("4:3");
+  });
+
+  test("rejects invalid formats", () => {
+    expect(() => parseAspectRatio("abc")).toThrow("W:H format");
+    expect(() => parseAspectRatio("16")).toThrow("W:H format");
+    expect(() => parseAspectRatio("16x9")).toThrow("W:H format");
+    expect(() => parseAspectRatio("16:")).toThrow("W:H format");
+  });
+});
+
+describe("parseTemperature", () => {
+  test("parses valid temperatures", () => {
+    expect(parseTemperature("0")).toBe(0);
+    expect(parseTemperature("1")).toBe(1);
+    expect(parseTemperature("1.5")).toBe(1.5);
+    expect(parseTemperature("2")).toBe(2);
+  });
+
+  test("rejects out of range", () => {
+    expect(() => parseTemperature("-0.1")).toThrow("between 0 and 2");
+    expect(() => parseTemperature("2.1")).toThrow("between 0 and 2");
+  });
+
+  test("rejects non-numeric", () => {
+    expect(() => parseTemperature("abc")).toThrow("between 0 and 2");
+  });
+});

package/src/lib/parse.ts

@@ -0,0 +1,44 @@
+export function parsePositiveInt(value: string, name: string): number {
+  if (!/^\d+$/.test(value)) {
+    throw new Error(`--${name} must be a positive integer, got "${value}"`);
+  }
+  const n = parseInt(value, 10);
+  if (n <= 0) {
+    throw new Error(`--${name} must be a positive integer, got "${value}"`);
+  }
+  return n;
+}
+
+export function parseNonNegativeFloat(value: string, name: string): number {
+  const n = parseFloat(value);
+  if (isNaN(n) || n < 0) {
+    throw new Error(`--${name} must be a non-negative number, got "${value}"`);
+  }
+  return n;
+}
+
+export function parseSize(value: string): `${number}x${number}` {
+  if (!/^\d+x\d+$/.test(value)) {
+    throw new Error(
+      `--size must be in WxH format (e.g. 1024x1024), got "${value}"`
+    );
+  }
+  return value as `${number}x${number}`;
+}
+
+export function parseAspectRatio(value: string): `${number}:${number}` {
+  if (!/^\d+:\d+$/.test(value)) {
+    throw new Error(
+      `--aspect-ratio must be in W:H format (e.g. 16:9), got "${value}"`
+    );
+  }
+  return value as `${number}:${number}`;
+}
+
+export function parseTemperature(value: string): number {
+  const n = parseFloat(value);
+  if (isNaN(n) || n < 0 || n > 2) {
+    throw new Error(`--temperature must be between 0 and 2, got "${value}"`);
+  }
+  return n;
+}

package/src/lib/png.test.ts

@@ -0,0 +1,104 @@
+import { describe, test, expect } from "bun:test";
+
+import { encodePNG } from "./png.js";
+
+describe("encodePNG", () => {
+  test("produces valid PNG signature", () => {
+    const width = 2;
+    const height = 2;
+    const yuvSize = width * height + 2 * (width >> 1) * (height >> 1);
+    const yuv = new Uint8Array(yuvSize);
+    yuv.fill(128);
+
+    const png = encodePNG(yuv, width, height);
+
+    // PNG signature: 0x89 P N G \r \n 0x1a \n
+    expect(png[0]).toBe(137);
+    expect(png[1]).toBe(80); // P
+    expect(png[2]).toBe(78); // N
+    expect(png[3]).toBe(71); // G
+    expect(png[4]).toBe(13);
+    expect(png[5]).toBe(10);
+    expect(png[6]).toBe(26);
+    expect(png[7]).toBe(10);
+  });
+
+  test("IHDR chunk has correct dimensions", () => {
+    const width = 4;
+    const height = 2;
+    const yuvSize = width * height + 2 * (width >> 1) * (height >> 1);
+    const yuv = new Uint8Array(yuvSize);
+    yuv.fill(128);
+
+    const png = encodePNG(yuv, width, height);
+
+    // IHDR starts at offset 8 (after signature)
+    // 4 bytes length + 4 bytes "IHDR" + 13 bytes data + 4 bytes CRC
+    const view = new DataView(png.buffer, png.byteOffset, png.byteLength);
+    const ihdrLen = view.getUint32(8);
+    expect(ihdrLen).toBe(13);
+
+    // "IHDR"
+    expect(String.fromCharCode(png[12], png[13], png[14], png[15])).toBe(
+      "IHDR"
+    );
+
+    // Width and height
+    const w = view.getUint32(16);
+    const h = view.getUint32(20);
+    expect(w).toBe(4);
+    expect(h).toBe(2);
+
+    // Bit depth
+    expect(png[24]).toBe(8);
+    // Color type (RGB)
+    expect(png[25]).toBe(2);
+  });
+
+  test("output contains IEND chunk", () => {
+    const width = 2;
+    const height = 2;
+    const yuvSize = width * height + 2 * (width >> 1) * (height >> 1);
+    const yuv = new Uint8Array(yuvSize);
+    yuv.fill(128);
+
+    const png = encodePNG(yuv, width, height);
+
+    // IEND should be the last chunk: 0-length + "IEND" + CRC = 12 bytes at the end
+    const iendType = String.fromCharCode(
+      png[png.length - 8],
+      png[png.length - 7],
+      png[png.length - 6],
+      png[png.length - 5]
+    );
+    expect(iendType).toBe("IEND");
+  });
+
+  test("converts gray YUV to gray RGB", () => {
+    // Y=128, Cb=128 (neutral), Cr=128 (neutral) should produce mid-gray (~128)
+    const width = 2;
+    const height = 2;
+    const yuv = new Uint8Array(width * height + 2);
+    yuv[0] = 128;
+    yuv[1] = 128;
+    yuv[2] = 128;
+    yuv[3] = 128; // Y
+    yuv[4] = 128; // Cb
+    yuv[5] = 128; // Cr
+
+    const png = encodePNG(yuv, width, height);
+    expect(png.length).toBeGreaterThan(8);
+    // Valid PNG (we trust the encoder at this level)
+  });
+
+  test("handles 1x1 image", () => {
+    const yuv = new Uint8Array(3);
+    yuv[0] = 200; // Y
+    yuv[1] = 128; // Cb
+    yuv[2] = 128; // Cr
+
+    const png = encodePNG(yuv, 1, 1);
+    expect(png[0]).toBe(137); // PNG signature
+    expect(png.length).toBeGreaterThan(20);
+  });
+});

package/src/lib/png.ts

@@ -0,0 +1,90 @@
+import { deflateSync } from "zlib";
+
+export function encodePNG(
+  yuv: Uint8Array,
+  width: number,
+  height: number
+): Buffer {
+  const chromaW = width >> 1;
+
+  const lumaOffset = 0;
+  const cbOffset = width * height;
+  const crOffset = cbOffset + chromaW * (height >> 1);
+
+  // YUV420 -> RGB, with PNG filter byte per row
+  const rowSize = width * 3 + 1;
+  const raw = Buffer.alloc(rowSize * height);
+
+  for (let y = 0; y < height; y++) {
+    raw[y * rowSize] = 0; // filter: None
+    for (let x = 0; x < width; x++) {
+      const yVal = yuv[lumaOffset + y * width + x];
+      const cb = yuv[cbOffset + (y >> 1) * chromaW + (x >> 1)] - 128;
+      const cr = yuv[crOffset + (y >> 1) * chromaW + (x >> 1)] - 128;
+
+      const r = yVal + 1.402 * cr;
+      const g = yVal - 0.344136 * cb - 0.714136 * cr;
+      const b = yVal + 1.772 * cb;
+
+      const off = y * rowSize + 1 + x * 3;
+      raw[off] = clamp(r);
+      raw[off + 1] = clamp(g);
+      raw[off + 2] = clamp(b);
+    }
+  }
+
+  const compressed = deflateSync(raw);
+
+  // Build PNG file
+  const signature = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+
+  const ihdr = Buffer.alloc(13);
+  ihdr.writeUInt32BE(width, 0);
+  ihdr.writeUInt32BE(height, 4);
+  ihdr[8] = 8; // bit depth
+  ihdr[9] = 2; // color type: RGB
+  ihdr[10] = 0; // compression
+  ihdr[11] = 0; // filter
+  ihdr[12] = 0; // interlace
+
+  const ihdrChunk = makeChunk("IHDR", ihdr);
+  const idatChunk = makeChunk("IDAT", compressed);
+  const iendChunk = makeChunk("IEND", Buffer.alloc(0));
+
+  return Buffer.concat([signature, ihdrChunk, idatChunk, iendChunk]);
+}
+
+function makeChunk(type: string, data: Buffer): Buffer {
+  const typeBytes = Buffer.from(type, "ascii");
+  const len = Buffer.alloc(4);
+  len.writeUInt32BE(data.length, 0);
+
+  const crcInput = Buffer.concat([typeBytes, data]);
+  const crc = Buffer.alloc(4);
+  crc.writeUInt32BE(crc32(crcInput), 0);
+
+  return Buffer.concat([len, typeBytes, data, crc]);
+}
+
+const CRC_TABLE = new Uint32Array(256);
+{
+  for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++) {
+      c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+    }
+    CRC_TABLE[n] = c;
+  }
+}
+
+function crc32(buf: Buffer): number {
+  let crc = 0xffffffff;
+  for (let i = 0; i < buf.length; i++) {
+    crc = CRC_TABLE[(crc ^ buf[i]) & 0xff] ^ (crc >>> 8);
+  }
+  return (crc ^ 0xffffffff) >>> 0;
+}
+
+function clamp(v: number): number {
+  return v < 0 ? 0 : v > 255 ? 255 : Math.round(v);
+}

package/src/lib/progress.ts

@@ -0,0 +1,214 @@
+import { isColorEnabled } from "./color.js";
+import { nextShimmerPos, SHIMMER_PADDING, shimmerText } from "./shimmer.js";
+
+let cleanupFn: (() => void) | null = null;
+let signalHandlersRegistered = false;
+
+function onSignal() {
+  if (cleanupFn) cleanupFn();
+  process.stderr.write("\x1b[0m\x1b[?25h");
+  process.exit(130);
+}
+
+function ensureSignalHandlers() {
+  if (signalHandlersRegistered) return;
+  signalHandlersRegistered = true;
+  process.on("SIGINT", onSignal);
+  process.on("SIGTERM", onSignal);
+}
+
+export function formatElapsed(ms: number): string {
+  const secs = Math.floor(ms / 1000);
+  if (secs < 60) return `${secs}s`;
+  const mins = Math.floor(secs / 60);
+  const remainSecs = secs % 60;
+  return `${mins}m ${remainSecs}s`;
+}
+
+function isTTY(): boolean {
+  return !!process.stderr.isTTY;
+}
+
+function getColumns(): number {
+  return (
+    (process.stderr as typeof process.stderr & { columns?: number }).columns ??
+    80
+  );
+}
+
+export class Progress {
+  private interval: ReturnType<typeof setInterval> | null = null;
+  private pos = -SHIMMER_PADDING;
+  private text = "";
+  private startTime = 0;
+  private quiet: boolean;
+
+  constructor(quiet = false) {
+    this.quiet = quiet;
+  }
+
+  start(message: string) {
+    if (this.quiet) return;
+    ensureSignalHandlers();
+    this.startTime = Date.now();
+    this.text = message;
+    this.pos = -SHIMMER_PADDING;
+    if (isTTY()) {
+      cleanupFn = () => {
+        process.stderr.write("\r\x1b[K");
+      };
+      this.render();
+      this.interval = setInterval(() => this.render(), 50);
+    }
+  }
+
+  stop(message?: string) {
+    if (this.quiet) return;
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+    }
+    cleanupFn = null;
+    if (isTTY()) {
+      process.stderr.write("\r\x1b[K");
+    }
+    if (message) {
+      const elapsed = formatElapsed(Date.now() - this.startTime);
+      process.stderr.write(`${message} (${elapsed})\n`);
+    }
+  }
+
+  private render() {
+    const elapsed = formatElapsed(Date.now() - this.startTime);
+    const columns = getColumns();
+    const suffix = ` (${elapsed})`;
+    const maxWidth = columns - 1 - suffix.length;
+    const display =
+      this.text.length > maxWidth ? this.text.slice(-maxWidth) : this.text;
+    const fullText = `${display}${suffix}`;
+
+    if (isColorEnabled()) {
+      process.stderr.write(`\r${shimmerText(fullText, this.pos)}\x1b[K`);
+    } else {
+      process.stderr.write(`\r${fullText}\x1b[K`);
+    }
+
+    this.pos = nextShimmerPos(this.pos, fullText.length);
+  }
+}
+
+type LineState = "queued" | "active" | "done";
+
+interface MultiLine {
+  text: string;
+  state: LineState;
+  startTime: number;
+  pos: number;
+  finalText: string;
+}
+
+export class MultiProgress {
+  private lines: MultiLine[] = [];
+  private interval: ReturnType<typeof setInterval> | null = null;
+  private quiet: boolean;
+  private renderedCount = 0;
+
+  constructor(quiet = false) {
+    this.quiet = quiet;
+  }
+
+  addLine(text: string): number {
+    ensureSignalHandlers();
+    const idx = this.lines.length;
+    this.lines.push({
+      text,
+      state: "queued",
+      startTime: 0,
+      pos: -SHIMMER_PADDING,
+      finalText: "",
+    });
+    if (!this.quiet && isTTY() && !this.interval) {
+      cleanupFn = () => this.eraseLines();
+      this.interval = setInterval(() => this.render(), 50);
+    }
+    if (isTTY()) this.render();
+    return idx;
+  }
+
+  startLine(idx: number) {
+    if (idx < 0 || idx >= this.lines.length) return;
+    const line = this.lines[idx];
+    if (line.state !== "queued") return;
+    line.state = "active";
+    line.startTime = Date.now();
+    line.pos = -SHIMMER_PADDING;
+    if (isTTY()) this.render();
+  }
+
+  completeLine(idx: number, finalText: string) {
+    if (idx < 0 || idx >= this.lines.length) return;
+    const line = this.lines[idx];
+    line.state = "done";
+    line.finalText = finalText;
+
+    if (this.lines.every((l) => l.state === "done")) {
+      this.stopAll();
+    } else if (isTTY()) {
+      this.render();
+    }
+  }
+
+  private stopAll() {
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+    }
+    cleanupFn = null;
+    if (isTTY()) this.eraseLines();
+    if (!this.quiet) {
+      for (const line of this.lines) {
+        process.stderr.write(`${line.finalText}\n`);
+      }
+    }
+    this.renderedCount = 0;
+  }
+
+  private render() {
+    if (this.quiet) return;
+    this.eraseLines();
+
+    const columns = getColumns();
+    const dim = isColorEnabled() ? "\x1b[2m\x1b[90m" : "";
+    const reset = isColorEnabled() ? "\x1b[0m" : "";
+
+    for (const line of this.lines) {
+      if (line.state === "done") {
+        process.stderr.write(`${line.finalText}\x1b[K\n`);
+      } else if (line.state === "queued") {
+        process.stderr.write(`${dim}${line.text} (queued)${reset}\x1b[K\n`);
+      } else {
+        const elapsed = formatElapsed(Date.now() - line.startTime);
+        const suffix = ` (${elapsed})`;
+        const maxWidth = columns - 1 - suffix.length;
+        const display =
+          line.text.length > maxWidth ? line.text.slice(-maxWidth) : line.text;
+        const fullText = `${display}${suffix}`;
+
+        if (isColorEnabled()) {
+          process.stderr.write(`${shimmerText(fullText, line.pos)}\x1b[K\n`);
+        } else {
+          process.stderr.write(`${fullText}\x1b[K\n`);
+        }
+
+        line.pos = nextShimmerPos(line.pos, fullText.length);
+      }
+    }
+
+    this.renderedCount = this.lines.length;
+  }
+
+  private eraseLines() {
+    if (this.renderedCount === 0) return;
+    process.stderr.write(`\x1b[${this.renderedCount}A\r`);
+  }
+}

package/src/lib/shimmer.test.ts

@@ -0,0 +1,39 @@
+import { describe, expect, test } from "bun:test";
+
+import { shimmerText, nextShimmerPos, SHIMMER_PADDING } from "./shimmer.js";
+
+describe("shimmerText", () => {
+  test("returns empty string unchanged", () => {
+    expect(shimmerText("", 0)).toBe("");
+  });
+
+  test("returns plain text when NO_COLOR is set", () => {
+    const prev = process.env.NO_COLOR;
+    process.env.NO_COLOR = "1";
+    try {
+      expect(shimmerText("hello", 2)).toBe("hello");
+    } finally {
+      if (prev === undefined) delete process.env.NO_COLOR;
+      else process.env.NO_COLOR = prev;
+    }
+  });
+});
+
+describe("nextShimmerPos", () => {
+  test("increments position by 1", () => {
+    expect(nextShimmerPos(0, 20)).toBe(1);
+    expect(nextShimmerPos(5, 20)).toBe(6);
+  });
+
+  test("wraps around after passing text length + padding + gap", () => {
+    const textLen = 10;
+    const wrapPoint = textLen + SHIMMER_PADDING + 6;
+    expect(nextShimmerPos(wrapPoint, textLen)).toBe(-SHIMMER_PADDING);
+  });
+
+  test("does not wrap before threshold", () => {
+    const textLen = 10;
+    const beforeWrap = textLen + SHIMMER_PADDING + 5;
+    expect(nextShimmerPos(beforeWrap, textLen)).toBe(beforeWrap + 1);
+  });
+});

package/src/lib/shimmer.ts

@@ -0,0 +1,42 @@
+import { isColorEnabled } from "./color.js";
+
+const SHIMMER_RADIUS = 8;
+const BASE = 243;
+const PEAK = 255;
+const GAP_FRAMES = 6;
+
+function charShade(charIdx: number, shimmerPos: number): number {
+  const d = Math.abs(charIdx - shimmerPos);
+  if (d >= SHIMMER_RADIUS) return BASE;
+  const t = (1 + Math.cos((d / SHIMMER_RADIUS) * Math.PI)) / 2;
+  return Math.round(BASE + (PEAK - BASE) * t);
+}
+
+export function shimmerText(text: string, pos: number): string {
+  if (!isColorEnabled() || text.length === 0) return text;
+
+  let result = "";
+  let prevShade = -1;
+
+  for (let i = 0; i < text.length; i++) {
+    const shade = charShade(i, pos);
+    if (shade !== prevShade) {
+      result += `\x1b[38;5;${shade}m`;
+      prevShade = shade;
+    }
+    result += text[i];
+  }
+
+  result += "\x1b[0m";
+  return result;
+}
+
+export const SHIMMER_PADDING = SHIMMER_RADIUS;
+
+export function nextShimmerPos(pos: number, textLength: number): number {
+  const next = pos + 1;
+  if (next > textLength + SHIMMER_PADDING + GAP_FRAMES) {
+    return -SHIMMER_PADDING;
+  }
+  return next;
+}

package/src/lib/stdin.ts

@@ -0,0 +1,31 @@
+export async function readStdin(): Promise<Buffer | null> {
+  if (process.stdin.isTTY) return null;
+
+  const first = await Promise.race([
+    new Promise<Buffer | null>((resolve) => {
+      process.stdin.once("data", (chunk) => resolve(Buffer.from(chunk)));
+      process.stdin.once("end", () => resolve(null));
+      process.stdin.once("error", () => resolve(null));
+    }),
+    new Promise<"timeout">((resolve) =>
+      setTimeout(() => resolve("timeout"), 1000)
+    ),
+  ]);
+
+  if (first === "timeout" || first === null) {
+    process.stdin.destroy();
+    return null;
+  }
+
+  const chunks: Buffer[] = [first];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.from(chunk));
+  }
+
+  const buf = Buffer.concat(chunks);
+  return buf.length > 0 ? buf : null;
+}
+
+export function stdinAsText(buf: Buffer): string {
+  return buf.toString("utf-8");
+}