ai-cli 0.2.0 → 0.2.1

package/src/lib/models.test.ts

@@ -1,307 +0,0 @@
-import { afterEach, describe, expect, mock, test } from "bun:test";
-
-import {
-  resolveModels,
-  fetchGatewayModels,
-  resetGatewayCache,
-} from "./models.js";
-
-const originalFetch = globalThis.fetch;
-
-afterEach(() => {
-  globalThis.fetch = originalFetch;
-  resetGatewayCache();
-});
-
-function mockGateway(models: Record<string, unknown>[]) {
-  globalThis.fetch = mock(() =>
-    Promise.resolve(
-      new Response(JSON.stringify({ data: models }), { status: 200 })
-    )
-  ) as unknown as typeof fetch;
-}
-
-function mockGatewayError() {
-  globalThis.fetch = mock(() =>
-    Promise.reject(new Error("network error"))
-  ) as unknown as typeof fetch;
-}
-
-describe("resolveModels", () => {
-  test("returns default when no user model", () => {
-    expect(resolveModels("text")[0]).toContain("/");
-    expect(resolveModels("image")[0]).toContain("/");
-    expect(resolveModels("video")[0]).toContain("/");
-  });
-
-  test("returns fully-qualified model as-is", () => {
-    expect(resolveModels("text", "openai/gpt-4")).toEqual(["openai/gpt-4"]);
-    expect(resolveModels("image", "openai/gpt-image-1")).toEqual([
-      "openai/gpt-image-1",
-    ]);
-  });
-
-  test("expands short names when knownModels provided", () => {
-    const known = [{ id: "openai/gpt-image-1" }, { id: "bfl/flux-2-pro" }];
-    expect(resolveModels("image", "gpt-image-1", known)).toEqual([
-      "openai/gpt-image-1",
-    ]);
-    expect(resolveModels("image", "flux-2-pro", known)).toEqual([
-      "bfl/flux-2-pro",
-    ]);
-  });
-
-  test("returns unknown short names as-is when no knownModels", () => {
-    expect(resolveModels("text", "my-model")).toEqual(["my-model"]);
-  });
-
-  test("returns unknown short names as-is when not in knownModels", () => {
-    const known = [{ id: "openai/gpt-5" }];
-    expect(resolveModels("text", "nonexistent", known)).toEqual([
-      "nonexistent",
-    ]);
-  });
-});
-
-describe("resolveModels multi", () => {
-  test("returns default when no user model", () => {
-    const result = resolveModels("text");
-    expect(result).toHaveLength(1);
-    expect(result[0]).toContain("/");
-  });
-
-  test("splits comma-separated models", () => {
-    const result = resolveModels("image", "openai/gpt-image-1,bfl/flux-2-pro");
-    expect(result).toEqual(["openai/gpt-image-1", "bfl/flux-2-pro"]);
-  });
-
-  test("trims whitespace around model names", () => {
-    const result = resolveModels(
-      "image",
-      "openai/gpt-image-1 , bfl/flux-2-pro"
-    );
-    expect(result).toEqual(["openai/gpt-image-1", "bfl/flux-2-pro"]);
-  });
-
-  test("expands short names in comma list", () => {
-    const known = [{ id: "openai/gpt-image-1" }, { id: "bfl/flux-2-pro" }];
-    const result = resolveModels("image", "gpt-image-1,flux-2-pro", known);
-    expect(result).toEqual(["openai/gpt-image-1", "bfl/flux-2-pro"]);
-  });
-
-  test("filters empty segments from trailing comma", () => {
-    const result = resolveModels("image", "openai/gpt-image-1,");
-    expect(result).toEqual(["openai/gpt-image-1"]);
-  });
-
-  test("falls back to default when all segments are empty", () => {
-    const result = resolveModels("image", ",,,");
-    expect(result).toHaveLength(1);
-    expect(result[0]).toContain("/");
-  });
-});
-
-describe("fetchGatewayModels", () => {
-  test("partitions models by type with enriched fields", async () => {
-    mockGateway([
-      {
-        id: "openai/gpt-5",
-        name: "GPT 5",
-        owned_by: "openai",
-        type: "language",
-        tags: [],
-        pricing: { input: "0.000003", output: "0.000015" },
-      },
-      {
-        id: "openai/gpt-image-2",
-        name: "GPT Image 2",
-        description: "Image gen",
-        owned_by: "openai",
-        type: "image",
-        tags: ["image-generation"],
-        pricing: { image: "0.02" },
-      },
-      {
-        id: "google/veo-3.0",
-        name: "Veo 3",
-        owned_by: "google",
-        type: "video",
-        tags: [],
-      },
-      {
-        id: "openai/text-embedding-3",
-        name: "Embedding",
-        owned_by: "openai",
-        type: "embedding",
-        tags: [],
-      },
-    ]);
-
-    const result = await fetchGatewayModels();
-
-    expect(result.text).toHaveLength(1);
-    expect(result.text[0].id).toBe("openai/gpt-5");
-    expect(result.text[0].creator).toBe("openai");
-    expect(result.text[0].capabilities).toEqual(["text"]);
-    expect(result.text[0].pricing).toEqual({
-      input: "0.000003",
-      output: "0.000015",
-    });
-
-    expect(result.image).toHaveLength(1);
-    expect(result.image[0].id).toBe("openai/gpt-image-2");
-    expect(result.image[0].creator).toBe("openai");
-    expect(result.image[0].capabilities).toEqual(["image"]);
-    expect(result.image[0].description).toBe("Image gen");
-    expect(result.image[0].pricing).toEqual({ image: "0.02" });
-
-    expect(result.video).toHaveLength(1);
-    expect(result.video[0].id).toBe("google/veo-3.0");
-    expect(result.video[0].creator).toBe("google");
-    expect(result.video[0].capabilities).toEqual(["video"]);
-
-    // embedding type is excluded
-    expect(result.all).toHaveLength(3);
-  });
-
-  test("language models with image-generation tag appear in both text and image", async () => {
-    mockGateway([
-      {
-        id: "google/gemini-2.5-flash-image",
-        name: "Gemini Flash Image",
-        owned_by: "google",
-        type: "language",
-        tags: ["image-generation"],
-      },
-      {
-        id: "openai/gpt-image-2",
-        name: "GPT Image 2",
-        owned_by: "openai",
-        type: "image",
-        tags: ["image-generation"],
-      },
-    ]);
-
-    const result = await fetchGatewayModels();
-
-    expect(result.text.map((m) => m.id)).toContain(
-      "google/gemini-2.5-flash-image"
-    );
-    expect(result.image.map((m) => m.id)).toContain(
-      "google/gemini-2.5-flash-image"
-    );
-    expect(result.image.map((m) => m.id)).toContain("openai/gpt-image-2");
-
-    const gemini = result.all.find(
-      (m) => m.id === "google/gemini-2.5-flash-image"
-    )!;
-    expect(gemini.capabilities).toEqual(["text", "image"]);
-
-    expect(
-      result.languageImageModelIds.has("google/gemini-2.5-flash-image")
-    ).toBe(true);
-    expect(result.languageImageModelIds.has("openai/gpt-image-2")).toBe(false);
-  });
-
-  test("language models without image-generation tag stay in text only", async () => {
-    mockGateway([
-      {
-        id: "openai/gpt-5",
-        name: "GPT 5",
-        owned_by: "openai",
-        type: "language",
-        tags: ["tool-use"],
-      },
-    ]);
-
-    const result = await fetchGatewayModels();
-
-    expect(result.text).toHaveLength(1);
-    expect(result.image).toHaveLength(0);
-    expect(result.languageImageModelIds.size).toBe(0);
-    expect(result.all[0].capabilities).toEqual(["text"]);
-  });
-
-  test("returns empty lists on gateway error", async () => {
-    mockGatewayError();
-
-    const result = await fetchGatewayModels();
-
-    expect(result.text).toHaveLength(0);
-    expect(result.image).toHaveLength(0);
-    expect(result.video).toHaveLength(0);
-    expect(result.all).toHaveLength(0);
-    expect(result.languageImageModelIds.size).toBe(0);
-  });
-
-  test("returns empty lists on non-200 response", async () => {
-    globalThis.fetch = mock(() =>
-      Promise.resolve(new Response("Not Found", { status: 404 }))
-    ) as unknown as typeof fetch;
-
-    const result = await fetchGatewayModels();
-
-    expect(result.text).toHaveLength(0);
-    expect(result.image).toHaveLength(0);
-    expect(result.video).toHaveLength(0);
-    expect(result.all).toHaveLength(0);
-  });
-
-  test("caches result across multiple calls", async () => {
-    const fetchMock = mock(() =>
-      Promise.resolve(
-        new Response(
-          JSON.stringify({
-            data: [
-              {
-                id: "openai/gpt-5",
-                name: "GPT 5",
-                owned_by: "openai",
-                type: "language",
-                tags: [],
-              },
-            ],
-          }),
-          { status: 200 }
-        )
-      )
-    );
-    globalThis.fetch = fetchMock as unknown as typeof fetch;
-
-    const r1 = await fetchGatewayModels();
-    const r2 = await fetchGatewayModels();
-
-    expect(r1).toBe(r2);
-    expect(fetchMock).toHaveBeenCalledTimes(1);
-  });
-
-  test("pricing is omitted when all pricing fields are empty", async () => {
-    mockGateway([
-      {
-        id: "openai/gpt-5",
-        name: "GPT 5",
-        owned_by: "openai",
-        type: "language",
-        tags: [],
-        pricing: {},
-      },
-    ]);
-
-    const result = await fetchGatewayModels();
-    expect(result.text[0].pricing).toBeUndefined();
-  });
-
-  test("falls back to parsing creator from id when owned_by is absent", async () => {
-    mockGateway([
-      {
-        id: "openai/gpt-5",
-        name: "GPT 5",
-        type: "language",
-        tags: [],
-      },
-    ]);
-
-    const result = await fetchGatewayModels();
-    expect(result.text[0].creator).toBe("openai");
-  });
-});

