ai-cli 0.0.12 → 0.1.0

package/package.json

@@ -1,49 +1,48 @@
 {
   "name": "ai-cli",
-  "version": "0.0.12",
-  "main": "dist/ai.mjs",
-  "bin": {
-    "ai": "dist/ai.mjs"
+  "version": "0.1.0",
+  "description": "A tiny, agent-native CLI for generating images, video and text with dead-simple commands, stdin support and predictable artifact outputs",
+  "type": "module",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vercel-labs/ai-cli.git"
   },
-  "engines": {
-    "node": ">=18.0.0"
+  "bin": {
+    "ai": "./src/index.ts"
   },
   "files": [
-    "dist/",
+    "src",
     "README.md"
   ],
+  "keywords": [
+    "ai",
+    "cli",
+    "generative",
+    "image",
+    "video",
+    "text",
+    "ai-sdk",
+    "vercel"
+  ],
   "scripts": {
-    "build": "node build.mjs",
-    "test": "bun test tests/*.test.ts",
-    "test:coverage": "bun test --coverage tests/*.test.ts",
-    "test:e2e": "bun test tests/e2e/",
-    "test:evals": "bun test tests/evals/",
-    "test:evals:matrix": "bun run tests/evals/run-matrix.ts",
-    "lint": "biome lint .",
-    "format": "biome format . --write",
+    "dev": "bun run src/index.ts",
+    "build": "bun build src/index.ts --compile --outfile=dist/ai",
     "typecheck": "tsc --noEmit",
-    "format:check": "biome format .",
-    "check": "biome check .",
-    "prepublishOnly": "bun run build"
+    "format": "oxfmt --write src/",
+    "format:check": "oxfmt --check src/",
+    "lint": "oxlint src/",
+    "test": "bun test",
+    "prepublishOnly": "bun run typecheck"
   },
-  "type": "module",
   "dependencies": {
-    "@ai-sdk/gateway": "3.0.40",
-    "@ai-sdk/mcp": "^1.0.18",
-    "@mozilla/readability": "^0.6.0",
-    "linkedom": "^0.18.12"
+    "ai": "^6.0.173",
+    "commander": "^14.0.3"
   },
   "devDependencies": {
-    "@ai-cli/typescript-config": "workspace:*",
-    "@types/node": "^24.1.0",
-    "@xterm/headless": "^6.0.0",
-    "ai": "6.0.79",
-    "ansi-escapes": "^7.3.0",
-    "arg": "^5.0.2",
-    "esbuild": "^0.25.8",
-    "rc9": "^2.1.2",
-    "typescript": "^5.8.3",
-    "yoctocolors": "^2.1.1",
-    "zod": "^4.1.8"
+    "@types/bun": "^1.3.13",
+    "oxfmt": "^0.47.0",
+    "oxlint": "^1.62.0",
+    "typescript": "^6.0.3"
   }
 }

package/src/cli.test.ts

@@ -0,0 +1,95 @@
+import { describe, expect, test } from "bun:test";
+
+const CLI = ["bun", "run", "src/index.ts"];
+const ROOT = import.meta.dir + "/..";
+
+async function run(...args: string[]) {
+  const proc = Bun.spawn([...CLI, ...args], {
+    cwd: ROOT,
+    stdout: "pipe",
+    stderr: "pipe",
+    stdin: "ignore",
+  });
+  const [stdout, stderr] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+  ]);
+  const exitCode = await proc.exited;
+  return { exitCode, stdout, stderr };
+}
+
+describe("cli integration", () => {
+  test("--help exits 0 and lists subcommands", async () => {
+    const { exitCode, stdout } = await run("--help");
+    expect(exitCode).toBe(0);
+    for (const sub of ["text", "image", "video", "models", "completions"]) {
+      expect(stdout).toContain(sub);
+    }
+  });
+
+  test("--version exits 0 and prints semver", async () => {
+    const { exitCode, stdout } = await run("--version");
+    expect(exitCode).toBe(0);
+    expect(stdout.trim()).toMatch(/^\d+\.\d+\.\d+/);
+  });
+
+  test("completions zsh exits 0 with valid output", async () => {
+    const { exitCode, stdout } = await run("completions", "zsh");
+    expect(exitCode).toBe(0);
+    expect(stdout).toContain("#compdef ai");
+    expect(stdout).toContain("--no-preview");
+  });
+
+  test("completions bash exits 0 with valid output", async () => {
+    const { exitCode, stdout } = await run("completions", "bash");
+    expect(exitCode).toBe(0);
+    expect(stdout).toContain("complete -F");
+  });
+
+  test("completions fish exits 0 with valid output", async () => {
+    const { exitCode, stdout } = await run("completions", "fish");
+    expect(exitCode).toBe(0);
+    expect(stdout).toContain("complete -c ai");
+  });
+
+  test("completions with invalid shell exits 1", async () => {
+    const { exitCode, stderr } = await run("completions", "powershell");
+    expect(exitCode).toBe(1);
+    expect(stderr).toContain("Unknown shell");
+  });
+
+  test("text with no prompt and no stdin exits 1", async () => {
+    const { exitCode, stderr } = await run("text");
+    expect(exitCode).toBe(1);
+    expect(stderr).toContain("prompt is required");
+  });
+
+  test("text --help exits 0 and lists flags", async () => {
+    const { exitCode, stdout } = await run("text", "--help");
+    expect(exitCode).toBe(0);
+    expect(stdout).toContain("--model");
+    expect(stdout).toContain("--format");
+    expect(stdout).toContain("--temperature");
+  });
+
+  test("image --help exits 0 and lists flags", async () => {
+    const { exitCode, stdout } = await run("image", "--help");
+    expect(exitCode).toBe(0);
+    expect(stdout).toContain("--no-preview");
+    expect(stdout).toContain("--size");
+    expect(stdout).toContain("--aspect-ratio");
+  });
+
+  test("video --help exits 0 and lists flags", async () => {
+    const { exitCode, stdout } = await run("video", "--help");
+    expect(exitCode).toBe(0);
+    expect(stdout).toContain("--duration");
+    expect(stdout).toContain("--aspect-ratio");
+  });
+
+  test("models --type invalid exits 1", async () => {
+    const { exitCode, stderr } = await run("models", "--type", "audio");
+    expect(exitCode).toBe(1);
+    expect(stderr).toContain("must be one of");
+  });
+});

