ai-cli 0.0.12 → 0.1.0

package/src/commands/models.ts

@@ -0,0 +1,117 @@
+import type { Command } from "commander";
+
+import { fetchGatewayModels, type ModelEntry } from "../lib/models.js";
+
+function groupByProvider(models: ModelEntry[]): Map<string, ModelEntry[]> {
+  const groups = new Map<string, ModelEntry[]>();
+  for (const m of models) {
+    const slash = m.id.indexOf("/");
+    const provider = slash !== -1 ? m.id.slice(0, slash) : "other";
+    if (!groups.has(provider)) groups.set(provider, []);
+    groups.get(provider)!.push(m);
+  }
+  return new Map(
+    [...groups.entries()].sort((a, b) => a[0].localeCompare(b[0]))
+  );
+}
+
+function modelName(id: string): string {
+  const slash = id.indexOf("/");
+  return slash !== -1 ? id.slice(slash + 1) : id;
+}
+
+export function registerModelsCommand(program: Command) {
+  program
+    .command("models")
+    .description("List available models from AI Gateway")
+    .option("--type <type>", "Filter by type: text, image, video")
+    .option("--provider <name>", "Filter by provider (e.g. openai, google)")
+    .option("--json", "Output as JSON (includes descriptions)")
+    .action(
+      async (opts: { type?: string; provider?: string; json?: boolean }) => {
+        const validTypes = ["text", "image", "video"];
+        const filterType = opts.type?.toLowerCase();
+        if (filterType && !validTypes.includes(filterType)) {
+          process.stderr.write(
+            `Error: --type must be one of: ${validTypes.join(", ")} (got "${opts.type}")\n`
+          );
+          process.exit(1);
+        }
+        const filterProvider = opts.provider?.toLowerCase();
+
+        const gatewayModels = await fetchGatewayModels();
+
+        const filterGrouped = (grouped: Map<string, ModelEntry[]>) => {
+          if (!filterProvider) return grouped;
+          const filtered = new Map<string, ModelEntry[]>();
+          for (const [provider, models] of grouped) {
+            if (provider.toLowerCase() === filterProvider) {
+              filtered.set(provider, models);
+            }
+          }
+          return filtered;
+        };
+
+        if (opts.json) {
+          const output: Record<string, unknown> = {};
+          const jsonMapper = (m: ModelEntry) => ({
+            id: m.id,
+            ...(m.name ? { name: m.name } : {}),
+            ...(m.description ? { description: m.description } : {}),
+          });
+          if (!filterType || filterType === "text") {
+            output.text = Object.fromEntries(
+              [...filterGrouped(groupByProvider(gatewayModels.text))].map(
+                ([provider, models]) => [provider, models.map(jsonMapper)]
+              )
+            );
+          }
+          if (!filterType || filterType === "image") {
+            output.image = Object.fromEntries(
+              [...filterGrouped(groupByProvider(gatewayModels.image))].map(
+                ([provider, models]) => [provider, models.map(jsonMapper)]
+              )
+            );
+          }
+          if (!filterType || filterType === "video") {
+            output.video = Object.fromEntries(
+              [...filterGrouped(groupByProvider(gatewayModels.video))].map(
+                ([provider, models]) => [provider, models.map(jsonMapper)]
+              )
+            );
+          }
+          process.stdout.write(JSON.stringify(output, null, 2) + "\n");
+          return;
+        }
+
+        const sections: { title: string; entries: ModelEntry[] }[] = [];
+        if (!filterType || filterType === "text")
+          sections.push({ title: "Text", entries: gatewayModels.text });
+        if (!filterType || filterType === "image")
+          sections.push({ title: "Image", entries: gatewayModels.image });
+        if (!filterType || filterType === "video")
+          sections.push({ title: "Video", entries: gatewayModels.video });
+
+        let totalCount = 0;
+        for (const section of sections) {
+          const grouped = filterGrouped(groupByProvider(section.entries));
+          const count = [...grouped.values()].reduce((s, m) => s + m.length, 0);
+          if (count === 0) continue;
+          totalCount += count;
+          process.stdout.write(`\n${section.title} models (${count}):\n`);
+          for (const [provider, models] of grouped) {
+            process.stdout.write(`\n  ${provider}\n`);
+            for (const m of models) {
+              process.stdout.write(`    ${modelName(m.id)}\n`);
+            }
+          }
+        }
+
+        if (totalCount === 0) {
+          process.stderr.write("No models found matching filters\n");
+        } else {
+          process.stdout.write("\n");
+        }
+      }
+    );
+}

