@tavily/cli 0.0.0-stage → 1.0.0

package/dist/chunk-E4N27QWM.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+
+// src/ui/theme.ts
+import pc from "picocolors";
+var AQUA = "#5CD9E6";
+var PINK = "#FAA2FB";
+var YELLOW = "#FFC769";
+var PURPLE = "#8385F9";
+var GREEN = "#9BC0AE";
+function colorEnabled(env = process.env) {
+  if (env.NO_COLOR || env.FORCE_COLOR === "0") return false;
+  return Boolean(env.FORCE_COLOR) || process.stdout.isTTY === true;
+}
+function paint(color, s) {
+  if (!colorEnabled()) return s;
+  const [r, g, b] = [1, 3, 5].map((i) => Number.parseInt(color.slice(i, i + 2), 16));
+  const cube = (c) => Math.round(c / 255 * 5);
+  const code = ["truecolor", "24bit"].includes(process.env.COLORTERM ?? "") ? `38;2;${r};${g};${b}` : `38;5;${16 + 36 * cube(r) + 6 * cube(g) + cube(b)}`;
+  return `\x1B[${code}m${s}\x1B[39m`;
+}
+var colors = {
+  aqua: (s) => paint(AQUA, s),
+  pink: (s) => paint(PINK, s),
+  yellow: (s) => paint(YELLOW, s),
+  purple: (s) => paint(PURPLE, s),
+  green: (s) => paint(GREEN, s),
+  dim: (s) => pc.createColors(colorEnabled()).dim(s),
+  bold: (s) => pc.createColors(colorEnabled()).bold(s)
+};
+var LOGO = [
+  colors.aqua("   _              _ _       "),
+  colors.pink("  | |_ __ ___   _(_) |_   _ "),
+  colors.yellow("  | __/ _` \\ \\ / / | | | | |"),
+  colors.purple("  | || (_| |\\ V /| | | |_| |"),
+  colors.green("   \\__\\__,_| \\_/ |_|_|\\__, |"),
+  colors.dim("                       |___/ ")
+].join("\n");
+function out(line = "") {
+  process.stdout.write(`${line}
+`);
+}
+function err(line = "") {
+  process.stderr.write(`${line}
+`);
+}
+
+export {
+  colorEnabled,
+  colors,
+  LOGO,
+  out,
+  err
+};

package/dist/chunk-HQ7QBZ5H.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+// src/core/agent-names.ts
+var AGENT_NAMES = ["claude-code", "codex", "cursor"];
+
+export {
+  AGENT_NAMES
+};

package/dist/chunk-IRCF6F3S.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+
+// src/commands/options.ts
+import { InvalidArgumentError, Option } from "commander";
+function resolveJson(cmd) {
+  return cmd.optsWithGlobals().json === true;
+}
+function addClientNameOption(cmd) {
+  return cmd.addOption(
+    new Option("--client-name <name>", "Set optional client_name for request attribution.").env(
+      "TAVILY_CLIENT_NAME"
+    )
+  );
+}
+function addOutputOption(cmd) {
+  return cmd.addOption(
+    new Option(
+      "-o, --output [file]",
+      "Save the full JSON response to this file. With no value, save it under .tavily/ with a generated name."
+    ).preset("")
+  );
+}
+function addCommonOptions(cmd) {
+  return addClientNameOption(addOutputOption(cmd));
+}
+function parseNumberArg(raw, opts = {}) {
+  const n = raw.trim() === "" ? Number.NaN : Number(raw);
+  if (Number.isNaN(n)) throw new InvalidArgumentError("Not a number.");
+  if (opts.integer && !Number.isInteger(n)) throw new InvalidArgumentError("Not an integer.");
+  if (opts.minimum !== void 0 && n < opts.minimum) {
+    throw new InvalidArgumentError(`${n} is below the minimum ${opts.minimum}.`);
+  }
+  if (opts.maximum !== void 0 && n > opts.maximum) {
+    throw new InvalidArgumentError(`${n} is above the maximum ${opts.maximum}.`);
+  }
+  return n;
+}
+
+export {
+  resolveJson,
+  addClientNameOption,
+  addOutputOption,
+  addCommonOptions,
+  parseNumberArg
+};