package/src/commands/completions.ts

@@ -0,0 +1,296 @@
+import type { Command } from "commander";
+
+import {
+  FALLBACK_TEXT_MODELS,
+  FALLBACK_IMAGE_MODELS,
+  FALLBACK_VIDEO_MODELS,
+} from "../lib/models.js";
+
+export function registerCompletionsCommand(program: Command) {
+  program
+    .command("completions")
+    .description("Output shell completion script")
+    .argument("<shell>", "Shell type: zsh, bash, fish")
+    .action((shell: string) => {
+      switch (shell.toLowerCase()) {
+        case "zsh":
+          process.stdout.write(generateZsh());
+          break;
+        case "bash":
+          process.stdout.write(generateBash());
+          break;
+        case "fish":
+          process.stdout.write(generateFish());
+          break;
+        default:
+          process.stderr.write(
+            `Unknown shell: ${shell}. Supported: zsh, bash, fish\n`
+          );
+          process.exit(1);
+      }
+    });
+}
+
+const SUBCOMMANDS = ["text", "image", "video", "models", "completions", "help"];
+const GLOBAL_FLAGS = [
+  "--model",
+  "--output",
+  "--count",
+  "--concurrency",
+  "--quiet",
+  "--json",
+  "--help",
+  "--version",
+];
+const TEXT_FLAGS = ["--format", "--system", "--max-tokens", "--temperature"];
+const IMAGE_FLAGS = [
+  "--size",
+  "--aspect-ratio",
+  "--quality",
+  "--style",
+  "--no-preview",
+];
+const VIDEO_FLAGS = ["--aspect-ratio", "--duration", "--no-preview"];
+const MODEL_FLAGS = ["--type", "--provider", "--json", "--help"];
+
+const ALL_MODELS = [
+  ...FALLBACK_TEXT_MODELS,
+  ...FALLBACK_IMAGE_MODELS,
+  ...FALLBACK_VIDEO_MODELS,
+];
+const MODEL_NAMES = ALL_MODELS.map((m) => m.slice(m.indexOf("/") + 1));
+
+function generateZsh(): string {
+  return `#compdef ai
+
+_ai() {
+  local -a subcommands
+  subcommands=(
+    'text:Generate text from a prompt'
+    'image:Generate an image from a prompt'
+    'video:Generate a video from a prompt'
+    'models:List available models'
+    'completions:Output shell completion script'
+    'help:Display help'
+  )
+
+  local -a models
+  models=(${ALL_MODELS.join(" ")})
+
+  local -a model_names
+  model_names=(${MODEL_NAMES.join(" ")})
+
+  _arguments -C \\
+    '1:command:->cmd' \\
+    '*::arg:->args'
+
+  case $state in
+    cmd)
+      _describe 'command' subcommands
+      ;;
+    args)
+      case $words[1] in
+        text)
+          _arguments \\
+            '-m[Model ID]:model:($models $model_names)' \\
+            '--model[Model ID]:model:($models $model_names)' \\
+            '-o[Output path]:file:_files' \\
+            '--output[Output path]:file:_files' \\
+            '-f[Format]:format:(md txt)' \\
+            '--format[Format]:format:(md txt)' \\
+            '-n[Count]:count:' \\
+            '--count[Count]:count:' \\
+            '-p[Concurrency]:concurrency:' \\
+            '--concurrency[Concurrency]:concurrency:' \\
+            '-s[System prompt]:system:' \\
+            '--system[System prompt]:system:' \\
+            '--max-tokens[Max tokens]:tokens:' \\
+            '-t[Temperature]:temp:' \\
+            '--temperature[Temperature]:temp:' \\
+            '-q[Quiet]' \\
+            '--quiet[Quiet]' \\
+            '--json[JSON output]' \\
+            '*:prompt:'
+          ;;
+        image)
+          _arguments \\
+            '-m[Model ID]:model:($models $model_names)' \\
+            '--model[Model ID]:model:($models $model_names)' \\
+            '-o[Output path]:file:_files' \\
+            '--output[Output path]:file:_files' \\
+            '-n[Count]:count:' \\
+            '--count[Count]:count:' \\
+            '-p[Concurrency]:concurrency:' \\
+            '--concurrency[Concurrency]:concurrency:' \\
+            '--size[Size]:size:' \\
+            '--aspect-ratio[Aspect ratio]:ratio:' \\
+            '--quality[Quality]:quality:(standard hd)' \\
+            '--style[Style]:style:(vivid natural)' \\
+            '--no-preview[Disable inline image preview]' \\
+            '-q[Quiet]' \\
+            '--quiet[Quiet]' \\
+            '--json[JSON output]' \\
+            '*:prompt:'
+          ;;
+        video)
+          _arguments \\
+            '-m[Model ID]:model:($models $model_names)' \\
+            '--model[Model ID]:model:($models $model_names)' \\
+            '-o[Output path]:file:_files' \\
+            '--output[Output path]:file:_files' \\
+            '-n[Count]:count:' \\
+            '--count[Count]:count:' \\
+            '-p[Concurrency]:concurrency:' \\
+            '--concurrency[Concurrency]:concurrency:' \\
+            '--aspect-ratio[Aspect ratio]:ratio:' \\
+            '--duration[Duration]:seconds:' \\
+            '--no-preview[Disable inline video frame preview]' \\
+            '-q[Quiet]' \\
+            '--quiet[Quiet]' \\
+            '--json[JSON output]' \\
+            '*:prompt:'
+          ;;
+        models)
+          _arguments \\
+            '--type[Filter by type]:type:(text image video)' \\
+            '--provider[Filter by provider]:provider:' \\
+            '--json[JSON output]'
+          ;;
+        completions)
+          _arguments '1:shell:(zsh bash fish)'
+          ;;
+      esac
+      ;;
+  esac
+}
+
+_ai "$@"
+`;
+}
+
+function generateBash(): string {
+  return `_ai_completions() {
+  local cur prev subcmd
+  COMPREPLY=()
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  prev="\${COMP_WORDS[COMP_CWORD-1]}"
+  subcmd="\${COMP_WORDS[1]}"
+
+  if [[ \${COMP_CWORD} -eq 1 ]]; then
+    COMPREPLY=($(compgen -W "${SUBCOMMANDS.join(" ")}" -- "$cur"))
+    return
+  fi
+
+  case "$prev" in
+    -m|--model)
+      COMPREPLY=($(compgen -W "${ALL_MODELS.join(" ")} ${MODEL_NAMES.join(" ")}" -- "$cur"))
+      return
+      ;;
+    -o|--output)
+      COMPREPLY=($(compgen -f -- "$cur"))
+      return
+      ;;
+    -f|--format)
+      COMPREPLY=($(compgen -W "md txt" -- "$cur"))
+      return
+      ;;
+    --quality)
+      COMPREPLY=($(compgen -W "standard hd" -- "$cur"))
+      return
+      ;;
+    --style)
+      COMPREPLY=($(compgen -W "vivid natural" -- "$cur"))
+      return
+      ;;
+    --type)
+      COMPREPLY=($(compgen -W "text image video" -- "$cur"))
+      return
+      ;;
+  esac
+
+  case "$subcmd" in
+    text)
+      COMPREPLY=($(compgen -W "${[...GLOBAL_FLAGS, ...TEXT_FLAGS].join(" ")}" -- "$cur"))
+      ;;
+    image)
+      COMPREPLY=($(compgen -W "${[...GLOBAL_FLAGS, ...IMAGE_FLAGS].join(" ")}" -- "$cur"))
+      ;;
+    video)
+      COMPREPLY=($(compgen -W "${[...GLOBAL_FLAGS, ...VIDEO_FLAGS].join(" ")}" -- "$cur"))
+      ;;
+    models)
+      COMPREPLY=($(compgen -W "${MODEL_FLAGS.join(" ")}" -- "$cur"))
+      ;;
+    completions)
+      COMPREPLY=($(compgen -W "zsh bash fish" -- "$cur"))
+      ;;
+  esac
+}
+
+complete -F _ai_completions ai
+`;
+}
+
+function generateFish(): string {
+  const lines: string[] = [];
+  lines.push("# ai completions for fish");
+  lines.push("");
+
+  for (const sub of SUBCOMMANDS) {
+    lines.push(`complete -c ai -n '__fish_use_subcommand' -a '${sub}'`);
+  }
+  lines.push("");
+
+  const SHORT_FLAG_MAP: Record<string, string> = {
+    "--model": "m",
+    "--output": "o",
+    "--count": "n",
+    "--concurrency": "p",
+    "--quiet": "q",
+    "--format": "f",
+    "--system": "s",
+    "--temperature": "t",
+  };
+
+  const addFlags = (sub: string, flags: string[]) => {
+    for (const flag of flags) {
+      const name = flag.replace(/^--/, "");
+      const short = SHORT_FLAG_MAP[flag];
+      const shortPart = short ? ` -s ${short}` : "";
+      lines.push(
+        `complete -c ai -n '__fish_seen_subcommand_from ${sub}'${shortPart} -l '${name}'`
+      );
+    }
+  };
+
+  addFlags("text", [...GLOBAL_FLAGS, ...TEXT_FLAGS]);
+  addFlags("image", [...GLOBAL_FLAGS, ...IMAGE_FLAGS]);
+  addFlags("video", [...GLOBAL_FLAGS, ...VIDEO_FLAGS]);
+  addFlags("models", MODEL_FLAGS);
+
+  lines.push("");
+  lines.push(
+    `complete -c ai -n '__fish_seen_subcommand_from completions' -a 'zsh bash fish'`
+  );
+  lines.push("");
+
+  const modelCompletions = ALL_MODELS.concat(MODEL_NAMES);
+  lines.push(
+    `complete -c ai -n '__fish_seen_subcommand_from text image video' -s m -l model -a '${modelCompletions.join(" ")}'`
+  );
+  lines.push(
+    `complete -c ai -n '__fish_seen_subcommand_from text' -s f -l format -a 'md txt'`
+  );
+  lines.push(
+    `complete -c ai -n '__fish_seen_subcommand_from image' -l quality -a 'standard hd'`
+  );
+  lines.push(
+    `complete -c ai -n '__fish_seen_subcommand_from image' -l style -a 'vivid natural'`
+  );
+  lines.push(
+    `complete -c ai -n '__fish_seen_subcommand_from models' -l type -a 'text image video'`
+  );
+  lines.push("");
+
+  return lines.join("\n");
+}