package/src/commands/text.ts

@@ -0,0 +1,113 @@
+import { generateText, gateway } from "ai";
+import type { Command } from "commander";
+
+import { buildJobs, runJobs } from "../lib/jobs.js";
+import { resolveModels } from "../lib/models.js";
+import type { OutputFormat } from "../lib/output.js";
+import { parsePositiveInt, parseTemperature } from "../lib/parse.js";
+import { readStdin, stdinAsText } from "../lib/stdin.js";
+
+const DEFAULT_CONCURRENCY = 4;
+const DEFAULT_TIMEOUT_MS = 120_000;
+
+interface TextOptions {
+  model?: string;
+  output?: string;
+  format?: string;
+  system?: string;
+  maxTokens?: string;
+  temperature?: string;
+  count?: string;
+  concurrency?: string;
+  quiet?: boolean;
+  json?: boolean;
+}
+
+function resolveFormat(fmt?: string): OutputFormat {
+  if (!fmt || fmt === "md") return "md";
+  if (fmt === "txt") return "txt";
+  throw new Error(`--format must be one of: md, txt (got "${fmt}")`);
+}
+
+export function registerTextCommand(program: Command) {
+  program
+    .command("text")
+    .description("Generate text from a prompt")
+    .argument("[prompt]", "The prompt to generate text from")
+    .option(
+      "-m, --model <model>",
+      "Model ID (creator/model-name), comma-separated for multi-model"
+    )
+    .option("-o, --output <path>", "Output file path or directory")
+    .option("-f, --format <fmt>", "Output format: md, txt (default: md)")
+    .option("-n, --count <n>", "Number of generations (default: 1)")
+    .option(
+      "-p, --concurrency <n>",
+      `Max parallel generations (default: ${DEFAULT_CONCURRENCY})`
+    )
+    .option("-s, --system <prompt>", "System prompt")
+    .option("--max-tokens <n>", "Maximum tokens to generate")
+    .option("-t, --temperature <n>", "Temperature (0-2)")
+    .option("-q, --quiet", "Suppress progress output")
+    .option("--json", "Output metadata as JSON")
+    .action(async (rawPrompt: string | undefined, opts: TextOptions) => {
+      const prompt = rawPrompt?.trim() || undefined;
+      const stdin = await readStdin();
+      if (!prompt && !stdin) {
+        process.stderr.write(
+          "Error: prompt is required (provide as argument or pipe via stdin)\n"
+        );
+        process.exit(1);
+      }
+      let fullPrompt: string;
+      if (stdin && prompt) {
+        fullPrompt = `${stdinAsText(stdin)}\n\n---\n\n${prompt}`;
+      } else if (stdin) {
+        fullPrompt = stdinAsText(stdin);
+      } else {
+        fullPrompt = prompt!;
+      }
+
+      const format = resolveFormat(opts.format);
+      const models = resolveModels("text", opts.model);
+      const countPerModel = opts.count
+        ? parsePositiveInt(opts.count, "count")
+        : 1;
+      const maxTokens = opts.maxTokens
+        ? parsePositiveInt(opts.maxTokens, "max-tokens")
+        : undefined;
+      const temperature = opts.temperature
+        ? parseTemperature(opts.temperature)
+        : undefined;
+
+      const jobs = buildJobs(models, countPerModel);
+
+      const { total, failed } = await runJobs(
+        jobs,
+        async (modelId) => {
+          const abort = AbortSignal.timeout(DEFAULT_TIMEOUT_MS);
+          const result = await generateText({
+            model: gateway(modelId),
+            prompt: fullPrompt,
+            system: opts.system,
+            maxOutputTokens: maxTokens,
+            temperature,
+            abortSignal: abort,
+          });
+          return result.text;
+        },
+        {
+          noun: "text",
+          format,
+          outputPath: opts.output,
+          quiet: opts.quiet,
+          json: opts.json,
+          concurrency: opts.concurrency
+            ? parsePositiveInt(opts.concurrency, "concurrency")
+            : DEFAULT_CONCURRENCY,
+        }
+      );
+      if (failed === total) process.exit(1);
+      if (failed > 0) process.exit(2);
+    });
+}