package/dist/chunk-K76OUMXM.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+import {
+  isTerminal
+} from "./chunk-QHWWSCVM.js";
+
+// src/ui/spinner.ts
+var FRAMES = "\u280B\u2819\u2839\u2838\u283C\u2834\u2826\u2827\u2807\u280F";
+var INTERVAL_MS = 80;
+function spinner(message, enabled) {
+  const stream = process.stderr;
+  if (!enabled || !isTerminal(stream)) return { update() {
+  }, stop() {
+  } };
+  let frame = 0;
+  const draw = () => stream.write(`\r${FRAMES[frame++ % FRAMES.length]} ${message}`);
+  draw();
+  const timer = setInterval(draw, INTERVAL_MS);
+  let stopped = false;
+  return {
+    update(next) {
+      message = next;
+    },
+    stop() {
+      if (stopped) return;
+      stopped = true;
+      clearInterval(timer);
+      stream.write("\r\x1B[2K");
+    }
+  };
+}
+async function withSpinner(message, enabled, fn) {
+  const s = spinner(message, enabled);
+  try {
+    return await fn();
+  } finally {
+    s.stop();
+  }
+}
+
+export {
+  spinner,
+  withSpinner
+};

package/dist/chunk-KQFC5TMG.js

@@ -0,0 +1,380 @@
+#!/usr/bin/env node
+import {
+  getApiKeyOrExit
+} from "./chunk-U3B7BNFI.js";
+import {
+  withSpinner
+} from "./chunk-K76OUMXM.js";
+import {
+  plain,
+  safeLink,
+  sanitizeControl
+} from "./chunk-QHWWSCVM.js";
+import {
+  parseNumberArg,
+  resolveJson
+} from "./chunk-IRCF6F3S.js";
+import {
+  colors,
+  err,
+  out
+} from "./chunk-E4N27QWM.js";
+import {
+  ExitError,
+  isObject,
+  messageOf
+} from "./chunk-5JXZZSLS.js";
+
+// src/ui/render/emit.ts
+import { randomBytes } from "crypto";
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import path from "path";
+var DEFAULT_OUTPUT_DIR = ".tavily";
+var list = (value) => Array.isArray(value) ? value : [];
+function emit(data, opts) {
+  const text = JSON.stringify(data, null, opts.pretty ? 2 : void 0);
+  if (!opts.outputFile) {
+    out(text);
+    return;
+  }
+  const folder = path.dirname(opts.outputFile);
+  if (!existsSync(folder)) {
+    mkdirSync(folder, { recursive: true });
+    if (path.basename(path.normalize(folder)) === DEFAULT_OUTPUT_DIR) {
+      writeFileSync(path.join(folder, ".gitignore"), "*\n");
+    }
+  }
+  writeFileSync(opts.outputFile, `${text}
+`);
+  err(`Output saved to ${opts.outputFile}`);
+}
+function emitIfRequested(data, opts) {
+  if (!opts.json && !opts.outputFile) return false;
+  emit(data, { outputFile: opts.outputFile, pretty: true });
+  return true;
+}
+function footer(count, unit, responseTime) {
+  const parts = [`${count} ${unit}`];
+  if (typeof responseTime === "number" && responseTime) parts.push(`${responseTime.toFixed(2)}s`);
+  const label = ` ${parts.join(" | ")} `;
+  const fill = Math.max(0, (process.stdout.columns ?? 80) - label.length);
+  const left = Math.floor(fill / 2);
+  out();
+  out(colors.dim(`${"\u2500".repeat(left)}${label}${"\u2500".repeat(fill - left)}`));
+}
+function echoPages(pages) {
+  for (const page of pages) {
+    out(`# ${plain(page.url ?? "")}
+`);
+    out(`${plain(page.raw_content || "(no content)")}
+`);
+  }
+}
+var pad = (n) => String(n).padStart(2, "0");
+function resolveOutput(outputFile, command, label, now = /* @__PURE__ */ new Date(), random = () => randomBytes(3).toString("hex")) {
+  if (outputFile !== "") return outputFile;
+  const slug = (String(label).toLowerCase().match(/[a-z0-9]+/g) ?? []).join("-").slice(0, 40).replace(/^-+|-+$/g, "") || "result";
+  const time = `${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
+  return path.join(DEFAULT_OUTPUT_DIR, `${command}-${slug}-${time}-${random()}.json`);
+}
+
+// src/ui/keyless.ts
+function formatSeconds(seconds) {
+  if (seconds < 60) return `${seconds}s`;
+  if (seconds < 3600) {
+    const m = Math.floor(seconds / 60);
+    const s = seconds % 60;
+    return s ? `${m}m ${s}s` : `${m}m`;
+  }
+  if (seconds < 86400) {
+    const h2 = Math.floor(seconds / 3600);
+    const m = Math.floor(seconds % 3600 / 60);
+    return m ? `${h2}h ${m}m` : `${h2}h`;
+  }
+  const d = Math.floor(seconds / 86400);
+  const h = Math.floor(seconds % 86400 / 3600);
+  return h ? `${d}d ${h}h` : `${d}d`;
+}
+var orDefault = (value, fallback) => value ? String(value) : fallback;
+function keylessCapError(e) {
+  return {
+    code: e.capType,
+    message: e.message,
+    window: e.window,
+    retry_after_seconds: e.retryAfter,
+    next_actions: e.continuationPaths
+  };
+}
+function printKeylessCapHit(e) {
+  err();
+  sanitizeControl(formatKeylessEnvelopeForTerminal(e)).split("\n").forEach((line, i) => {
+    if (i === 0) err(`  ${colors.yellow(">")} ${colors.bold(line)}`);
+    else err(line ? `    ${line}` : "");
+  });
+  err();
+  err(
+    `  ${colors.dim("Run ")}${colors.green("tvly login")}${colors.dim(" to authenticate and remove this cap.")}`
+  );
+  err();
+}
+function formatKeylessEnvelopeForTerminal(e) {
+  const lines = ["Tavily rate limit reached."];
+  if (e.message.trim()) lines.push(e.message.trim());
+  const retry = e.retryAfter;
+  if (typeof retry === "number" && Number.isInteger(retry) && retry > 0) {
+    lines.push("", `Retry after: ${formatSeconds(retry)} (${retry}s)`);
+  }
+  const actions = e.continuationPaths.filter(isObject);
+  const last = (type) => [...actions].reverse().find((a) => a.type === type);
+  const signup = last("signup");
+  const payment = last("agentic_payment");
+  const bonus = last("bonus_credits");
+  if (signup || payment || bonus) {
+    lines.push("", "Continuation options:");
+    if (signup) {
+      lines.push(
+        `  - Sign up for a Tavily API key:  ${orDefault(signup.resource, "https://tavily.com")}`
+      );
+      if (signup.instruction) lines.push(`      ${signup.instruction}`);
+    }
+    if (payment) {
+      const label = `  - Pay via ${orDefault(payment.scheme, "x402")} agentic payment`;
+      const resource = payment.resource;
+      lines.push(resource ? `${label}:  ${resource}` : label);
+      if (payment.instruction) lines.push(`      ${payment.instruction}`);
+    }
+    if (bonus) {
+      const params = isObject(bonus.params) ? bonus.params : {};
+      const questions = Array.isArray(params.questions) ? params.questions : [];
+      if (questions.length > 0) {
+        const credits = params.credits_on_completion;
+        const noun = `${questions.length} question${questions.length !== 1 ? "s" : ""}`;
+        lines.push(
+          typeof credits === "number" && Number.isInteger(credits) ? `  - Earn ${credits} bonus credits by answering ${noun}:` : `  - Earn bonus credits by answering ${noun}:`
+        );
+        questions.forEach((q, i) => {
+          if (typeof q === "string") lines.push(`      ${i + 1}. ${q}`);
+        });
+        lines.push(`    POST your answers to: ${orDefault(bonus.resource, "/v1/keyless/bonus")}`);
+      }
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/commands/invoke.ts
+import { TavilyKeylessLimitError, TavilyRequestError } from "@tavily/core";
+var LIMIT_STATUSES = /* @__PURE__ */ new Set([429, 432]);
+var AUTH_STATUSES = /* @__PURE__ */ new Set([401, 403]);
+async function invoke(cmd, host, opts, fn) {
+  const json = resolveJson(cmd);
+  const key = await getApiKeyOrExit(json, host);
+  if (opts.keyed && !key) requireKey(opts.keyed);
+  const client = await host.resolveClient(key, opts.clientName);
+  try {
+    const { label } = opts;
+    return label === void 0 ? await fn(client) : await withSpinner(label, !json, () => fn(client));
+  } catch (e) {
+    if (e instanceof ExitError) throw e;
+    if (e instanceof TavilyKeylessLimitError) {
+      if (json) out(JSON.stringify({ error: keylessCapError(e) }));
+      else printKeylessCapHit(e);
+      throw new ExitError(3);
+    }
+    return handleApiError(e, json);
+  }
+}
+function requireKey(command) {
+  err();
+  err(`  ${colors.pink(">")} The ${colors.bold(command)} command requires a Tavily API key.`);
+  err();
+  err(`  Sign up for a free key at ${safeLink("https://tavily.com")}`);
+  err(
+    `  Then run ${colors.green("tvly login")} or ${colors.green("tvly login --api-key tvly-YOUR_KEY")}`
+  );
+  err();
+  err(
+    colors.dim(
+      `  Tip: ${colors.green("tvly search")} and ${colors.green("tvly extract")} work without an API key (subject to a rate-limit cap).`
+    )
+  );
+  err();
+  throw new ExitError(3);
+}
+function handleApiError(e, json) {
+  const limit = e instanceof TavilyRequestError && LIMIT_STATUSES.has(e.status);
+  const code = limit || e instanceof TavilyRequestError && AUTH_STATUSES.has(e.status) ? 3 : 4;
+  if (json) {
+    out(JSON.stringify({ error: messageOf(e) }));
+    throw new ExitError(code);
+  }
+  const text = sanitizeControl(messageOf(e));
+  if (limit) {
+    err();
+    err(`  ${colors.yellow(">")} ${text}`);
+    err();
+    err(
+      `  ${colors.dim("Upgrade your plan at")} ${colors.green(safeLink("https://tavily.com", "tavily.com"))}`
+    );
+    err();
+    throw new ExitError(3);
+  }
+  err(`  ${colors.pink("> Error:")} ${text}`);
+  throw new ExitError(code);
+}
+
+// src/core/search-flags.ts
+import { searchParameters } from "@tavily/core/parameters";
+import { InvalidArgumentError, Option } from "commander";
+var SEARCH_FLAG_OVERRIDES = {
+  query: { positional: true },
+  searchDepth: { flag: "depth" },
+  includeAnswer: { bareValue: "basic" },
+  includeRawContent: { bareValue: "markdown" }
+};
+var PYTHON_ORDER = [
+  "searchDepth",
+  "maxResults",
+  "topic",
+  "timeRange",
+  "startDate",
+  "endDate",
+  "includeDomains",
+  "excludeDomains",
+  "country",
+  "includeAnswer",
+  "includeRawContent",
+  "includeImages",
+  "includeImageDescriptions",
+  "chunksPerSource"
+];
+var kebab = (key) => key.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
+var snake = (key) => key.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+function checkChoice(raw, choices) {
+  if (!choices.includes(raw)) {
+    throw new InvalidArgumentError(`Allowed choices are ${choices.join(", ")}.`);
+  }
+  return raw;
+}
+function toSpec(key, def) {
+  const override = SEARCH_FLAG_OVERRIDES[key] ?? {};
+  const flag = `--${override.flag ?? kebab(key)}`;
+  const base = { key, description: def.description };
+  if (Array.isArray(def.type)) {
+    const values = "enum" in def ? def.enum : [];
+    const choices = [
+      ...values.filter((v) => typeof v === "string"),
+      ...values.filter((v) => typeof v === "boolean")
+    ].map(String);
+    return {
+      ...base,
+      flags: `${flag} [value]`,
+      choices,
+      parse: (raw) => {
+        const value = checkChoice(raw === true ? override.bareValue ?? "true" : raw, choices);
+        return value === "true" ? true : value === "false" ? false : value;
+      }
+    };
+  }
+  switch (def.type) {
+    case "boolean":
+      return { ...base, flags: flag, parse: () => true };
+    case "array":
+      return {
+        ...base,
+        flags: `${flag} <list>`,
+        parse: (raw) => String(raw).split(",").map((s) => s.trim()).filter(Boolean)
+      };
+    case "integer":
+    case "number":
+      return {
+        ...base,
+        flags: `${flag} <n>`,
+        parse: (raw) => parseNumberArg(String(raw), {
+          integer: def.type === "integer",
+          ...def.minimum !== void 0 ? { minimum: def.minimum } : {},
+          ...def.maximum !== void 0 ? { maximum: def.maximum } : {}
+        })
+      };
+    default: {
+      const choices = "enum" in def ? def.enum.map(String) : void 0;
+      return {
+        ...base,
+        flags: `${flag} <value>`,
+        ...choices ? { choices } : {},
+        parse: (raw) => choices ? checkChoice(String(raw), choices) : String(raw)
+      };
+    }
+  }
+}
+function searchFlagSpecs() {
+  const keys = Object.keys(searchParameters).filter(
+    (key) => !SEARCH_FLAG_OVERRIDES[key]?.positional
+  );
+  const specs = keys.map((key) => toSpec(key, searchParameters[key]));
+  const rank = (s) => PYTHON_ORDER.indexOf(s.key);
+  const python = specs.filter((s) => rank(s) >= 0).sort((a, b) => rank(a) - rank(b));
+  const rest = specs.filter((s) => rank(s) < 0).sort((a, b) => a.flags < b.flags ? -1 : 1);
+  return [...python, ...rest];
+}
+function applySearchFlags(cmd) {
+  for (const spec of searchFlagSpecs()) {
+    const option = new Option(spec.flags, spec.description);
+    if (spec.choices) option.choices(spec.choices);
+    if (!option.isBoolean()) option.argParser((raw) => spec.parse(raw));
+    const bareValue = SEARCH_FLAG_OVERRIDES[spec.key]?.bareValue;
+    if (bareValue !== void 0) option.preset(bareValue);
+    option.attributeName = () => spec.key;
+    cmd.addOption(option);
+  }
+  return cmd;
+}
+function searchBodyFromOptions(opts) {
+  const body = {};
+  for (const key of Object.keys(searchParameters)) {
+    const value = opts[key];
+    if (value === void 0 || Array.isArray(value) && value.length === 0) continue;
+    body[snake(key)] = value;
+  }
+  return body;
+}
+
+// src/commands/shared.ts
+import { readFileSync } from "fs";
+function splitCsv(value) {
+  return value ? value.split(",").map((part) => part.trim()) : void 0;
+}
+function definedSnake(opts, keys) {
+  const body = {};
+  for (const key of keys) {
+    const value = opts[key];
+    if (value !== void 0) body[snake(key)] = value;
+  }
+  return body;
+}
+var MAX_STDIN_CHARS = 1e5;
+var QUERY_REQUIRED = "error: QUERY is required. Pass a query string or use '-' to read from stdin.";
+function readQueryArg(query, cmd) {
+  const value = (query === "-" ? readFileSync(0, "utf8").slice(0, MAX_STDIN_CHARS) : query ?? "").trim();
+  if (!value) cmd.error(QUERY_REQUIRED);
+  return value;
+}
+
+export {
+  list,
+  emit,
+  emitIfRequested,
+  footer,
+  echoPages,
+  resolveOutput,
+  keylessCapError,
+  printKeylessCapHit,
+  LIMIT_STATUSES,
+  invoke,
+  applySearchFlags,
+  searchBodyFromOptions,
+  splitCsv,
+  definedSnake,
+  QUERY_REQUIRED,
+  readQueryArg
+};