package/src/lib/models.ts

@@ -1,173 +0,0 @@
-export type Modality = "text" | "image" | "video";
-
-const DEFAULTS: Record<Modality, string> = {
-  text: process.env.AI_CLI_TEXT_MODEL ?? "openai/gpt-5.5",
-  image: process.env.AI_CLI_IMAGE_MODEL ?? "openai/gpt-image-2",
-  video: process.env.AI_CLI_VIDEO_MODEL ?? "bytedance/seedance-2.0",
-};
-
-const GATEWAY_MODELS_URL = "https://ai-gateway.vercel.sh/v1/models";
-const GATEWAY_TIMEOUT_MS = 5_000;
-
-export interface ModelPricing {
-  input?: string;
-  output?: string;
-  image?: string;
-}
-
-export interface ModelEntry {
-  id: string;
-  name?: string;
-  description?: string;
-  creator: string;
-  capabilities: Modality[];
-  pricing?: ModelPricing;
-}
-
-export interface GatewayModels {
-  text: ModelEntry[];
-  image: ModelEntry[];
-  video: ModelEntry[];
-  all: ModelEntry[];
-  languageImageModelIds: Set<string>;
-}
-
-interface RawGatewayModel {
-  id: string;
-  name?: string;
-  description?: string;
-  owned_by?: string;
-  type?: string;
-  tags?: string[];
-  pricing?: {
-    input?: string;
-    output?: string;
-    image?: string;
-  };
-}
-
-let cached: Promise<GatewayModels> | null = null;
-
-export function fetchGatewayModels(): Promise<GatewayModels> {
-  if (!cached) {
-    cached = doFetch().catch((err) => {
-      cached = null;
-      throw err;
-    });
-  }
-  return cached;
-}
-
-export function resetGatewayCache(): void {
-  cached = null;
-}
-
-async function doFetch(): Promise<GatewayModels> {
-  const result: GatewayModels = {
-    text: [],
-    image: [],
-    video: [],
-    all: [],
-    languageImageModelIds: new Set(),
-  };
-
-  try {
-    const res = await fetch(GATEWAY_MODELS_URL, {
-      signal: AbortSignal.timeout(GATEWAY_TIMEOUT_MS),
-    });
-    if (!res.ok) throw new Error(`HTTP ${res.status}`);
-    const json = (await res.json()) as { data?: RawGatewayModel[] };
-    const models = json.data ?? [];
-
-    const entryMap = new Map<string, ModelEntry>();
-
-    for (const m of models) {
-      const tags = m.tags ?? [];
-      const isImageGen = tags.includes("image-generation");
-      const capabilities: Modality[] = [];
-
-      switch (m.type) {
-        case "language":
-          capabilities.push("text");
-          if (isImageGen) capabilities.push("image");
-          break;
-        case "image":
-          capabilities.push("image");
-          break;
-        case "video":
-          capabilities.push("video");
-          break;
-        default:
-          continue;
-      }
-
-      const creator =
-        m.owned_by ??
-        (m.id.slice(0, Math.max(0, m.id.indexOf("/"))) || "other");
-
-      const pricing: ModelPricing | undefined =
-        m.pricing?.input || m.pricing?.output || m.pricing?.image
-          ? {
-              ...(m.pricing.input ? { input: m.pricing.input } : {}),
-              ...(m.pricing.output ? { output: m.pricing.output } : {}),
-              ...(m.pricing.image ? { image: m.pricing.image } : {}),
-            }
-          : undefined;
-
-      const entry: ModelEntry = {
-        id: m.id,
-        name: m.name,
-        description: m.description,
-        creator,
-        capabilities,
-        pricing,
-      };
-
-      entryMap.set(m.id, entry);
-
-      if (capabilities.includes("text")) result.text.push(entry);
-      if (capabilities.includes("image")) result.image.push(entry);
-      if (capabilities.includes("video")) result.video.push(entry);
-
-      if (m.type === "language" && isImageGen) {
-        result.languageImageModelIds.add(m.id);
-      }
-    }
-
-    result.all = [...entryMap.values()];
-  } catch {
-    cached = null;
-    process.stderr.write("Warning: could not fetch models from AI Gateway\n");
-  }
-
-  return result;
-}
-
-export function resolveModels(
-  modality: Modality,
-  userModel?: string,
-  knownModels?: Pick<ModelEntry, "id">[]
-): string[] {
-  if (!userModel) return [DEFAULTS[modality]];
-  const models = userModel
-    .split(",")
-    .map((m) => m.trim())
-    .filter(Boolean)
-    .map((m) => expandModelId(m, knownModels));
-  return models.length > 0 ? models : [DEFAULTS[modality]];
-}
-
-function expandModelId(
-  input: string,
-  knownModels?: Pick<ModelEntry, "id">[]
-): string {
-  if (input.includes("/")) return input;
-  if (!knownModels) return input;
-
-  for (const m of knownModels) {
-    const name = m.id.slice(m.id.indexOf("/") + 1);
-    if (name === input) return m.id;
-  }
-
-  return input;
-}