package/src/commands/video.ts

@@ -0,0 +1,109 @@
+import { experimental_generateVideo as generateVideo, gateway } from "ai";
+import type { Command } from "commander";
+
+import { buildJobs, runJobs } from "../lib/jobs.js";
+import { resolveModels } from "../lib/models.js";
+import {
+  parsePositiveInt,
+  parseAspectRatio,
+  parseNonNegativeFloat,
+} from "../lib/parse.js";
+import { readStdin } from "../lib/stdin.js";
+
+const DEFAULT_CONCURRENCY = 2;
+const DEFAULT_TIMEOUT_MS = 300_000;
+
+interface VideoOptions {
+  model?: string;
+  output?: string;
+  count?: string;
+  aspectRatio?: string;
+  duration?: string;
+  quiet?: boolean;
+  json?: boolean;
+  concurrency?: string;
+  preview?: boolean;
+}
+
+export function registerVideoCommand(program: Command) {
+  program
+    .command("video")
+    .description("Generate a video from a prompt")
+    .argument("[prompt]", "The prompt to generate a video from")
+    .option(
+      "-m, --model <model>",
+      "Model ID (creator/model-name), comma-separated for multi-model"
+    )
+    .option("-o, --output <path>", "Output file path or directory")
+    .option("-n, --count <n>", "Number of videos per model (default: 1)")
+    .option("--aspect-ratio <W:H>", "Aspect ratio (e.g. 16:9)")
+    .option("--duration <seconds>", "Video duration in seconds")
+    .option("-q, --quiet", "Suppress progress output")
+    .option("--json", "Output metadata as JSON")
+    .option(
+      "--no-preview",
+      "Disable inline video frame preview in supported terminals"
+    )
+    .option(
+      "-p, --concurrency <n>",
+      `Max parallel generations (default: ${DEFAULT_CONCURRENCY})`
+    )
+    .action(async (rawPrompt: string | undefined, opts: VideoOptions) => {
+      const prompt = rawPrompt?.trim() || undefined;
+      const stdin = await readStdin();
+      if (!prompt && !stdin) {
+        process.stderr.write(
+          "Error: prompt is required (provide as argument or pipe via stdin)\n"
+        );
+        process.exit(1);
+      }
+
+      let videoPrompt: string | { image: Uint8Array; text?: string } = prompt!;
+      if (stdin) {
+        videoPrompt = prompt
+          ? { image: new Uint8Array(stdin), text: prompt }
+          : { image: new Uint8Array(stdin) };
+      }
+
+      const models = resolveModels("video", opts.model);
+      const countPerModel = opts.count
+        ? parsePositiveInt(opts.count, "count")
+        : 1;
+      const aspectRatio = opts.aspectRatio
+        ? parseAspectRatio(opts.aspectRatio)
+        : undefined;
+      const duration = opts.duration
+        ? parseNonNegativeFloat(opts.duration, "duration")
+        : undefined;
+
+      const jobs = buildJobs(models, countPerModel);
+
+      const { total, failed } = await runJobs(
+        jobs,
+        async (modelId) => {
+          const abort = AbortSignal.timeout(DEFAULT_TIMEOUT_MS);
+          const result = await generateVideo({
+            model: gateway.video(modelId),
+            prompt: videoPrompt,
+            abortSignal: abort,
+            aspectRatio,
+            duration,
+          });
+          return Buffer.from(result.video.uint8Array);
+        },
+        {
+          noun: "video",
+          format: "video",
+          outputPath: opts.output,
+          quiet: opts.quiet,
+          json: opts.json,
+          display: opts.preview,
+          concurrency: opts.concurrency
+            ? parsePositiveInt(opts.concurrency, "concurrency")
+            : DEFAULT_CONCURRENCY,
+        }
+      );
+      if (failed === total) process.exit(1);
+      if (failed > 0) process.exit(2);
+    });
+}

package/src/index.ts

