ai-cli 0.1.1 → 0.2.1

package/src/commands/text.ts

@@ -1,117 +0,0 @@
-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({
-            headers: {
-              "http-referer": "https://github.com/vercel-labs/ai-cli",
-              "x-title": "ai-cli",
-            },
-            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

@@ -1,113 +0,0 @@
-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({
-            headers: {
-              "http-referer": "https://github.com/vercel-labs/ai-cli",
-              "x-title": "ai-cli",
-            },
-            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

@@ -1,30 +0,0 @@
-#!/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

@@ -1,5 +0,0 @@
-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

@@ -1,164 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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();
-  });
-});

package/src/lib/jobs.ts

@@ -1,192 +0,0 @@
-import {
-  supportsKittyGraphics,
-  displayImage,
-  displayVideoFrame,
-} from "./kitty.js";
-import type { OutputFormat } from "./output.js";
-import { writeOutput } from "./output.js";
-import { pMap } from "./p-map.js";
-import { Progress, MultiProgress, formatElapsed } from "./progress.js";
-
-export interface Job {
-  modelId: string;
-  label: string;
-  index: number;
-}
-
-export interface RunJobsOptions {
-  noun: string;
-  format: OutputFormat;
-  outputPath?: string;
-  quiet?: boolean;
-  json?: boolean;
-  concurrency: number;
-  display?: boolean;
-}
-
-export function buildJobs(models: string[], countPerModel: number): Job[] {
-  let jobIndex = 0;
-  return models.flatMap((modelId) =>
-    Array.from({ length: countPerModel }, (_, i) => ({
-      modelId,
-      label: models.length > 1 ? `${modelId} #${i + 1}` : `#${i + 1}`,
-      index: jobIndex++,
-    }))
-  );
-}
-
-export interface RunJobsResult {
-  total: number;
-  failed: number;
-}
-
-export async function runJobs(
-  jobs: Job[],
-  generate: (modelId: string) => Promise<Buffer | string>,
-  opts: RunJobsOptions
-): Promise<RunJobsResult> {
-  const { noun, format, outputPath, quiet, json, concurrency, display } = opts;
-
-  if (jobs.length === 1) {
-    const { modelId } = jobs[0];
-    const progress = new Progress(quiet);
-    const start = Date.now();
-    progress.start(`Generating ${noun} with ${modelId}`);
-
-    try {
-      const data = await generate(modelId);
-      const elapsed = Date.now() - start;
-      progress.stop(`Generated ${noun} with ${modelId}`);
-
-      if (json) {
-        const path = await writeOutput({
-          data,
-          format,
-          outputPath,
-          quiet: true,
-          display,
-        });
-        const meta = {
-          elapsed_ms: elapsed,
-          count: 1,
-          results: [
-            {
-              index: 1,
-              model: modelId,
-              elapsed_ms: elapsed,
-              success: true,
-              file: path,
-            },
-          ],
-        };
-        process.stdout.write(JSON.stringify(meta, null, 2) + "\n");
-      } else {
-        await writeOutput({ data, format, outputPath, quiet, display });
-      }
-    } catch (err) {
-      progress.stop();
-      throw err;
-    }
-    return { total: 1, failed: 0 };
-  }
-
-  const multi = new MultiProgress(quiet);
-  const start = Date.now();
-  const shouldDisplay =
-    display !== false &&
-    (format === "image" || format === "video") &&
-    process.stdout.isTTY &&
-    supportsKittyGraphics();
-
-  const lineIdxs = jobs.map((j) =>
-    multi.addLine(`Generating ${noun} ${j.label} with ${j.modelId}`)
-  );
-
-  const results: {
-    index: number;
-    model: string;
-    success: boolean;
-    elapsed_ms: number;
-    file: string | null;
-  }[] = [];
-  const pendingDisplayBuffers: Buffer[] = [];
-
-  await pMap(
-    jobs,
-    async (job, i) => {
-      multi.startLine(lineIdxs[i]);
-      const genStart = Date.now();
-      try {
-        const data = await generate(job.modelId);
-        const genElapsed = Date.now() - genStart;
-        const suffix = `${i + 1}`;
-        const path = await writeOutput({
-          data,
-          format,
-          outputPath,
-          suffix,
-          quiet: true,
-          display: false,
-        });
-        if (shouldDisplay && Buffer.isBuffer(data))
-          pendingDisplayBuffers.push(data);
-        const savedMsg = path
-          ? `Saved to ${path}`
-          : `${noun[0].toUpperCase()}${noun.slice(1)} ${job.label} written to stdout`;
-        multi.completeLine(
-          lineIdxs[i],
-          `${savedMsg} (${formatElapsed(genElapsed)})`
-        );
-        results.push({
-          index: i,
-          model: job.modelId,
-          success: true,
-          elapsed_ms: genElapsed,
-          file: path,
-        });
-      } catch (err: unknown) {
-        const genElapsed = Date.now() - genStart;
-        const msg = err instanceof Error ? err.message : String(err);
-        multi.completeLine(
-          lineIdxs[i],
-          `${noun[0].toUpperCase()}${noun.slice(1)} ${job.label} failed: ${msg} (${formatElapsed(genElapsed)})`
-        );
-        results.push({
-          index: i,
-          model: job.modelId,
-          success: false,
-          elapsed_ms: genElapsed,
-          file: null,
-        });
-      }
-    },
-    concurrency
-  );
-
-  if (json) {
-    const totalElapsed = Date.now() - start;
-    const meta = {
-      elapsed_ms: totalElapsed,
-      count: results.filter((r) => r.success).length,
-      results: results.map((r) => ({
-        index: r.index + 1,
-        model: r.model,
-        elapsed_ms: r.elapsed_ms,
-        success: r.success,
-        file: r.file,
-      })),
-    };
-    process.stdout.write(JSON.stringify(meta, null, 2) + "\n");
-  }
-
-  for (const buf of pendingDisplayBuffers) {
-    if (format === "video") {
-      await displayVideoFrame(buf);
-    } else {
-      displayImage(buf);
-    }
-  }
-
-  const failCount = results.filter((r) => !r.success).length;
-  return { total: results.length, failed: failCount };
-}