package/src/lib/mp4.test.ts

@@ -1,231 +0,0 @@
-import { describe, test, expect } from "bun:test";
-
-import { extractKeyframe } from "./mp4.js";
-
-describe("extractKeyframe", () => {
-  test("returns null for empty buffer", () => {
-    expect(extractKeyframe(new Uint8Array(0))).toBeNull();
-  });
-
-  test("returns null for buffer too small", () => {
-    expect(extractKeyframe(new Uint8Array(4))).toBeNull();
-  });
-
-  test("returns null when no moov box found", () => {
-    // Valid-looking box header but wrong type
-    const buf = new Uint8Array(16);
-    const view = new DataView(buf.buffer);
-    view.setUint32(0, 16);
-    buf[4] = 0x66;
-    buf[5] = 0x74;
-    buf[6] = 0x79;
-    buf[7] = 0x70; // ftyp
-    expect(extractKeyframe(buf)).toBeNull();
-  });
-
-  test("returns null for minimal moov with no video track", () => {
-    // Construct a minimal moov box with no trak inside
-    const moovPayload = new Uint8Array(0);
-    const moovSize = 8 + moovPayload.length;
-    const buf = new Uint8Array(moovSize);
-    const view = new DataView(buf.buffer);
-    view.setUint32(0, moovSize);
-    buf[4] = 0x6d;
-    buf[5] = 0x6f;
-    buf[6] = 0x6f;
-    buf[7] = 0x76; // moov
-    expect(extractKeyframe(buf)).toBeNull();
-  });
-
-  test("builds a minimal MP4 structure and extracts keyframe data", () => {
-    // This test creates a valid-ish MP4 structure to exercise the parsing path.
-    // The actual H.264 data is minimal/dummy, so we just verify the parser
-    // successfully extracts SPS, PPS, and slice data.
-    const mp4 = buildMinimalMP4();
-    const result = extractKeyframe(mp4);
-
-    // If the MP4 was well-formed enough, we should get non-null result
-    if (result) {
-      expect(result.sps.length).toBeGreaterThan(0);
-      expect(result.pps.length).toBeGreaterThan(0);
-      expect(result.sliceData.length).toBeGreaterThan(0);
-    }
-  });
-});
-
-function writeBox(type: string, payload: Uint8Array): Uint8Array {
-  const size = 8 + payload.length;
-  const buf = new Uint8Array(size);
-  const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
-  view.setUint32(0, size);
-  for (let i = 0; i < 4; i++) buf[4 + i] = type.charCodeAt(i);
-  buf.set(payload, 8);
-  return buf;
-}
-
-function concatArrays(...arrs: Uint8Array[]): Uint8Array {
-  const total = arrs.reduce((s, a) => s + a.length, 0);
-  const result = new Uint8Array(total);
-  let off = 0;
-  for (const a of arrs) {
-    result.set(a, off);
-    off += a.length;
-  }
-  return result;
-}
-
-function buildMinimalMP4(): Uint8Array {
-  // SPS NAL unit (minimal baseline profile, 16x16 resolution)
-  const sps = new Uint8Array([
-    0x67, 0x42, 0x00, 0x0a, 0xe9, 0x40, 0x40, 0x04, 0x00, 0x00, 0x00, 0x04,
-    0x00, 0x00, 0x00, 0xc8, 0x40,
-  ]);
-  const pps = new Uint8Array([0x68, 0xce, 0x38, 0x80]);
-
-  // avcC box
-  const avcCPayload = new Uint8Array([
-    1, // version
-    0x42, // profile
-    0x00, // compat
-    0x0a, // level
-    0xff, // nal length size = 4
-    0xe1, // num SPS = 1
-    // SPS length + data
-    (sps.length >> 8) & 0xff,
-    sps.length & 0xff,
-    ...sps,
-    1, // num PPS = 1
-    (pps.length >> 8) & 0xff,
-    pps.length & 0xff,
-    ...pps,
-  ]);
-  const avcC = writeBox("avcC", avcCPayload);
-
-  // avc1 box: 78 bytes fixed header + avcC child
-  const avc1Fixed = new Uint8Array(78);
-  // data_ref_index at offset 6 = 1
-  avc1Fixed[6] = 0;
-  avc1Fixed[7] = 1;
-  // width at offset 24
-  avc1Fixed[24] = 0;
-  avc1Fixed[25] = 16;
-  // height at offset 26
-  avc1Fixed[26] = 0;
-  avc1Fixed[27] = 16;
-  const avc1Payload = concatArrays(avc1Fixed, avcC);
-  const avc1 = writeBox("avc1", avc1Payload);
-
-  // stsd box: version(4) + entry_count(4) + avc1
-  const stsdInner = new Uint8Array(8);
-  const stsdView = new DataView(stsdInner.buffer);
-  stsdView.setUint32(4, 1); // entry count
-  const stsd = writeBox("stsd", concatArrays(stsdInner, avc1));
-
-  // stsz (1 sample, size 10)
-  const stszPayload = new Uint8Array(12);
-  const stszView = new DataView(stszPayload.buffer);
-  stszView.setUint32(4, 0); // sample_size = variable
-  stszView.setUint32(8, 1); // sample_count = 1
-  const stszEntry = new Uint8Array(4);
-  new DataView(stszEntry.buffer).setUint32(0, 10);
-  const stsz = writeBox("stsz", concatArrays(stszPayload, stszEntry));
-
-  // stsc (1 entry: chunk 1, 1 sample/chunk, sdi 1)
-  const stscPayload = new Uint8Array(16);
-  const stscView = new DataView(stscPayload.buffer);
-  stscView.setUint32(4, 1); // entry count
-  stscView.setUint32(8, 1); // first chunk
-  stscView.setUint32(12, 1); // samples per chunk
-  const stscExtra = new Uint8Array(4);
-  new DataView(stscExtra.buffer).setUint32(0, 1);
-  const stsc = writeBox("stsc", concatArrays(stscPayload, stscExtra));
-
-  // stco (1 chunk offset, will be filled in later)
-  const stcoPayload = new Uint8Array(8);
-  const stcoView = new DataView(stcoPayload.buffer);
-  stcoView.setUint32(4, 1); // entry count
-  // offset will be set after we know the layout
-  const stcoOffsetPos = 8; // position within stco payload for the offset value
-  const stco = writeBox("stco", concatArrays(stcoPayload, new Uint8Array(4)));
-
-  // stss (1 sync sample: sample 1)
-  const stssPayload = new Uint8Array(8);
-  const stssView = new DataView(stssPayload.buffer);
-  stssView.setUint32(4, 1); // entry count
-  const stssSample = new Uint8Array(4);
-  new DataView(stssSample.buffer).setUint32(0, 1);
-  const stss = writeBox("stss", concatArrays(stssPayload, stssSample));
-
-  const stbl = writeBox("stbl", concatArrays(stsd, stsz, stsc, stco, stss));
-  const minf = writeBox("minf", stbl);
-
-  // hdlr box (video handler)
-  const hdlrPayload = new Uint8Array(20);
-  // handler_type at offset 8..11 = "vide"
-  hdlrPayload[8] = 0x76;
-  hdlrPayload[9] = 0x69;
-  hdlrPayload[10] = 0x64;
-  hdlrPayload[11] = 0x65;
-  const hdlr = writeBox("hdlr", hdlrPayload);
-
-  const mdia = writeBox("mdia", concatArrays(hdlr, minf));
-  const trak = writeBox("trak", mdia);
-  const moov = writeBox("moov", trak);
-
-  // mdat with a dummy IDR NAL unit (length-prefixed)
-  const idrNal = new Uint8Array([0x65, 0x88, 0x80, 0x40, 0x00, 0x00]);
-  const mdatPayload = new Uint8Array(4 + idrNal.length);
-  new DataView(mdatPayload.buffer).setUint32(0, idrNal.length);
-  mdatPayload.set(idrNal, 4);
-
-  // ftyp box
-  const ftyp = writeBox(
-    "ftyp",
-    new Uint8Array([
-      0x69,
-      0x73,
-      0x6f,
-      0x6d, // brand: isom
-      0x00,
-      0x00,
-      0x02,
-      0x00, // version
-    ])
-  );
-
-  const mdat = writeBox("mdat", mdatPayload);
-
-  // Calculate chunk offset
-  const mdatOffset = ftyp.length + moov.length + 8; // 8 for mdat header
-  const fullMp4 = concatArrays(ftyp, moov, mdat);
-
-  // Patch the stco chunk offset
-  // We need to find the stco entry in the final buffer and patch it
-  const stcoMarker = findStcoOffset(fullMp4);
-  if (stcoMarker >= 0) {
-    const view = new DataView(
-      fullMp4.buffer,
-      fullMp4.byteOffset,
-      fullMp4.byteLength
-    );
-    view.setUint32(stcoMarker, mdatOffset);
-  }
-
-  return fullMp4;
-}
-
-function findStcoOffset(buf: Uint8Array): number {
-  // Find the stco box and return the position of its first chunk offset entry
-  for (let i = 0; i < buf.length - 12; i++) {
-    if (
-      buf[i] === 0x73 &&
-      buf[i + 1] === 0x74 &&
-      buf[i + 2] === 0x63 &&
-      buf[i + 3] === 0x6f
-    ) {
-      // Found "stco" - the chunk offset entry is at i + 4 (version/flags) + 4 (entry_count) + 4
-      return i + 4 + 8;
-    }
-  }
-  return -1;
-}