@@ -0,0 +1,30 @@
+#!/usr/bin/env bun
+import { Command } from "commander";
+
+import pkg from "../package.json";
+import { registerCompletionsCommand } from "./commands/completions.js";
+import { registerImageCommand } from "./commands/image.js";
+import { registerModelsCommand } from "./commands/models.js";
+import { registerTextCommand } from "./commands/text.js";
+import { registerVideoCommand } from "./commands/video.js";
+
+const program = new Command();
+
+program
+  .name("ai")
+  .description(
+    "A tiny, agent-native CLI for generating images, video and text with dead-simple commands, stdin support and predictable artifact outputs"
+  )
+  .version(pkg.version);
+
+registerTextCommand(program);
+registerImageCommand(program);
+registerVideoCommand(program);
+registerModelsCommand(program);
+registerCompletionsCommand(program);
+
+program.parseAsync(process.argv).catch((err: unknown) => {
+  const msg = err instanceof Error ? err.message : String(err);
+  process.stderr.write(`Error: ${msg}\n`);
+  process.exit(1);
+});

package/src/lib/color.ts

@@ -0,0 +1,5 @@
+export function isColorEnabled(): boolean {
+  if (process.env.NO_COLOR !== undefined) return false;
+  if (process.env.FORCE_COLOR !== undefined) return true;
+  return !!process.stderr.isTTY;
+}

package/src/lib/h264-wasm.ts

@@ -0,0 +1,164 @@
+export interface DecodedFrame {
+  yuv: Uint8Array;
+  width: number;
+  height: number;
+}
+
+interface OpenH264Module {
+  _decoder_init(): number;
+  _decoder_feed(ptr: number, len: number): number;
+  _decoder_flush(): number;
+  _decoder_destroy(): void;
+  _get_has_frame(): number;
+  _get_width(): number;
+  _get_height(): number;
+  _get_y_stride(): number;
+  _get_uv_stride(): number;
+  _get_y_ptr(): number;
+  _get_u_ptr(): number;
+  _get_v_ptr(): number;
+  _malloc(size: number): number;
+  _free(ptr: number): void;
+  HEAPU8: Uint8Array;
+}
+
+const START_CODE = new Uint8Array([0x00, 0x00, 0x00, 0x01]);
+
+function buildAnnexB(
+  sps: Uint8Array,
+  pps: Uint8Array,
+  idr: Uint8Array
+): Uint8Array {
+  const len = START_CODE.length * 3 + sps.length + pps.length + idr.length;
+  const buf = new Uint8Array(len);
+  let off = 0;
+  buf.set(START_CODE, off);
+  off += START_CODE.length;
+  buf.set(sps, off);
+  off += sps.length;
+  buf.set(START_CODE, off);
+  off += START_CODE.length;
+  buf.set(pps, off);
+  off += pps.length;
+  buf.set(START_CODE, off);
+  off += START_CODE.length;
+  buf.set(idr, off);
+  return buf;
+}
+
+function extractPlanarYUV(
+  mod: OpenH264Module,
+  width: number,
+  height: number
+): Uint8Array {
+  const yStride = mod._get_y_stride();
+  const uvStride = mod._get_uv_stride();
+  const yPtr = mod._get_y_ptr();
+  const uPtr = mod._get_u_ptr();
+  const vPtr = mod._get_v_ptr();
+
+  const chromaW = width >> 1;
+  const chromaH = height >> 1;
+  const ySize = width * height;
+  const cSize = chromaW * chromaH;
+  const out = new Uint8Array(ySize + cSize * 2);
+
+  const heap = mod.HEAPU8;
+
+  for (let y = 0; y < height; y++) {
+    out.set(
+      heap.subarray(yPtr + y * yStride, yPtr + y * yStride + width),
+      y * width
+    );
+  }
+
+  const cbOff = ySize;
+  for (let y = 0; y < chromaH; y++) {
+    out.set(
+      heap.subarray(uPtr + y * uvStride, uPtr + y * uvStride + chromaW),
+      cbOff + y * chromaW
+    );
+  }
+
+  const crOff = cbOff + cSize;
+  for (let y = 0; y < chromaH; y++) {
+    out.set(
+      heap.subarray(vPtr + y * uvStride, vPtr + y * uvStride + chromaW),
+      crOff + y * chromaW
+    );
+  }
+
+  return out;
+}
+
+let modulePromise: Promise<OpenH264Module> | null = null;
+
+function getModule(): Promise<OpenH264Module> {
+  if (!modulePromise) {
+    modulePromise = (async () => {
+      const { readFileSync } = await import("fs");
+      const wasmPath: string = (await import("./openh264.wasm")).default;
+      const wasmBinary = readFileSync(wasmPath);
+      const factory = (await import("./openh264.mjs")).default;
+      return factory({
+        wasmBinary,
+        print: () => {},
+        printErr: () => {},
+      }) as Promise<OpenH264Module>;
+    })();
+  }
+  return modulePromise;
+}
+
+export async function decodeIDR(
+  sps: Uint8Array,
+  pps: Uint8Array,
+  sliceData: Uint8Array
+): Promise<DecodedFrame | null> {
+  if (!sps.length || !pps.length || !sliceData.length) return null;
+
+  const mod = await getModule();
+  const annexB = buildAnnexB(sps, pps, sliceData);
+
+  if (mod._decoder_init() !== 0) return null;
+
+  let ptr = 0;
+  try {
+    ptr = mod._malloc(annexB.length);
+    if (!ptr) {
+      mod._decoder_destroy();
+      return null;
+    }
+    mod.HEAPU8.set(annexB, ptr);
+
+    mod._decoder_feed(ptr, annexB.length);
+
+    if (!mod._get_has_frame()) {
+      mod._decoder_feed(0, 0);
+    }
+    if (!mod._get_has_frame()) {
+      mod._decoder_flush();
+    }
+    if (!mod._get_has_frame()) {
+      mod._free(ptr);
+      mod._decoder_destroy();
+      return null;
+    }
+
+    const width = mod._get_width();
+    const height = mod._get_height();
+    const yuv = extractPlanarYUV(mod, width, height);
+
+    mod._free(ptr);
+    mod._decoder_destroy();
+    return { yuv, width, height };
+  } catch {
+    if (ptr) mod._free(ptr);
+    try {
+      mod._decoder_destroy();
+    } catch {
+      /* best-effort */
+    }
+    return null;
+  }
+}

