ai-cli 0.0.13 → 0.1.1

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,136 @@
+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

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