package/src/commands/image.ts

@@ -0,0 +1,132 @@
+import { generateImage, gateway } from "ai";
+import type { Command } from "commander";
+
+import { buildJobs, runJobs } from "../lib/jobs.js";
+import { resolveModels } from "../lib/models.js";
+import { parsePositiveInt, parseSize, parseAspectRatio } from "../lib/parse.js";
+import { readStdin } from "../lib/stdin.js";
+
+const DEFAULT_CONCURRENCY = 4;
+const DEFAULT_TIMEOUT_MS = 120_000;
+
+interface ImageOptions {
+  model?: string;
+  output?: string;
+  count?: string;
+  size?: string;
+  aspectRatio?: string;
+  quality?: string;
+  style?: string;
+  quiet?: boolean;
+  json?: boolean;
+  concurrency?: string;
+  preview?: boolean;
+}
+
+export function registerImageCommand(program: Command) {
+  program
+    .command("image")
+    .description("Generate an image from a prompt")
+    .argument("[prompt]", "The prompt to generate an image 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 images per model (default: 1)")
+    .option("--size <WxH>", "Image size (e.g. 1024x1024)")
+    .option("--aspect-ratio <W:H>", "Aspect ratio (e.g. 16:9)")
+    .option("--quality <level>", "Quality (standard, hd)")
+    .option("--style <style>", "Style (e.g. vivid, natural)")
+    .option("-q, --quiet", "Suppress progress output")
+    .option("--json", "Output metadata as JSON")
+    .option(
+      "--no-preview",
+      "Disable inline image preview in supported terminals"
+    )
+    .option(
+      "-p, --concurrency <n>",
+      `Max parallel generations (default: ${DEFAULT_CONCURRENCY})`
+    )
+    .action(async (rawPrompt: string | undefined, opts: ImageOptions) => {
+      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 imagePrompt: string | { images: Uint8Array[]; text?: string } =
+        prompt!;
+      if (stdin) {
+        imagePrompt = prompt
+          ? { images: [new Uint8Array(stdin)], text: prompt }
+          : { images: [new Uint8Array(stdin)] };
+      }
+
+      const models = resolveModels("image", opts.model);
+      const countPerModel = opts.count
+        ? parsePositiveInt(opts.count, "count")
+        : 1;
+      const size = opts.size ? parseSize(opts.size) : undefined;
+      const aspectRatio = opts.aspectRatio
+        ? parseAspectRatio(opts.aspectRatio)
+        : undefined;
+      const provOpts = buildProviderOptions(opts);
+
+      if (
+        (opts.quality || opts.style) &&
+        models.every((m) => !m.startsWith("openai/"))
+      ) {
+        process.stderr.write(
+          "Warning: --quality and --style only apply to OpenAI models\n"
+        );
+      }
+
+      const jobs = buildJobs(models, countPerModel);
+
+      const { total, failed } = await runJobs(
+        jobs,
+        async (modelId) => {
+          const abort = AbortSignal.timeout(DEFAULT_TIMEOUT_MS);
+          const result = await generateImage({
+            model: gateway.image(modelId),
+            prompt: imagePrompt,
+            abortSignal: abort,
+            n: 1,
+            size,
+            aspectRatio,
+            providerOptions:
+              Object.keys(provOpts).length > 0 ? provOpts : undefined,
+          });
+          return Buffer.from(result.image.uint8Array);
+        },
+        {
+          noun: "image",
+          format: "image",
+          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);
+    });
+}
+
+function buildProviderOptions(
+  opts: ImageOptions
+): Record<string, Record<string, string>> {
+  const providerOptions: Record<string, Record<string, string>> = {};
+  if (opts.quality || opts.style) {
+    providerOptions.openai = {};
+    if (opts.quality) providerOptions.openai.quality = opts.quality;
+    if (opts.style) providerOptions.openai.style = opts.style;
+  }
+  return providerOptions;
+}