package/src/lib/h264.test.ts

@@ -0,0 +1,48 @@
+import { describe, test, expect } from "bun:test";
+
+import { decodeIDR } from "./h264-wasm.js";
+
+describe("decodeIDR (openh264 WASM)", () => {
+  test("returns null for empty inputs", async () => {
+    expect(
+      await decodeIDR(new Uint8Array(0), new Uint8Array(0), new Uint8Array(0))
+    ).toBeNull();
+  });
+
+  test("returns null for truncated SPS", async () => {
+    const sps = new Uint8Array([0x67, 0x42]);
+    const pps = new Uint8Array([0x68, 0xce, 0x38, 0x80]);
+    const slice = new Uint8Array([0x65, 0x88, 0x80, 0x40]);
+    expect(await decodeIDR(sps, pps, slice)).toBeNull();
+  });
+
+  test("gracefully handles malformed data without crashing", async () => {
+    const sps = new Uint8Array([0x67, 0x42, 0x00, 0x0a, 0xe9, 0x40, 0x40]);
+    const pps = new Uint8Array([0x68, 0xce, 0x38, 0x80]);
+    const slice = new Uint8Array(100);
+    slice[0] = 0x65;
+    for (let i = 1; i < 100; i++) slice[i] = (i * 37) & 0xff;
+
+    const result = await decodeIDR(sps, pps, slice);
+    expect(
+      result === null || (result && result.yuv instanceof Uint8Array)
+    ).toBeTruthy();
+  });
+
+  test("returns DecodedFrame with valid YUV for well-formed data", async () => {
+    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]);
+    const slice = new Uint8Array(200);
+    slice[0] = 0x65;
+    for (let i = 1; i < 200; i++) slice[i] = (i * 37) & 0xff;
+
+    const result = await decodeIDR(sps, pps, slice);
+    // May return null for synthetic data, but should not throw
+    expect(
+      result === null || (result && result.width > 0 && result.height > 0)
+    ).toBeTruthy();
+  });
+});