@inferall/cli 0.2.0

package/README.md

@@ -0,0 +1,55 @@
+# @inferall/cli
+
+Install [InferAll](https://inferall.ai) into your project in one command:
+
+```bash
+npx @inferall/cli init
+```
+
+The wizard:
+
+1. **Detects your project** — Node or Python, and whether you already use the
+   `openai`, `@anthropic-ai/sdk`, or `@google/generative-ai` SDKs.
+2. **Sets up your key** — writes `INFERALL_API_KEY` to `.env`, adds a
+   placeholder to `.env.example`, and makes sure `.env` is gitignored.
+3. **Migrates existing code** — points `OpenAI` and `Anthropic` client
+   constructors at the InferAll gateway (the OpenAI SDK gets
+   `https://api.inferall.ai/v1`; the Anthropic SDK gets the host root since it
+   appends `/v1/messages` itself). Simple constructors are rewritten
+   deterministically; anything ambiguous gets an AI-suggested patch (generated
+   by InferAll's own $0 NIM models — the wizard dogfoods the gateway) that you
+   review before it's applied. Google Gemini SDK usage is detected too — that
+   SDK speaks its own protocol, so instead of a risky rewrite you get the exact
+   OpenAI-compat snippet (`model: "gemini/gemini-2.5-flash"`) to migrate at
+   your own pace.
+4. **Verifies with a live call** — and if your account isn't activated yet, it
+   says exactly that, with the link, instead of failing opaquely.
+
+## Commands
+
+- `init` — the wizard above (default).
+- `doctor` — health-check an existing setup: key present + valid, `.env`
+  gitignore hygiene, whether every client call site points at the gateway, and
+  a live call that reports your real account state (active vs `$5` activation
+  pending). Exit code 0 only when everything passes — CI-friendly.
+- `models` — the live model list with real prices, straight from the gateway.
+  `--free` shows only the $0 models; `--json` gives the raw pricing map.
+- `status` — your account state from the key's point of view: tier, activation,
+  balance, trial calls remaining, and what the free models saved you this week.
+  The fast answer to "did my payment land?"
+
+## Flags
+
+| Flag | Effect |
+| --- | --- |
+| `--key ifu_...` | Skip the key prompt |
+| `--yes` / `-y` | Accept all defaults (non-interactive) |
+| `--no-ai` | Deterministic codemod only, no AI-suggested patches |
+
+## Why this exists
+
+Most gateways make you read docs to change one line. This makes the one-line
+change for you, tells you the truth about the $5 activation gate, and leaves
+your code otherwise untouched — no reformatting, no renames.
+
+Zero runtime dependencies. Node 18+.

package/bin/inferall.js

@@ -0,0 +1,635 @@
+#!/usr/bin/env node
+// InferAll install wizard — `npx @inferall/cli init`
+//
+// Gets a project from zero to a working InferAll call in one command:
+//   1. Detects the project (Node / Python) and any existing AI SDK usage.
+//   2. Sets up INFERALL_API_KEY in .env (+ .env.example, .gitignore).
+//   3. Points existing OpenAI-SDK call sites at the InferAll gateway
+//      (deterministic codemod; AI-assisted patch suggestions for call
+//      sites the codemod can't confidently rewrite — powered by
+//      InferAll's own $0 NIM models, so the wizard dogfoods the product).
+//   4. Verifies with a live call and explains exactly what state the
+//      account is in (including the $5 activation gate) instead of
+//      failing opaquely.
+//
+// Zero runtime dependencies. Node 18+ (built-in fetch).
+
+import { createInterface } from "node:readline/promises";
+import { stdin, stdout, exit, argv, env, cwd } from "node:process";
+import {
+  readFileSync,
+  writeFileSync,
+  appendFileSync,
+  existsSync,
+  readdirSync,
+  statSync,
+} from "node:fs";
+import { join, relative, extname } from "node:path";
+
+const API_BASE = env.INFERALL_API_BASE || "https://api.inferall.ai/v1";
+// The Anthropic SDK appends /v1/messages itself, so its baseURL is the host root.
+const ANTHROPIC_BASE = API_BASE.replace(/\/v1$/, "");
+const KEYS_URL = "https://inferall.ai/keys";
+const BILLING_URL = "https://inferall.ai/billing?src=cli_init";
+const FREE_MODEL = "meta/llama-3.1-8b-instruct";
+
+const c = {
+  dim: (s) => `\x1b[2m${s}\x1b[0m`,
+  bold: (s) => `\x1b[1m${s}\x1b[0m`,
+  green: (s) => `\x1b[32m${s}\x1b[0m`,
+  yellow: (s) => `\x1b[33m${s}\x1b[0m`,
+  red: (s) => `\x1b[31m${s}\x1b[0m`,
+  cyan: (s) => `\x1b[36m${s}\x1b[0m`,
+};
+
+const args = argv.slice(2);
+const cmd = args.find((a) => !a.startsWith("-")) || "init";
+const flag = (name) => args.includes(`--${name}`);
+const flagValue = (name) => {
+  const i = args.indexOf(`--${name}`);
+  return i >= 0 && args[i + 1] && !args[i + 1].startsWith("-") ? args[i + 1] : undefined;
+};
+const YES = flag("yes") || flag("y");
+const NO_AI = flag("no-ai");
+
+const rl = createInterface({ input: stdin, output: stdout });
+async function ask(q, fallback) {
+  if (YES) return fallback ?? "y";
+  const a = (await rl.question(q)).trim();
+  return a === "" ? (fallback ?? "") : a;
+}
+async function confirm(q, defaultYes = true) {
+  const hint = defaultYes ? "Y/n" : "y/N";
+  const a = (await ask(`${q} ${c.dim(`[${hint}]`)} `, defaultYes ? "y" : "n")).toLowerCase();
+  return defaultYes ? a !== "n" : a === "y";
+}
+
+// ---------- project detection ----------
+
+function detectProject(root) {
+  const p = { root, kind: null, sdks: [], pkg: null };
+  const pkgPath = join(root, "package.json");
+  if (existsSync(pkgPath)) {
+    p.kind = "node";
+    try {
+      p.pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+      const deps = { ...p.pkg.dependencies, ...p.pkg.devDependencies };
+      for (const name of ["openai", "@anthropic-ai/sdk", "@google/generative-ai", "@google/genai", "ai", "@inferall/sdk"]) {
+        if (deps?.[name]) p.sdks.push(name);
+      }
+    } catch {
+      /* unparseable package.json — treat as bare node */
+    }
+  } else if (existsSync(join(root, "pyproject.toml")) || existsSync(join(root, "requirements.txt"))) {
+    p.kind = "python";
+    const reqs = ["pyproject.toml", "requirements.txt"]
+      .filter((f) => existsSync(join(root, f)))
+      .map((f) => readFileSync(join(root, f), "utf8"))
+      .join("\n");
+    for (const name of ["openai", "anthropic", "google-generativeai", "google-genai", "inferall-ai"]) {
+      if (new RegExp(`^\\s*"?${name}`, "m").test(reqs)) p.sdks.push(name);
+    }
+  }
+  return p;
+}
+
+// ---------- env / key setup ----------
+
+function upsertEnvFile(root, key) {
+  const envPath = join(root, ".env");
+  const line = `INFERALL_API_KEY=${key}`;
+  if (existsSync(envPath)) {
+    const body = readFileSync(envPath, "utf8");
+    if (/^INFERALL_API_KEY=/m.test(body)) {
+      writeFileSync(envPath, body.replace(/^INFERALL_API_KEY=.*$/m, line));
+    } else {
+      appendFileSync(envPath, `${body.endsWith("\n") || body === "" ? "" : "\n"}${line}\n`);
+    }
+  } else {
+    writeFileSync(envPath, `${line}\n`);
+  }
+
+  const examplePath = join(root, ".env.example");
+  const exampleLine = "INFERALL_API_KEY=ifu_your_key_here";
+  if (existsSync(examplePath)) {
+    const body = readFileSync(examplePath, "utf8");
+    if (!/^INFERALL_API_KEY=/m.test(body)) {
+      appendFileSync(examplePath, `${body.endsWith("\n") || body === "" ? "" : "\n"}${exampleLine}\n`);
+    }
+  } else {
+    writeFileSync(examplePath, `${exampleLine}\n`);
+  }
+
+  const giPath = join(root, ".gitignore");
+  if (existsSync(giPath)) {
+    const gi = readFileSync(giPath, "utf8");
+    if (!gi.split("\n").some((l) => l.trim() === ".env" || l.trim() === ".env*" || l.trim() === "*.env")) {
+      appendFileSync(giPath, `${gi.endsWith("\n") ? "" : "\n"}.env\n`);
+      console.log(`  ${c.green("+")} added ${c.bold(".env")} to .gitignore`);
+    }
+  } else {
+    writeFileSync(giPath, ".env\n");
+    console.log(`  ${c.green("+")} created .gitignore with .env`);
+  }
+}
+
+// ---------- gateway API helpers ----------
+
+async function apiGet(path, key) {
+  const res = await fetch(`${API_BASE}${path}`, {
+    headers: { Authorization: `Bearer ${key}` },
+  });
+  return { status: res.status, body: await res.json().catch(() => ({})) };
+}
+
+async function apiChat(key, messages, model = FREE_MODEL) {
+  const res = await fetch(`${API_BASE}/chat/completions`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${key}`, "Content-Type": "application/json" },
+    body: JSON.stringify({ model, messages, max_tokens: 512 }),
+  });
+  return { status: res.status, body: await res.json().catch(() => ({})) };
+}
+
+// ---------- codemod: point OpenAI SDK at InferAll ----------
+
+const SOURCE_EXTS = new Set([".js", ".mjs", ".cjs", ".ts", ".tsx", ".jsx", ".py"]);
+const SKIP_DIRS = new Set(["node_modules", ".git", ".next", "dist", "build", "venv", ".venv", "__pycache__", ".turbo"]);
+
+function* walk(dir, depth = 0) {
+  if (depth > 6) return;
+  let entries = [];
+  try {
+    entries = readdirSync(dir);
+  } catch {
+    return;
+  }
+  for (const name of entries) {
+    if (SKIP_DIRS.has(name) || name.startsWith(".")) continue;
+    const full = join(dir, name);
+    let st;
+    try {
+      st = statSync(full);
+    } catch {
+      continue;
+    }
+    if (st.isDirectory()) yield* walk(full, depth + 1);
+    else if (st.isFile() && SOURCE_EXTS.has(extname(name)) && st.size < 512 * 1024) yield full;
+  }
+}
+
+function findCallSites(root) {
+  const sites = [];
+  for (const file of walk(root)) {
+    let body;
+    try {
+      body = readFileSync(file, "utf8");
+    } catch {
+      continue;
+    }
+    const isPy = file.endsWith(".py");
+    const baseKey = isPy ? "base_url" : "baseURL";
+    for (const sdk of ["OpenAI", "Anthropic"]) {
+      const ctorRe = isPy ? new RegExp(`\\b${sdk}\\s*\\(`) : new RegExp(`new\\s+${sdk}\\s*\\(`);
+      if (!ctorRe.test(body)) continue;
+      sites.push({
+        file,
+        body,
+        isPy,
+        sdk,
+        alreadyPointed: body.includes(new URL(API_BASE).host),
+        hasBaseUrl: new RegExp(`${baseKey}\\s*[:=]`).test(body),
+      });
+    }
+  }
+  return sites;
+}
+
+// Deterministic rewrite for the common zero-arg / simple-config constructor.
+// The OpenAI SDK's baseURL includes /v1; the Anthropic SDK appends /v1 itself.
+function patchSite(site) {
+  const { body, isPy, sdk } = site;
+  const base = sdk === "Anthropic" ? ANTHROPIC_BASE : API_BASE;
+  const baseLine = isPy
+    ? `base_url="${base}", api_key=os.environ["INFERALL_API_KEY"]`
+    : `baseURL: "${base}", apiKey: process.env.INFERALL_API_KEY`;
+
+  let patched = null;
+  if (isPy) {
+    const bare = new RegExp(`\\b${sdk}\\s*\\(\\s*\\)`);
+    if (bare.test(body)) {
+      patched = body.replace(bare, `${sdk}(${baseLine})`);
+      if (!/^import os$/m.test(patched)) patched = `import os\n${patched}`;
+    }
+  } else {
+    const bare = new RegExp(`new\\s+${sdk}\\s*\\(\\s*\\)`);
+    const obj = new RegExp(`new\\s+${sdk}\\s*\\(\\s*\\{`);
+    if (bare.test(body)) {
+      patched = body.replace(bare, `new ${sdk}({ ${baseLine} })`);
+    } else if (obj.test(body) && !site.hasBaseUrl) {
+      patched = body.replace(obj, `new ${sdk}({ baseURL: "${base}", `);
+    }
+  }
+  return patched;
+}
+
+// Gemini SDKs (@google/generative-ai, @google/genai, google-generativeai) speak
+// their own wire protocol (generateContent), which the gateway doesn't serve —
+// Gemini models are reached through the OpenAI-compat endpoint with a gemini/
+// model prefix. These sites get exact guidance, never a baseURL patch, and no
+// AI rewrite either: a cross-protocol reshape (response shapes differ) is too
+// invasive to automate safely.
+function findGeminiSites(root) {
+  const sites = [];
+  for (const file of walk(root)) {
+    let body;
+    try {
+      body = readFileSync(file, "utf8");
+    } catch {
+      continue;
+    }
+    const isPy = file.endsWith(".py");
+    const hit = isPy
+      ? /\bgenai\.(configure|GenerativeModel|Client)\s*\(/.test(body)
+      : /new\s+(GoogleGenerativeAI|GoogleGenAI)\s*\(/.test(body);
+    if (hit) sites.push({ file, isPy });
+  }
+  return sites;
+}
+
+function printGeminiGuidance(root, sites) {
+  console.log(`\n  ${c.bold("Gemini SDK usage")} found in ${sites.length} file(s):`);
+  for (const s of sites) console.log(`    - ${relative(root, s.file)}`);
+  console.log(`  The Google SDK speaks its own protocol, so it can't be re-pointed with a base URL.`);
+  console.log(`  Gemini models work through InferAll's OpenAI-compatible endpoint instead:`);
+  if (sites.some((s) => s.isPy)) {
+    console.log(c.dim(`    # pip install openai`));
+    console.log(c.cyan(`    ai = OpenAI(base_url="${API_BASE}", api_key=os.environ["INFERALL_API_KEY"])`));
+    console.log(c.cyan(`    ai.chat.completions.create(model="gemini/gemini-2.5-flash", messages=messages)`));
+  } else {
+    console.log(c.dim(`    // npm install openai`));
+    console.log(c.cyan(`    const ai = new OpenAI({ baseURL: "${API_BASE}", apiKey: process.env.INFERALL_API_KEY });`));
+    console.log(c.cyan(`    await ai.chat.completions.create({ model: "gemini/gemini-2.5-flash", messages });`));
+  }
+  console.log(`  Same Gemini models, one ifu_ key, $0 markup — migrate at your own pace.`);
+}
+
+// AI-assisted patch for call sites the deterministic codemod can't handle.
+// Uses the user's own key against a $0 NIM model — the wizard dogfoods the
+// gateway. Returns the suggested full-file replacement, or null.
+async function aiSuggestPatch(key, site) {
+  const base = site.sdk === "Anthropic" ? ANTHROPIC_BASE : API_BASE;
+  const prompt = [
+    {
+      role: "user",
+      content:
+        `Rewrite this ${site.isPy ? "Python" : "JavaScript/TypeScript"} file so the ${site.sdk} SDK client sends requests to the InferAll gateway.\n` +
+        `Rules:\n` +
+        `- Set the client's ${site.isPy ? `base_url to "${base}" and api_key to os.environ["INFERALL_API_KEY"]` : `baseURL to "${base}" and apiKey to process.env.INFERALL_API_KEY`}.\n` +
+        `- Change NOTHING else: no reformatting, no renames, no comment changes.\n` +
+        `- Reply with ONLY the complete rewritten file, no code fences, no commentary.\n\n` +
+        site.body,
+    },
+  ];
+  const { status, body } = await apiChat(key, prompt);
+  if (status !== 200) return { status, patched: null };
+  const text = body?.choices?.[0]?.message?.content;
+  if (!text || Math.abs(text.length - site.body.length) > site.body.length) return { status, patched: null };
+  return { status, patched: text.replace(/^```[a-z]*\n?/, "").replace(/\n?```\s*$/, "") };
+}
+
+// ---------- fresh-install example ----------
+
+function writeExample(root, kind) {
+  if (kind === "python") {
+    const p = join(root, "inferall_hello.py");
+    if (existsSync(p)) return null;
+    writeFileSync(
+      p,
+      `"""InferAll hello — run: python inferall_hello.py (pip install inferall-ai)"""\nfrom inferall import Inferall\n\nai = Inferall()  # reads INFERALL_API_KEY from the environment\nprint(ai.text("Explain InferAll in one sentence."))\n`
+    );
+    return p;
+  }
+  const p = join(root, "inferall-hello.mjs");
+  if (existsSync(p)) return null;
+  writeFileSync(
+    p,
+    `// InferAll hello — run: node --env-file=.env inferall-hello.mjs\nconst res = await fetch("${API_BASE}/chat/completions", {\n  method: "POST",\n  headers: {\n    Authorization: \`Bearer \${process.env.INFERALL_API_KEY}\`,\n    "Content-Type": "application/json",\n  },\n  body: JSON.stringify({\n    model: "${FREE_MODEL}",\n    messages: [{ role: "user", content: "Explain InferAll in one sentence." }],\n  }),\n});\nconsole.log((await res.json()).choices?.[0]?.message?.content ?? (await res.text()));\n`
+  );
+  return p;
+}
+
+// ---------- models ----------
+
+// Pricing lives on the gateway's public metadata endpoint (host root, not the
+// OpenAI-compat surface): { "<id>": { type, inputPerM|perImage|perSecond, … } }.
+function priceLabel(p) {
+  if (p.type === "token") {
+    if (!p.inputPerM && !p.outputPerM) return "$0";
+    return `$${p.inputPerM}/M in · $${p.outputPerM}/M out`;
+  }
+  if (p.perImage != null) return `$${p.perImage}/image`;
+  if (p.perSecond != null) return `$${p.perSecond}/s`;
+  return p.type;
+}
+
+async function modelsCmd() {
+  const res = await fetch(`${ANTHROPIC_BASE}/ai/v1/models`);
+  if (!res.ok) {
+    console.log(`${c.red("✗")} couldn't fetch the model list (HTTP ${res.status})`);
+    rl.close();
+    exit(1);
+  }
+  const map = await res.json();
+  let rows = Object.entries(map).map(([id, p]) => ({
+    id,
+    type: p.type,
+    free: p.type === "token" && !p.inputPerM && !p.outputPerM,
+    price: priceLabel(p),
+    sort: p.type === "token" ? (p.inputPerM || 0) : Infinity,
+  }));
+  if (flag("free")) rows = rows.filter((r) => r.free);
+  if (flag("json")) {
+    console.log(JSON.stringify(flag("free") ? Object.fromEntries(rows.map((r) => [r.id, map[r.id]])) : map, null, 2));
+    rl.close();
+    return;
+  }
+  rows.sort((a, b) => (a.free !== b.free ? (a.free ? -1 : 1) : a.sort - b.sort || a.id.localeCompare(b.id)));
+  const w = Math.min(48, Math.max(...rows.map((r) => r.id.length)) + 2);
+  console.log(`\n${c.bold("MODEL".padEnd(w))}${c.bold("TYPE".padEnd(12))}${c.bold("PRICE")}`);
+  for (const r of rows) {
+    const price = r.free ? c.green("$0") : r.price;
+    console.log(`${r.id.padEnd(w)}${r.type.padEnd(12)}${price}`);
+  }
+  const freeCount = Object.values(map).filter((p) => p.type === "token" && !p.inputPerM && !p.outputPerM).length;
+  console.log(`\n${Object.keys(map).length} models — ${c.green(`${freeCount} at $0`)} (NVIDIA NIM). Use any with your ifu_ key.\n`);
+  rl.close();
+}
+
+// ---------- status ----------
+
+// GET /ai/v1/key/status (host root, API-key auth) — tier, trial counter,
+// balance, savings. Answers "did my payment land?" without opening a browser.
+async function statusCmd() {
+  let key = env.INFERALL_API_KEY || flagValue("key") || "";
+  const envPath = join(cwd(), ".env");
+  if (!key && existsSync(envPath)) {
+    const m = readFileSync(envPath, "utf8").match(/^INFERALL_API_KEY=(.+)$/m);
+    if (m) key = m[1].trim();
+  }
+  if (!key) {
+    console.log(`${c.red("✗")} No key in INFERALL_API_KEY or .env — run ${c.bold("npx @inferall/cli init")}`);
+    rl.close();
+    exit(1);
+  }
+  const res = await fetch(`${ANTHROPIC_BASE}/ai/v1/key/status`, {
+    headers: { Authorization: `Bearer ${key}` },
+  });
+  if (!res.ok) {
+    console.log(`${c.red("✗")} status check failed (HTTP ${res.status}) — check the key at ${KEYS_URL}`);
+    rl.close();
+    exit(1);
+  }
+  const s = await res.json();
+  console.log(`\n${c.bold("InferAll account status")} ${c.dim(`(key ${key.slice(0, 8)}…)`)}\n`);
+  if (s.project) {
+    console.log(`  tier: ${c.cyan(s.tier)} ${c.dim("(project key — billed separately, no trial counter)")}\n`);
+    rl.close();
+    return;
+  }
+  const active = s.has_paid_successfully;
+  console.log(`  tier:      ${c.cyan(s.tier)}`);
+  console.log(`  activated: ${active ? c.green("yes") : c.yellow("not yet")}${!active && s.has_card ? c.dim(" (checkout started, not settled)") : ""}`);
+  console.log(`  balance:   ${s.balance_usd > 0 ? c.green(`$${s.balance_usd.toFixed(2)}`) : `$${s.balance_usd.toFixed(2)}`}`);
+  if (s.trial) console.log(`  trial:     ${s.trial.remaining}/${s.trial.cap} calls remaining`);
+  const sv = s.savings_7d;
+  if (sv && (sv.vs_gpt4o_mini_usd > 0 || sv.vs_claude_sonnet_usd > 0)) {
+    console.log(`  saved 7d:  $${sv.vs_gpt4o_mini_usd.toFixed(2)} vs GPT-4o-mini · $${sv.vs_claude_sonnet_usd.toFixed(2)} vs Claude Sonnet`);
+  }
+  if (!active) {
+    console.log(`\n  Activate with the one-time ${c.bold("$5 starter pack")} (becomes spendable balance):`);
+    console.log(`  ${c.cyan(BILLING_URL)}`);
+  }
+  console.log("");
+  rl.close();
+}
+
+// ---------- doctor ----------
+
+async function doctor() {
+  console.log(`\n${c.bold("InferAll doctor")} ${c.dim(`— checks your setup against ${API_BASE}`)}\n`);
+  const root = cwd();
+  let ok = true;
+
+  // 1. key present
+  let key = env.INFERALL_API_KEY || "";
+  const envPath = join(root, ".env");
+  if (!key && existsSync(envPath)) {
+    const m = readFileSync(envPath, "utf8").match(/^INFERALL_API_KEY=(.+)$/m);
+    if (m) key = m[1].trim();
+  }
+  if (!key) {
+    console.log(`  ${c.red("✗")} INFERALL_API_KEY not found in environment or .env — run ${c.bold("npx @inferall/cli init")}`);
+    rl.close();
+    exit(1);
+  }
+  console.log(`  ${c.green("✓")} key found (${key.slice(0, 8)}…)`);
+  if (!key.startsWith("ifu_")) {
+    console.log(`  ${c.yellow("~")} key doesn't have the ifu_ prefix — is this an InferAll key?`);
+    ok = false;
+  }
+
+  // 2. .env hygiene
+  const giPath = join(root, ".gitignore");
+  const giCovers =
+    existsSync(giPath) &&
+    readFileSync(giPath, "utf8").split("\n").some((l) => [".env", ".env*", "*.env"].includes(l.trim()));
+  if (existsSync(envPath) && !giCovers) {
+    console.log(`  ${c.yellow("~")} .env exists but is NOT gitignored — your key could be committed`);
+    ok = false;
+  } else {
+    console.log(`  ${c.green("✓")} .env hygiene ok`);
+  }
+
+  // 3. key valid against the gateway
+  const models = await apiGet("/models", key).catch(() => null);
+  if (!models || (models.status !== 200 && models.status !== 402)) {
+    console.log(`  ${c.red("✗")} key rejected by gateway (${models ? `HTTP ${models.status}` : "network error"}) — check ${KEYS_URL}`);
+    rl.close();
+    exit(1);
+  }
+  console.log(`  ${c.green("✓")} key accepted by gateway`);
+
+  // 4. call-site wiring
+  const sites = findCallSites(root);
+  const pointed = sites.filter((s) => s.alreadyPointed).length;
+  const unpointed = sites.length - pointed;
+  if (sites.length === 0) {
+    console.log(`  ${c.dim("·")} no OpenAI/Anthropic client constructors found in this project`);
+  } else if (unpointed === 0) {
+    console.log(`  ${c.green("✓")} all ${sites.length} client constructor site(s) point at InferAll`);
+  } else {
+    console.log(`  ${c.yellow("~")} ${unpointed} of ${sites.length} client site(s) NOT pointed at InferAll — run ${c.bold("npx @inferall/cli init")}`);
+    ok = false;
+  }
+
+  // 4b. Gemini SDK sites — different protocol, can't be re-pointed
+  const gSites = findGeminiSites(root);
+  if (gSites.length) {
+    console.log(`  ${c.yellow("~")} ${gSites.length} Gemini SDK site(s) bypass InferAll (different protocol) — use the OpenAI-compat endpoint with model ${c.bold("gemini/gemini-2.5-flash")}; run ${c.bold("npx @inferall/cli init")} for the exact snippet`);
+    ok = false;
+  }
+
+  // 5. live account state
+  process.stdout.write(`  live call (${FREE_MODEL}) … `);
+  const test = await apiChat(key, [{ role: "user", content: "Reply with the single word: ready" }]);
+  if (test.status === 200) {
+    console.log(c.green("account active ✓"));
+  } else if (test.status === 402) {
+    console.log(c.yellow("account not activated (402)"));
+    console.log(`    One-time ${c.bold("$5 activation")} (becomes spendable balance): ${c.cyan(BILLING_URL)}`);
+    ok = false;
+  } else {
+    console.log(c.red(`HTTP ${test.status}`));
+    ok = false;
+  }
+
+  console.log(ok ? `\n${c.green(c.bold("All checks passed."))}\n` : `\n${c.yellow(c.bold("Some checks need attention (see above)."))}\n`);
+  rl.close();
+  exit(ok ? 0 : 1);
+}
+
+// ---------- main ----------
+
+async function main() {
+  if (flag("version") || cmd === "version") {
+    const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+    console.log(pkg.version);
+    rl.close();
+    return;
+  }
+  if (cmd === "doctor") return doctor();
+  if (cmd === "models") return modelsCmd();
+  if (cmd === "status") return statusCmd();
+  if (cmd !== "init") {
+    console.log(`Usage: npx @inferall/cli <init|doctor|models|status|version> [--key ifu_...] [--yes] [--no-ai] [--free] [--json]`);
+    exit(cmd === "help" || flag("help") ? 0 : 1);
+  }
+
+  console.log(`\n${c.bold("InferAll setup")} ${c.dim("— one API for OpenAI, Anthropic, Google, and 118+ $0 NIM models")}\n`);
+
+  const root = cwd();
+  const project = detectProject(root);
+  if (!project.kind) {
+    console.log(`${c.yellow("!")} No package.json / pyproject.toml / requirements.txt found here.`);
+    console.log(`  Run this from your project root, or continue for a bare .env + example setup.`);
+    if (!(await confirm("Continue anyway?", false))) exit(0);
+    project.kind = "node";
+  }
+  console.log(`  detected: ${c.cyan(project.kind)} project${project.sdks.length ? ` using ${c.cyan(project.sdks.join(", "))}` : ""}`);
+
+  // --- key ---
+  let key = flagValue("key") || env.INFERALL_API_KEY || "";
+  if (!key) {
+    console.log(`\n  Grab a key at ${c.cyan(KEYS_URL)} (free account, key starts with ${c.bold("ifu_")})`);
+    key = await ask(`  Paste your InferAll API key: `);
+  }
+  if (!key.startsWith("ifu_")) {
+    console.log(`${c.red("✗")} That doesn't look like an InferAll key (expected ifu_ prefix).`);
+    exit(1);
+  }
+
+  process.stdout.write(`  verifying key against ${API_BASE} … `);
+  const models = await apiGet("/models", key).catch(() => null);
+  if (!models || (models.status !== 200 && models.status !== 402)) {
+    console.log(c.red(`failed (${models ? `HTTP ${models.status}` : "network error"})`));
+    console.log(`  Check the key at ${KEYS_URL} and re-run.`);
+    exit(1);
+  }
+  console.log(c.green("ok"));
+
+  // --- env files ---
+  upsertEnvFile(root, key);
+  console.log(`  ${c.green("+")} INFERALL_API_KEY written to ${c.bold(".env")} (and .env.example placeholder)`);
+
+  // --- integration ---
+  const usesSdk = project.sdks.some((s) => ["openai", "@anthropic-ai/sdk", "anthropic"].includes(s));
+  if (usesSdk) {
+    const sites = findCallSites(root).filter((s) => !s.alreadyPointed);
+    if (sites.length === 0) {
+      console.log(`  ${c.green("✓")} AI SDK present but no un-migrated client constructors found.`);
+    } else {
+      console.log(`\n  Found ${c.bold(sites.length)} client constructor site(s):`);
+      for (const s of sites) console.log(`    - ${relative(root, s.file)} ${c.dim(`(${s.sdk})`)}`);
+      if (await confirm(`  Point them at the InferAll gateway?`)) {
+        for (const s of sites) {
+          let patched = patchSite(s);
+          let via = "codemod";
+          if (!patched && !NO_AI) {
+            process.stdout.write(`    ${c.dim("AI-assist")} ${relative(root, s.file)} … `);
+            const r = await aiSuggestPatch(key, s);
+            if (r.status === 402) {
+              console.log(c.yellow("skipped (account not activated yet — see verify step below)"));
+              continue;
+            }
+            patched = r.patched;
+            via = "AI";
+            console.log(patched ? c.green("patch ready") : c.yellow("no confident patch"));
+          }
+          if (!patched) {
+            const manualBase = s.sdk === "Anthropic" ? ANTHROPIC_BASE : API_BASE;
+            console.log(`    ${c.yellow("~")} ${relative(root, s.file)}: couldn't patch automatically — set ${s.isPy ? `base_url="${manualBase}"` : `baseURL: "${manualBase}"`} on your ${s.sdk} client manually.`);
+            continue;
+          }
+          if (via === "AI" && !(await confirm(`    Apply AI-suggested rewrite to ${relative(root, s.file)}?`))) continue;
+          writeFileSync(s.file, patched);
+          console.log(`    ${c.green("✓")} ${relative(root, s.file)} ${c.dim(`(${via})`)}`);
+        }
+      }
+    }
+  } else {
+    const example = writeExample(root, project.kind);
+    if (example) console.log(`  ${c.green("+")} example written: ${c.bold(relative(root, example))}`);
+    if (project.kind === "node") console.log(`  ${c.dim("optional:")} npm install @inferall/sdk`);
+    else console.log(`  ${c.dim("optional:")} pip install inferall-ai`);
+  }
+
+  const geminiSites = findGeminiSites(root);
+  if (geminiSites.length) printGeminiGuidance(root, geminiSites);
+
+  // --- verify with a live call ---
+  const testModel = flagValue("model") || FREE_MODEL;
+  process.stdout.write(`\n  test call (${testModel}${testModel === FREE_MODEL ? ", $0 model" : ""}) … `);
+  const test = await apiChat(key, [{ role: "user", content: "Reply with the single word: ready" }], testModel);
+  if (test.status === 200) {
+    console.log(c.green("success ✓"));
+    console.log(`\n${c.green(c.bold("Done."))} Your project is wired to InferAll. Models list: ${API_BASE}/models\n`);
+  } else if (test.status === 402) {
+    console.log(c.yellow("blocked (402)"));
+    console.log(`\n  Everything is wired up, but your account isn't activated yet.`);
+    // Real account state beats a generic message — trial counter + whether a
+    // checkout was already started (settle vs start are different next steps).
+    const st = await fetch(`${ANTHROPIC_BASE}/ai/v1/key/status`, {
+      headers: { Authorization: `Bearer ${key}` },
+    }).then((r) => (r.ok ? r.json() : null)).catch(() => null);
+    if (st?.trial) {
+      console.log(`  Trial: ${st.trial.used}/${st.trial.cap} free calls used${st.has_card ? c.dim(" · checkout started but not settled — finishing it activates you") : ""}.`);
+    }
+    console.log(`  InferAll charges ${c.bold("$0 markup")} — a one-time ${c.bold("$5 activation")} (it becomes spendable`);
+    console.log(`  balance, not a fee) unlocks every model, including the 118+ free NIM models.`);
+    console.log(`  Activate: ${c.cyan(BILLING_URL)}`);
+    console.log(`  The code changes above are done — the first call will work the moment you activate.`);
+    console.log(`  Check anytime: ${c.bold("npx @inferall/cli status")}\n`);
+  } else {
+    console.log(c.red(`HTTP ${test.status}`));
+    console.log(`  ${JSON.stringify(test.body).slice(0, 300)}`);
+    console.log(`  Setup files were written; re-run ${c.bold("npx @inferall/cli init")} to retry the verify step.\n`);
+  }
+  rl.close();
+}
+
+main().catch((err) => {
+  console.error(`${c.red("✗")} ${err?.message || err}`);
+  rl.close();
+  exit(1);
+});

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@inferall/cli",
+  "version": "0.2.0",
+  "description": "Install InferAll into your project in one command: npx @inferall/cli init",
+  "bin": {
+    "inferall": "bin/inferall.js"
+  },
+  "type": "module",
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "bin",
+    "README.md"
+  ],
+  "keywords": [
+    "inferall",
+    "ai",
+    "gateway",
+    "openai",
+    "anthropic",
+    "nim",
+    "cli",
+    "wizard"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kindlyrobotics/inferall.ai.git",
+    "directory": "packages/cli"
+  },
+  "license": "MIT"
+}