ai-cli 0.1.1 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-cli",
-  "version": "0.1.1",
+  "version": "0.2.1",
   "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",
@@ -8,11 +8,14 @@
     "type": "git",
     "url": "https://github.com/vercel-labs/ai-cli.git"
   },
+  "engines": {
+    "node": ">=20"
+  },
   "bin": {
-    "ai": "./src/index.ts"
+    "ai": "./dist/index.js"
   },
   "files": [
-    "src",
+    "dist",
     "README.md"
   ],
   "keywords": [
@@ -27,13 +30,14 @@
   ],
   "scripts": {
     "dev": "bun run src/index.ts",
-    "build": "bun build src/index.ts --compile --outfile=dist/ai",
+    "clean": "bun -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\"",
+    "build": "bun run clean && bun build src/index.ts --target=node --outdir=dist",
     "typecheck": "tsc --noEmit",
     "format": "oxfmt --write src/",
     "format:check": "oxfmt --check src/",
     "lint": "oxlint src/",
     "test": "bun test",
-    "prepublishOnly": "bun run typecheck"
+    "prepack": "bun run typecheck && bun run build"
   },
   "dependencies": {
     "ai": "^6.0.173",

package/src/cli.test.ts

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

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

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

package/src/commands/models.ts

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