@bloomai/cli 0.1.5 → 0.1.7

package/dist/index.js

@@ -1,29 +1,263 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { readFileSync as readFileSync2 } from "fs";
+import { readFileSync as readFileSync5 } from "fs";
 import path from "path";
 import { fileURLToPath } from "url";
-import { Command } from "commander";
+import { Command as Command3 } from "commander";
 
-// src/auth.ts
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+// src/errors.ts
+var BloomError = class extends Error {
+  constructor(msg) {
+    super(msg);
+    this.name = "BloomError";
+  }
+};
+var AuthError = class extends BloomError {
+  constructor(msg) {
+    super(msg);
+    this.name = "AuthError";
+  }
+};
+var RateLimitError = class extends BloomError {
+  constructor(msg) {
+    super(msg);
+    this.name = "RateLimitError";
+  }
+};
+var TickerNotFoundError = class extends BloomError {
+  ticker;
+  constructor(ticker, msg) {
+    super(msg ?? `Ticker not found: ${ticker}`);
+    this.name = "TickerNotFoundError";
+    this.ticker = ticker;
+  }
+};
+var ApiError = class extends BloomError {
+  status;
+  constructor(status2, msg) {
+    super(msg);
+    this.name = "ApiError";
+    this.status = status2;
+  }
+};
+function errorMessage(body) {
+  const text = body.trim();
+  try {
+    const parsed = JSON.parse(text);
+    const msg = typeof parsed === "string" ? parsed : parsed?.error ?? parsed?.detail ?? parsed?.message;
+    if (typeof msg === "string") return msg;
+  } catch {
+  }
+  return text.startsWith("<") ? "" : text;
+}
+var TICKER_NOT_FOUND = /invalid symbol|symbol doesn't exist|investment not found/i;
+function httpError(status2, body, ticker) {
+  const msg = errorMessage(body);
+  if (status2 === 401) {
+    return new AuthError("API key was rejected (HTTP 401). It may be invalid or revoked.");
+  }
+  if (status2 === 403) {
+    return new AuthError(msg || "Authentication failed");
+  }
+  if (status2 === 429) {
+    return new RateLimitError(msg || "Rate limited");
+  }
+  if (ticker && TICKER_NOT_FOUND.test(msg)) {
+    return new TickerNotFoundError(ticker, msg);
+  }
+  return new ApiError(status2, msg ? `${msg} (HTTP ${status2})` : `API error ${status2}`);
+}
+function mcpError(code, message) {
+  const msg = message ? String(message) : "";
+  const lower = msg.toLowerCase();
+  if (code === -32e3 || lower.includes("unauthorized") || lower.includes("auth")) {
+    return new AuthError(msg || "Authentication failed");
+  }
+  if (code === -32001 || lower.includes("rate limit")) {
+    return new RateLimitError(msg || "Rate limited");
+  }
+  if (lower.includes("not found") && lower.includes("ticker")) {
+    const match = msg.match(/ticker[:\s]+([A-Z]+)/i);
+    return new TickerNotFoundError(match?.[1] ?? "UNKNOWN", msg);
+  }
+  return new ApiError(code, msg || `MCP error ${code}`);
+}
+
+// src/debug.ts
+var _debug = false;
+function setDebug(v) {
+  _debug = v;
+}
+function debugLog(...args) {
+  if (_debug) {
+    console.error("[debug]", ...args);
+  }
+}
+
+// src/cache.ts
+import { readFileSync, writeFileSync, mkdirSync, readdirSync, unlinkSync, statSync } from "fs";
+import { createHash } from "crypto";
 import { join } from "path";
 import { homedir } from "os";
-var CONFIG_DIR = join(homedir(), ".config", "bloom-cli");
-var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+var TTL = {
+  quote: 300,
+  // 5 min
+  news: 14400,
+  // 4 hours
+  info: 86400,
+  // 24 hours
+  financials: 604800,
+  // 7 days
+  earnings: 86400,
+  // 24 hours
+  technicals: 3600,
+  // 1 hour
+  sentiment: 1800,
+  // 30 min
+  default: 3600
+  // 1 hour fallback
+};
+var _noCache = false;
+var _cacheDir;
+function setNoCache(v) {
+  _noCache = v;
+}
+function setCacheDir(dir) {
+  _cacheDir = dir;
+}
+function getCacheDir() {
+  return _cacheDir ?? process.env.BLOOM_CACHE_DIR ?? join(homedir(), ".cache", "bloom-cli");
+}
+function ensureCacheDir() {
+  const dir = getCacheDir();
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+function cacheKey(toolName, args) {
+  const sortedArgs = JSON.stringify(args, Object.keys(args).sort());
+  const hash = createHash("md5").update(`${toolName}:${sortedArgs}`).digest("hex");
+  return hash;
+}
+function getCached(toolName, args) {
+  if (_noCache) return void 0;
+  const key = cacheKey(toolName, args);
+  const filePath = join(getCacheDir(), `${key}.json`);
+  let raw;
+  try {
+    raw = readFileSync(filePath, "utf-8");
+  } catch {
+    return void 0;
+  }
+  try {
+    const entry = JSON.parse(raw);
+    if (Date.now() > entry.expiresAt) {
+      try {
+        unlinkSync(filePath);
+      } catch {
+      }
+      debugLog(`cache MISS (expired) ${toolName}`);
+      return void 0;
+    }
+    debugLog(`cache HIT ${toolName} (expires in ${Math.round((entry.expiresAt - Date.now()) / 1e3)}s)`);
+    return entry.data;
+  } catch {
+    try {
+      unlinkSync(filePath);
+    } catch {
+    }
+    return void 0;
+  }
+}
+function setCached(toolName, args, data, category) {
+  if (_noCache) return;
+  const ttlSeconds = TTL[category] ?? TTL.default;
+  const key = cacheKey(toolName, args);
+  const entry = {
+    data,
+    expiresAt: Date.now() + ttlSeconds * 1e3,
+    toolName,
+    category,
+    createdAt: Date.now()
+  };
+  try {
+    const dir = ensureCacheDir();
+    const filePath = join(dir, `${key}.json`);
+    writeFileSync(filePath, JSON.stringify(entry), { mode: 384 });
+    debugLog(`cache SET ${toolName} (ttl=${ttlSeconds}s, category=${category})`);
+  } catch (err) {
+    debugLog(`cache WRITE ERROR: ${err}`);
+  }
+}
+function clearCache() {
+  const dir = getCacheDir();
+  let cleared = 0;
+  try {
+    const files = readdirSync(dir);
+    for (const f of files) {
+      if (f.endsWith(".json")) {
+        try {
+          unlinkSync(join(dir, f));
+          cleared++;
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  return { cleared };
+}
+function cacheStats() {
+  const dir = getCacheDir();
+  const result = {
+    items: 0,
+    totalBytes: 0,
+    expired: 0,
+    byCategory: {},
+    cacheDir: dir
+  };
+  try {
+    const files = readdirSync(dir);
+    for (const f of files) {
+      if (!f.endsWith(".json")) continue;
+      const filePath = join(dir, f);
+      try {
+        const st = statSync(filePath);
+        result.totalBytes += st.size;
+        const raw = readFileSync(filePath, "utf-8");
+        const entry = JSON.parse(raw);
+        result.items++;
+        if (Date.now() > entry.expiresAt) {
+          result.expired++;
+        }
+        const cat = entry.category || "unknown";
+        result.byCategory[cat] = (result.byCategory[cat] ?? 0) + 1;
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return result;
+}
+
+// src/auth.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+var CONFIG_DIR = join2(homedir2(), ".config", "bloom-cli");
+var CONFIG_FILE = join2(CONFIG_DIR, "config.json");
 function readConfig() {
-  if (!existsSync(CONFIG_FILE)) return {};
+  if (!existsSync2(CONFIG_FILE)) return {};
   try {
-    return JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+    return JSON.parse(readFileSync2(CONFIG_FILE, "utf-8"));
   } catch {
     return {};
   }
 }
-function writeConfig(config) {
+function writeConfig(config2) {
   try {
-    mkdirSync(CONFIG_DIR, { recursive: true });
-    writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n", {
+    mkdirSync2(CONFIG_DIR, { recursive: true });
+    writeFileSync2(CONFIG_FILE, JSON.stringify(config2, null, 2) + "\n", {
       mode: 384
     });
   } catch (err) {
@@ -41,36 +275,49 @@ function getApiKey() {
 function requireApiKey() {
   const key = getApiKey();
   if (!key) {
-    console.error(
-      "Error: No API key found. Set BLOOM_API_KEY or run: bloom auth login"
-    );
-    process.exit(1);
+    throw new AuthError("No API key found. Set BLOOM_API_KEY or run: bloom auth login");
   }
   return key;
 }
-function login(apiKey) {
-  const config = readConfig();
-  config.api_key = apiKey;
-  writeConfig(config);
+async function login(apiKey) {
+  const check = await verifyApiKey(apiKey);
+  if (check === "invalid") {
+    console.error(`Error: API key ${maskKey(apiKey)} was rejected by the server. Nothing was saved.`);
+    process.exit(1);
+  }
+  const config2 = readConfig();
+  config2.api_key = apiKey;
+  writeConfig(config2);
   console.log("API key saved to " + CONFIG_FILE);
+  if (check === "unverified") {
+    console.error("Warning: could not reach the server to verify the key.");
+  }
 }
 function logout() {
-  if (existsSync(CONFIG_FILE)) {
-    const config = readConfig();
-    delete config.api_key;
-    writeConfig(config);
+  if (existsSync2(CONFIG_FILE)) {
+    const config2 = readConfig();
+    delete config2.api_key;
+    writeConfig(config2);
   }
   console.log("Logged out. API key cleared.");
 }
-function status() {
+async function status() {
   const envKey = process.env.BLOOM_API_KEY;
   const storedKey = readConfig().api_key;
-  if (envKey) {
-    console.log(`Authenticated via BLOOM_API_KEY (${maskKey(envKey)})`);
-  } else if (storedKey) {
-    console.log(`Authenticated via ${CONFIG_FILE} (${maskKey(storedKey)})`);
-  } else {
+  const key = envKey || storedKey;
+  if (!key) {
     console.log("Not authenticated. Set BLOOM_API_KEY or run: bloom auth login");
+    process.exit(1);
+  }
+  const source = envKey ? "BLOOM_API_KEY" : CONFIG_FILE;
+  const check = await verifyApiKey(key);
+  if (check === "valid") {
+    console.log(`Authenticated via ${source} (${maskKey(key)})`);
+  } else if (check === "invalid") {
+    console.log(`Invalid key via ${source} (${maskKey(key)}): rejected by the server`);
+    process.exit(1);
+  } else {
+    console.log(`Key set via ${source} (${maskKey(key)}), not verified: server unreachable`);
   }
 }
 function maskKey(key) {
@@ -78,44 +325,32 @@ function maskKey(key) {
   return key.slice(0, 4) + "..." + key.slice(-4);
 }
 
-// src/commands/auth.ts
-import { createInterface } from "readline";
-function registerAuthCommand(program2) {
-  const auth = program2.command("auth").description("Manage API authentication");
-  auth.command("login").description("Store API key").argument("[key]", "API key (or pass via stdin)").action(async (key) => {
-    if (!key) {
-      const rl = createInterface({
-        input: process.stdin,
-        output: process.stderr
-      });
-      key = await new Promise((resolve) => {
-        rl.question("API key: ", (answer) => {
-          rl.close();
-          resolve(answer.trim());
-        });
-      });
-    }
-    if (!key) {
-      console.error("Error: No API key provided");
-      process.exit(1);
-    }
-    login(key);
-  });
-  auth.command("status").description("Show current auth state").action(() => {
-    status();
-  });
-  auth.command("logout").description("Clear stored credentials").action(() => {
-    logout();
-  });
-}
-
 // src/api.ts
-var API_BASE = "https://api.getbloom.app";
-var MCP_URL = `${API_BASE}/mcp/`;
+var _apiBase = "https://api.getbloom.app";
+function setApiBase(base) {
+  _apiBase = base;
+}
 var requestId = 0;
+async function verifyApiKey(apiKey) {
+  const url = `${_apiBase}/mcp/test-auth/`;
+  debugLog(`\u2192 GET ${url}`);
+  try {
+    const res = await fetch(url, {
+      headers: { Authorization: `Bearer ${apiKey}` },
+      signal: AbortSignal.timeout(1e4)
+    });
+    debugLog(`\u2190 ${res.status}`);
+    if (res.ok) return "valid";
+    if (res.status === 401 || res.status === 403) return "invalid";
+  } catch (err) {
+    debugLog(`  key check failed: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  return "unverified";
+}
 async function callTool(toolName, args) {
   const apiKey = requireApiKey();
   requestId++;
+  const mcpUrl = `${_apiBase}/mcp/`;
   const body = {
     jsonrpc: "2.0",
     method: "tools/call",
@@ -125,7 +360,10 @@ async function callTool(toolName, args) {
     },
     id: requestId
   };
-  const res = await fetch(MCP_URL, {
+  debugLog(`\u2192 POST ${mcpUrl}`);
+  debugLog(`  tool: ${toolName}`, JSON.stringify(args));
+  const start = performance.now();
+  const res = await fetch(mcpUrl, {
     method: "POST",
     headers: {
       Authorization: `Bearer ${apiKey}`,
@@ -133,13 +371,15 @@ async function callTool(toolName, args) {
     },
     body: JSON.stringify(body)
   });
+  const elapsed = Math.round(performance.now() - start);
+  debugLog(`\u2190 ${res.status} (${elapsed}ms)`);
   if (!res.ok) {
     const text2 = await res.text().catch(() => "");
-    throw new Error(`API error ${res.status}: ${text2 || res.statusText}`);
+    throw httpError(res.status, text2 || res.statusText);
   }
   const data = await res.json();
   if (data.error) {
-    throw new Error(`MCP error ${data.error.code}: ${data.error.message}`);
+    throw mcpError(data.error.code, data.error.message);
   }
   if (!data.result?.content?.length) {
     throw new Error("Empty response from API");
@@ -153,12 +393,14 @@ async function callTool(toolName, args) {
 }
 async function callRest(path2, params) {
   const apiKey = requireApiKey();
-  const url = new URL(path2, API_BASE);
+  const url = new URL(path2, _apiBase);
   if (params) {
     for (const [k, v] of Object.entries(params)) {
       url.searchParams.set(k, v);
     }
   }
+  debugLog(`\u2192 GET ${url.toString()}`);
+  const start = performance.now();
   const res = await fetch(url.toString(), {
     method: "GET",
     headers: {
@@ -166,17 +408,74 @@ async function callRest(path2, params) {
       "Content-Type": "application/json"
     }
   });
+  const elapsed = Math.round(performance.now() - start);
+  debugLog(`\u2190 ${res.status} (${elapsed}ms)`);
   if (!res.ok) {
     const text = await res.text().catch(() => "");
-    throw new Error(`API error ${res.status}: ${text || res.statusText}`);
+    const ticker = path2.match(/^\/?investments\/([^/]+)\//)?.[1];
+    throw httpError(res.status, text || res.statusText, ticker && decodeURIComponent(ticker));
   }
   return res.json();
 }
+async function callToolCached(toolName, args, category = "default") {
+  const cacheToolName = `${_apiBase}:${category}:${toolName}`;
+  const cached = getCached(cacheToolName, args);
+  if (cached !== void 0) {
+    return cached;
+  }
+  debugLog(`cache MISS ${toolName}`);
+  const result = await callTool(toolName, args);
+  setCached(cacheToolName, args, result, category);
+  return result;
+}
+async function callRestCached(path2, params, category = "default") {
+  const cacheToolName = `${_apiBase}:${category}:REST:${path2}`;
+  const cacheArgs = params ?? {};
+  const cached = getCached(cacheToolName, cacheArgs);
+  if (cached !== void 0) {
+    return cached;
+  }
+  debugLog(`cache MISS ${cacheToolName}`);
+  const result = await callRest(path2, params);
+  if (result?.results?.length !== 0) {
+    setCached(cacheToolName, cacheArgs, result, category);
+  }
+  return result;
+}
+
+// src/config.ts
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+import { homedir as homedir3 } from "os";
+var CONFIG_DIR2 = join3(homedir3(), ".config", "bloom-cli");
+var CONFIG_FILE2 = join3(CONFIG_DIR2, "config.json");
+function readConfigFile() {
+  if (!existsSync3(CONFIG_FILE2)) return {};
+  try {
+    return JSON.parse(readFileSync3(CONFIG_FILE2, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function loadConfig(overrides) {
+  const file = readConfigFile();
+  return {
+    apiKey: process.env.BLOOM_API_KEY ?? file.api_key ?? overrides?.apiKey,
+    apiBase: process.env.BLOOM_API_BASE ?? file.api_base ?? overrides?.apiBase ?? "https://api.getbloom.app",
+    cacheDir: process.env.BLOOM_CACHE_DIR ?? file.cache_dir ?? overrides?.cacheDir ?? join3(homedir3(), ".cache", "bloom-cli"),
+    noCache: overrides?.noCache ?? false,
+    debug: overrides?.debug ?? false
+  };
+}
+
+// src/global-opts.ts
+import { Option } from "commander";
 
 // src/format.ts
 import Table from "cli-table3";
-import { writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { writeFileSync as writeFileSync4, mkdirSync as mkdirSync4 } from "fs";
 import { dirname } from "path";
+var FORMATS = ["json", "csv", "table", "markdown"];
 function resolveFormat(opts) {
   if (opts.format) return opts.format;
   if (opts.output || !process.stdout.isTTY) return "json";
@@ -187,15 +486,19 @@ function outputResult(data, opts, tableFormatter) {
     emit(JSON.stringify(data, null, 2), opts);
     return;
   }
-  const fmt2 = resolveFormat(opts);
-  if (fmt2 === "json") {
+  const fmt3 = resolveFormat(opts);
+  if (fmt3 === "json") {
     emit(JSON.stringify(data, null, 2), opts);
     return;
   }
-  if (fmt2 === "csv") {
+  if (fmt3 === "csv") {
     emit(toCSV(data), opts);
     return;
   }
+  if (fmt3 === "markdown") {
+    emit(toMarkdown(data), opts);
+    return;
+  }
   if (tableFormatter) {
     emit(tableFormatter(data, opts), opts);
   } else {
@@ -204,8 +507,8 @@ function outputResult(data, opts, tableFormatter) {
 }
 function emit(content, opts) {
   if (opts.output) {
-    mkdirSync2(dirname(opts.output), { recursive: true });
-    writeFileSync2(opts.output, content + "\n");
+    mkdirSync4(dirname(opts.output), { recursive: true });
+    writeFileSync4(opts.output, content + "\n");
     if (!opts.quiet) {
       console.error(`Written to ${opts.output}`);
     }
@@ -228,6 +531,23 @@ function toCSV(data) {
   }
   return lines.join("\n");
 }
+function toMarkdown(data, _title) {
+  const rows = toRows(data);
+  if (rows.length === 0) return "(no data)";
+  const headers = Array.from(new Set(rows.flatMap((row) => Object.keys(row))));
+  const lines = [];
+  lines.push("| " + headers.join(" | ") + " |");
+  lines.push("| " + headers.map(() => "---").join(" | ") + " |");
+  for (const row of rows) {
+    const vals = headers.map((h) => {
+      const v = row[h];
+      const s = String(v ?? "");
+      return s.replace(/\|/g, "\\|").replace(/\n/g, " ");
+    });
+    lines.push("| " + vals.join(" | ") + " |");
+  }
+  return lines.join("\n");
+}
 function toRows(data) {
   const flatten = (v) => flattenObj(v);
   if (Array.isArray(data)) return data.map(flatten);
@@ -270,8 +590,11 @@ function flattenObj(obj, prefix = "") {
   return result;
 }
 function autoTable(data, opts) {
-  const rows = toRows(data);
+  let rows = toRows(data);
   if (rows.length === 0) return "(no data)";
+  if (rows.length === 1 && Object.keys(rows[0]).length > 6) {
+    rows = Object.entries(rows[0]).map(([key, value]) => ({ key, value }));
+  }
   const headers = Object.keys(rows[0]);
   const table = new Table({
     head: opts?.quiet ? [] : headers,
@@ -297,16 +620,282 @@ function makeTable(headers, rows, opts) {
 function truncate(s, max) {
   return s.length > max ? s.slice(0, max - 1) + "\u2026" : s;
 }
-function parseIntSafe(value, fallback) {
-  const n = parseInt(value, 10);
-  return Number.isNaN(n) ? fallback : n;
+function parseIntArg(value, name, min = 1, max = Number.MAX_SAFE_INTEGER) {
+  const n = /^-?\d+$/.test(value.trim()) ? Number(value) : NaN;
+  if (Number.isNaN(n) || n < min || n > max) {
+    const range = max === Number.MAX_SAFE_INTEGER ? `>= ${min}` : `${min}-${max}`;
+    throw new BloomError(`${name} must be a whole number ${range}, got "${value}"`);
+  }
+  return n;
 }
 
 // src/global-opts.ts
 function addGlobalOptions(cmd) {
-  return cmd.option("-o, --output <file>", "Write output to file").option("-f, --format <fmt>", "Output format: json, csv, table").option("-q, --quiet", "Suppress headers, data only").option("--raw", "Raw JSON from API");
+  return cmd.option("-o, --output <file>", "Write output to file").addOption(
+    new Option("-f, --format <fmt>", "Output format").choices(FORMATS)
+  ).option("-q, --quiet", "Suppress headers, data only").option("--raw", "Raw JSON from API").option("--no-cache", "Bypass disk cache").option("--debug", "Show debug info on stderr");
+}
+
+// src/commands/auth.ts
+import { createInterface } from "readline";
+function registerAuthCommand(program2) {
+  const auth = program2.command("auth").description("Manage API authentication");
+  auth.command("login").description("Store API key").argument("[key]", "API key (or pass via stdin)").action(async (key) => {
+    if (!key) {
+      key = (await readKey()).trim();
+    }
+    if (!key) {
+      console.error("Error: No API key provided");
+      process.exit(1);
+    }
+    await login(key);
+  });
+  auth.command("status").description("Show current auth state").action(status);
+  auth.command("logout").description("Clear stored credentials").action(() => {
+    logout();
+  });
+}
+async function readKey() {
+  const rl = createInterface({ input: process.stdin, output: process.stderr, prompt: "API key: " });
+  if (process.stdin.isTTY) rl.prompt();
+  for await (const line of rl) {
+    rl.close();
+    return line;
+  }
+  return "";
 }
 
+// src/client.ts
+var _instance;
+var BloomClient = class _BloomClient {
+  constructor() {
+  }
+  // --- Singleton ---
+  static instance() {
+    if (!_instance) {
+      _instance = new _BloomClient();
+    }
+    return _instance;
+  }
+  static resetInstance() {
+    _instance = void 0;
+  }
+  // --- Info ---
+  // cacheCategory lets the `quote` alias use the 5-minute quote TTL instead of
+  // the 24-hour info TTL, so an advertised "current" price is never a day old.
+  async getInfo(symbols, fields, cacheCategory = "info") {
+    const args = { symbols };
+    if (fields) args.fields = fields;
+    return callToolCached("get_symbols_metadata", args, cacheCategory);
+  }
+  // --- News ---
+  async getNews(symbols, limit = 15) {
+    return callToolCached("get_news_for_symbols", { symbols, limit }, "news");
+  }
+  // --- Price ---
+  async getPrice(symbol, timeframes, includeOhlc = false) {
+    return callToolCached("get_price_charts", {
+      symbol,
+      timeframes,
+      include_ohlc: includeOhlc
+    }, "quote");
+  }
+  // --- Financials ---
+  async getFinancials(symbol, chartType = "revenue") {
+    return callToolCached("get_financial_charts", { symbol, chart_type: chartType }, "financials");
+  }
+  // --- Earnings ---
+  async getEarnings(symbols) {
+    return callToolCached("analyze_earnings", { symbols }, "earnings");
+  }
+  // --- Earnings Calendar ---
+  async getEarningsCalendar(params) {
+    return callRestCached("/markets/earnings-calendar/", params, "earnings");
+  }
+  // --- Sentiment ---
+  async getSentiment(sections) {
+    const args = {};
+    if (sections) args.sections = sections;
+    return callToolCached("get_market_sentiment", args, "sentiment");
+  }
+  // --- Market ---
+  async getMarket(mapType, period, limit, universe) {
+    return callToolCached("get_market_map", {
+      map_type: mapType,
+      period,
+      limit,
+      universe
+    }, "default");
+  }
+  // --- Collections ---
+  async getCollections(section, limit) {
+    return callToolCached("get_collections", { section, limit }, "default");
+  }
+  // --- Screen ---
+  async screen(args) {
+    return callToolCached("filter_stocks", args, "default");
+  }
+  // --- Technicals ---
+  async getTechnicals(symbols, sections) {
+    const args = { symbols };
+    if (sections) args.sections = sections;
+    return callToolCached("analyze_technicals", args, "technicals");
+  }
+  // --- Options ---
+  async getOptions(symbol, lookbackDays, weeklySampling, includeGreeks) {
+    return callToolCached("analyze_options_history", {
+      symbol,
+      lookback_days: lookbackDays,
+      weekly_sampling: weeklySampling,
+      include_greeks_analysis: includeGreeks
+    }, "technicals");
+  }
+  // --- Portfolio ---
+  async analyzePortfolio(holdings, strategy) {
+    const args = { holdings };
+    if (strategy) args.strategy = strategy;
+    return callToolCached("analyze_portfolio", args, "default");
+  }
+  // --- Trades ---
+  async evaluateTrades(trades) {
+    return callToolCached("analyze_trades", { trades }, "default");
+  }
+  // --- Catalysts ---
+  async getCatalysts(symbols) {
+    return callToolCached("generate_catalysts", { symbols }, "default");
+  }
+  // --- Position Size ---
+  async positionSize(args) {
+    return callToolCached("calculate_position_size", args, "default");
+  }
+  // --- Transcript ---
+  async searchTranscript(args) {
+    return callToolCached("search_transcript", args, "default");
+  }
+  // --- AI Trades ---
+  async getAiTrades(args) {
+    return callToolCached("get_ai_trade_ideas", args, "default");
+  }
+  // --- AI Portfolio ---
+  async getAiPortfolio(args) {
+    return callToolCached("get_ai_trade_ideas", args, "default");
+  }
+  // --- Moving Averages ---
+  // Folded into get_technicals as the "moving_averages" part. Unwrap the slice
+  // back into the {symbol, current_price, indicators} shape callers expect.
+  async getMovingAverages(symbol, indicators) {
+    const raw = await callToolCached(
+      "get_technicals",
+      { symbol, parts: ["moving_averages"], ma_indicators: indicators },
+      "technicals"
+    );
+    const parsed = typeof raw === "string" ? JSON.parse(raw) : raw;
+    const ma = parsed?.moving_averages;
+    if (ma && typeof ma === "object") {
+      return { symbol: parsed.symbol, ...ma };
+    }
+    return parsed;
+  }
+  // --- Backtest ---
+  async backtest(params) {
+    return callRestCached("backtest/", params, "default");
+  }
+  // --- Correlation ---
+  async correlation(params) {
+    return callRestCached("correlation/", params, "default");
+  }
+  // --- Risk ---
+  async getRisk(symbol) {
+    return callRestCached(`investments/${encodeURIComponent(symbol)}/risk_factors/`, void 0, "default");
+  }
+  // --- Drawdown ---
+  async getDrawdown(params) {
+    return callRestCached("portfolios/drawdown/", params, "default");
+  }
+  // --- Macro ---
+  async getMacro(args) {
+    return callToolCached("get_macro_indicators", args, "default");
+  }
+  // --- Sectors ---
+  async getSectors() {
+    return callToolCached("get_sector_performance", {}, "default");
+  }
+  // --- DCF ---
+  async getDcf(symbol) {
+    return callToolCached("get_dcf_valuation", { symbol }, "default");
+  }
+  // --- Holders ---
+  async getHolders(symbol) {
+    return callToolCached("get_holders", { symbol }, "default");
+  }
+  // --- Short Interest ---
+  async getShortInterest(symbol, limit) {
+    return callToolCached("get_short_interest", { symbol, limit }, "default");
+  }
+  // --- Insider ---
+  async getInsider(symbol, limit) {
+    return callToolCached("get_insider_trading", { symbol, limit }, "default");
+  }
+  // --- Dividends ---
+  async getDividends(args) {
+    return callToolCached("get_dividends", args, "default");
+  }
+  // --- Splits ---
+  async getSplits(args) {
+    return callToolCached("get_splits", args, "default");
+  }
+  // --- IPO ---
+  async getIpo(args) {
+    return callToolCached("get_ipo_calendar", args, "default");
+  }
+  // --- Compare ---
+  async compare(symbols) {
+    return callToolCached("get_symbols_metadata", { symbols }, "info");
+  }
+  // --- Ratings ---
+  async getRatings(symbol, limit) {
+    return callToolCached("get_analyst_ratings", { symbol, limit }, "default");
+  }
+  // --- Stats ---
+  async getStats(symbol) {
+    return callRestCached(`investments/${encodeURIComponent(symbol)}/stats/`, void 0, "quote");
+  }
+  // --- Peers ---
+  async getPeers(symbol) {
+    return callRestCached(`investments/${encodeURIComponent(symbol)}/peers/`, void 0, "quote");
+  }
+  // --- Bottom Line ---
+  async getBottomLine(symbol) {
+    return callRestCached(`investments/${encodeURIComponent(symbol)}/bottom_line_v2/`, void 0, "info");
+  }
+  // --- Insights ---
+  async getInsights(symbol, symbols) {
+    if (symbol) {
+      return callRestCached(`investments/${encodeURIComponent(symbol)}/insights/`, void 0, "default");
+    }
+    const params = {};
+    if (symbols) params.symbols = symbols.join(",");
+    return callRestCached("investments/all_insights/", params, "default");
+  }
+  // --- Arena Activity ---
+  async getArenaActivity(model, limit) {
+    const params = {};
+    if (model) params.model = model;
+    if (limit) params.limit = String(limit);
+    return callRestCached("api/arena/activity/", params, "default");
+  }
+  // --- Portfolio News ---
+  async getPortfolioNews(symbols) {
+    const params = {};
+    if (symbols) params.symbols = symbols.join(",");
+    return callRestCached("smart-summaries/portfolio-news/", params, "news");
+  }
+  // --- Collection Returns ---
+  async getCollectionReturns(collectionIds, timerange) {
+    return callRestCached("collections/returns/", { collection_ids: collectionIds, timerange }, "default");
+  }
+};
+
 // src/commands/info.ts
 var VALID_FIELDS = [
   "basic_metadata",
@@ -318,15 +907,12 @@ var VALID_FIELDS = [
 ];
 function registerInfoCommand(program2) {
   addGlobalOptions(
-    program2.command("info").description("Company fundamentals, ratings, peers, holdings").argument("<symbols...>", "Ticker symbols (e.g. AAPL MSFT)").option("--fields <fields>", "Comma-separated: " + VALID_FIELDS.join(","))
+    program2.command("info").alias("quote").description("Company fundamentals, ratings, peers, holdings").argument("<symbols...>", "Ticker symbols (e.g. AAPL MSFT)").option("--fields <fields>", "Comma-separated: " + VALID_FIELDS.join(","))
   ).action(async (symbols, opts) => {
-    const args = {
-      symbols: symbols.map((s) => s.toUpperCase())
-    };
-    if (opts.fields) {
-      args.fields = opts.fields.split(",").map((f) => f.trim());
-    }
-    const data = await callTool("get_symbols_metadata", args);
+    const syms = symbols.map((s) => s.toUpperCase());
+    const fields = opts.fields?.split(",").map((f) => f.trim());
+    const cacheCategory = program2.args[0] === "quote" ? "quote" : "info";
+    const data = await BloomClient.instance().getInfo(syms, fields, cacheCategory);
     outputResult(data, opts, (d) => formatInfo(d));
   });
 }
@@ -376,11 +962,16 @@ function formatSection(obj, indent = "") {
 function registerNewsCommand(program2) {
   addGlobalOptions(
     program2.command("news").description("Recent news from Benzinga channels").argument("<symbols...>", "Ticker symbols").option("--limit <n>", "Max articles (default: 15)", "15")
-  ).action(async (symbols, opts) => {
-    const data = await callTool("get_news_for_symbols", {
-      symbols: symbols.map((s) => s.toUpperCase()),
-      limit: parseIntSafe(opts.limit, 15)
-    });
+  ).addHelpText("after", `
+Examples:
+  $ bloom news AAPL                  Latest Apple news
+  $ bloom news AAPL MSFT GOOGL       News for multiple stocks
+  $ bloom news TSLA --limit 5        Last 5 Tesla articles
+`).action(async (symbols, opts) => {
+    const data = await BloomClient.instance().getNews(
+      symbols.map((s) => s.toUpperCase()),
+      parseIntArg(opts.limit, "--limit")
+    );
     outputResult(data, opts, (d, o) => formatNews(d, o));
   });
 }
@@ -412,12 +1003,18 @@ function formatNews(data, opts) {
 function registerPriceCommand(program2) {
   addGlobalOptions(
     program2.command("price").description("Historical price data").argument("<symbol>", "Ticker symbol").option("--timeframes <tf>", "Comma-separated: 1d,1w,1m,3m,6m,ytd,1y,2y,5y", "1d,1m,1y").option("--ohlc", "Include full OHLC data")
-  ).action(async (symbol, opts) => {
-    const data = await callTool("get_price_charts", {
-      symbol: symbol.toUpperCase(),
-      timeframes: opts.timeframes.split(",").map((t) => t.trim()),
-      include_ohlc: !!opts.ohlc
-    });
+  ).addHelpText("after", `
+Examples:
+  $ bloom price AAPL                        Default timeframes (1d, 1m, 1y)
+  $ bloom price TSLA --timeframes 1d,5y     Daily and 5-year price history
+  $ bloom price MSFT --ohlc                 Include open/high/low/close
+  $ bloom price AAPL -f csv -o prices.csv   Export to CSV file
+`).action(async (symbol, opts) => {
+    const data = await BloomClient.instance().getPrice(
+      symbol.toUpperCase(),
+      opts.timeframes.split(",").map((t) => t.trim()),
+      !!opts.ohlc
+    );
     outputResult(data, opts, (d, o) => formatPrices(d, o));
   });
 }
@@ -467,7 +1064,8 @@ function formatPrices(data, opts) {
 }
 
 // src/commands/financials.ts
-var CHART_TYPES = [
+import { Option as Option2 } from "commander";
+var VALID_TYPES = [
   "revenue",
   "revenue_growth",
   "operating_margin",
@@ -480,12 +1078,18 @@ var CHART_TYPES = [
 ];
 function registerFinancialsCommand(program2) {
   addGlobalOptions(
-    program2.command("financials").description("Quarterly/annual financial data with YoY growth").argument("<symbol>", "Ticker symbol").option("--type <type>", "Chart type: " + CHART_TYPES.join(", "), "revenue")
-  ).action(async (symbol, opts) => {
-    const data = await callTool("get_financial_charts", {
-      symbol: symbol.toUpperCase(),
-      chart_type: opts.type
-    });
+    program2.command("financials").description("Financial charts: revenue, margins, earnings, FCF").argument("<symbol>", "Ticker symbol").addOption(
+      new Option2("--type <type>", "Chart type").choices(VALID_TYPES).default("revenue")
+    )
+  ).addHelpText("after", `
+Examples:
+  $ bloom financials AAPL                              Revenue (default)
+  $ bloom financials TSLA --type operating_margin      Operating margins
+  $ bloom financials MSFT --type free_cash_flow        Free cash flow
+  $ bloom financials NVDA --type revenue_growth        Revenue growth rate
+`).action(async (symbol, opts) => {
+    const sym = symbol.toUpperCase();
+    const data = await BloomClient.instance().getFinancials(sym, opts.type);
     outputResult(data, opts);
   });
 }
@@ -500,12 +1104,13 @@ var SECTIONS = [
 function registerSentimentCommand(program2) {
   addGlobalOptions(
     program2.command("sentiment").description("Market mood: AAII, Fear&Greed, VIX, momentum").option("--sections <s>", "Comma-separated: " + SECTIONS.join(","))
-  ).action(async (opts) => {
-    const args = {};
-    if (opts.sections) {
-      args.sections = opts.sections.split(",").map((s) => s.trim());
-    }
-    const data = await callTool("get_market_sentiment", args);
+  ).addHelpText("after", `
+Examples:
+  $ bloom sentiment                                             All sentiment indicators
+  $ bloom sentiment --sections aaii_sentiment,cnn_fear_greed    Just AAII and Fear & Greed
+`).action(async (opts) => {
+    const sections = opts.sections?.split(",").map((s) => s.trim());
+    const data = await BloomClient.instance().getSentiment(sections);
     outputResult(data, opts, (d) => formatSentiment(d));
   });
 }
@@ -536,13 +1141,20 @@ function formatSentiment(data) {
 function registerMarketCommand(program2) {
   addGlobalOptions(
     program2.command("market").description("Market performance, sectors, global").option("--type <type>", "top_movers|sector_breakdown|global_markets|major_indexes", "top_movers").option("--period <p>", "1d|1w|1m|3m|6m|ytd|1y|5y", "1d").option("--limit <n>", "Max stocks for top_movers", "24").option("--universe <u>", "all|sp500|international|crypto|community", "all")
-  ).action(async (opts) => {
-    const data = await callTool("get_market_map", {
-      map_type: opts.type,
-      period: opts.period,
-      limit: parseIntSafe(opts.limit, 24),
-      universe: opts.universe
-    });
+  ).addHelpText("after", `
+Examples:
+  $ bloom market                                   Today's top movers
+  $ bloom market --type sector_breakdown           Sector performance
+  $ bloom market --type global_markets             Global market overview
+  $ bloom market --type top_movers --period 1w     Weekly top movers
+  $ bloom market --universe sp500 --limit 10       Top 10 S&P 500 movers
+`).action(async (opts) => {
+    const data = await BloomClient.instance().getMarket(
+      opts.type,
+      opts.period,
+      parseIntArg(opts.limit, "--limit"),
+      opts.universe
+    );
     outputResult(data, opts);
   });
 }
@@ -551,11 +1163,17 @@ function registerMarketCommand(program2) {
 function registerCollectionsCommand(program2) {
   addGlobalOptions(
     program2.command("collections").description("Curated stock collections by theme").option("--section <s>", "GET_STARTED|VALUE|TRENDS|BEAT_UP|FAMOUS_INVESTORS|HIGH_FLYERS|SECTORS|GEO|LEADERBOARDS", "GET_STARTED").option("--limit <n>", "Max collections", "6")
-  ).action(async (opts) => {
-    const data = await callTool("get_collections", {
-      section: opts.section,
-      limit: parseIntSafe(opts.limit, 6)
-    });
+  ).addHelpText("after", `
+Examples:
+  $ bloom collections                              Default collections
+  $ bloom collections --section VALUE              Value investing picks
+  $ bloom collections --section FAMOUS_INVESTORS   Famous investor portfolios
+  $ bloom collections --section TRENDS --limit 3   Top 3 trending collections
+`).action(async (opts) => {
+    const data = await BloomClient.instance().getCollections(
+      opts.section,
+      parseIntArg(opts.limit, "--limit")
+    );
     outputResult(data, opts);
   });
 }
@@ -569,7 +1187,7 @@ function registerScreenCommand(program2) {
       const args = {
         filter_expressions: filters,
         and_query: !opts.or,
-        limit: parseIntSafe(opts.limit, 50)
+        limit: parseIntArg(opts.limit, "--limit")
       };
       if (opts.symbols) {
         args.symbols = opts.symbols.split(",").map((s) => s.trim().toUpperCase());
@@ -577,7 +1195,7 @@ function registerScreenCommand(program2) {
       if (opts.fields) {
         args.fields = opts.fields.split(",").map((f) => f.trim());
       }
-      const data = await callTool("filter_stocks", args);
+      const data = await BloomClient.instance().screen(args);
       outputResult(data, opts, (d, o) => formatScreen(d, o));
     }
   );
@@ -614,32 +1232,54 @@ function formatScreen(data, opts) {
   return makeTable(headers, rows, opts);
 }
 
+// src/limits.ts
+var MAX_ANALYSIS_SYMBOLS = 10;
+
 // src/commands/earnings.ts
 function registerEarningsCommand(program2) {
   addGlobalOptions(
-    program2.command("earnings").description("Earnings history, estimates, surprises").argument("<symbols...>", "Ticker symbols (up to 5)")
-  ).action(async (symbols, opts) => {
-    const data = await callTool("analyze_earnings", {
-      symbols: symbols.map((s) => s.toUpperCase()).slice(0, 5)
-    });
+    program2.command("earnings").description("Earnings history, estimates, surprises").argument("<symbols...>", "Ticker symbols (up to 10)")
+  ).addHelpText("after", `
+Examples:
+  $ bloom earnings AAPL              Apple earnings history and surprises
+  $ bloom earnings AAPL MSFT GOOGL   Compare earnings for multiple stocks
+`).action(async (symbols, opts) => {
+    const syms = symbols.map((s) => s.toUpperCase()).slice(0, MAX_ANALYSIS_SYMBOLS);
+    const data = await BloomClient.instance().getEarnings(syms);
     outputResult(data, opts);
   });
 }
 
 // src/commands/earnings-calendar.ts
+function formatEps(value, currency) {
+  if (value == null) return "\u2014";
+  return !currency || currency === "USD" ? `$${value}` : `${value} ${currency}`;
+}
 function registerEarningsCalendarCommand(program2) {
   addGlobalOptions(
     program2.command("earnings-calendar").description(
-      "Upcoming earnings dates for symbols (default 28 days)"
-    ).argument("<symbols...>", "Ticker symbols").option("--days <n>", "Look-ahead window in days (1-90)", "28")
-  ).action(
+      "Upcoming earnings dates (all companies, or filter by symbols)"
+    ).argument("[symbols...]", "Ticker symbols (omit to show all)").option("--days <n>", "Look-ahead window in days (1-90)", "28").option(
+      "--popular",
+      "Also include top companies by market cap, not just the given symbols"
+    )
+  ).addHelpText("after", `
+Examples:
+  $ bloom earnings-calendar AAPL MSFT GOOGL   Upcoming earnings for these stocks
+  $ bloom earnings-calendar TSLA --days 7     Earnings within the next week
+  $ bloom earnings-calendar NVDA --days 90    Earnings within 90 days
+  $ bloom earnings-calendar AAPL --popular    AAPL plus the popular calendar
+`).action(
     async (symbols, opts) => {
-      const days = parseIntSafe(opts.days, 28);
-      const syms = symbols.map((s) => s.toUpperCase()).join(",");
-      const data = await callRest("/markets/earnings-calendar/", {
-        symbols: syms,
-        days: String(days)
-      });
+      const days = parseIntArg(opts.days, "--days", 1, 90);
+      const params = { days: String(days) };
+      if (symbols.length > 0) {
+        params.symbols = symbols.map((s) => s.toUpperCase()).join(",");
+        if (!opts.popular) params.include_popular = "false";
+      }
+      const data = await BloomClient.instance().getEarningsCalendar(
+        params
+      );
       const items = data.results ?? [];
       outputResult(items, opts, (d, o) => {
         const rows = d;
@@ -650,8 +1290,8 @@ function registerEarningsCalendarCommand(program2) {
             r.earnings_date ?? "\u2014",
             r.symbol,
             r.name,
-            r.eps_estimate != null ? `$${r.eps_estimate}` : "\u2014",
-            r.eps_actual != null ? `$${r.eps_actual}` : "\u2014"
+            formatEps(r.eps_estimate, r.currency),
+            formatEps(r.eps_actual, r.currency)
           ]),
           o
         );
@@ -664,15 +1304,17 @@ function registerEarningsCalendarCommand(program2) {
 var SECTIONS2 = ["technical_indicators", "options_analysis", "insider_activity"];
 function registerTechnicalsCommand(program2) {
   addGlobalOptions(
-    program2.command("technicals").description("RSI, MAs, patterns, options flow, insider trades").argument("<symbols...>", "Ticker symbols (up to 5)").option("--sections <s>", "Comma-separated: " + SECTIONS2.join(","))
-  ).action(async (symbols, opts) => {
-    const args = {
-      symbols: symbols.map((s) => s.toUpperCase()).slice(0, 5)
-    };
-    if (opts.sections) {
-      args.sections = opts.sections.split(",").map((s) => s.trim());
-    }
-    const data = await callTool("analyze_technicals", args);
+    program2.command("technicals").description("RSI, MAs, patterns, options flow, insider trades").argument("<symbols...>", "Ticker symbols (up to 10)").option("--sections <s>", "Comma-separated: " + SECTIONS2.join(","))
+  ).addHelpText("after", `
+Examples:
+  $ bloom technicals AAPL                                 All technical data
+  $ bloom technicals TSLA --sections technical_indicators    RSI, MAs, patterns only
+  $ bloom technicals NVDA --sections options_analysis     Options flow only
+  $ bloom technicals AAPL --sections insider_activity     Insider trades only
+`).action(async (symbols, opts) => {
+    const syms = symbols.map((s) => s.toUpperCase()).slice(0, MAX_ANALYSIS_SYMBOLS);
+    const sections = opts.sections?.split(",").map((s) => s.trim());
+    const data = await BloomClient.instance().getTechnicals(syms, sections);
     outputResult(data, opts);
   });
 }
@@ -681,14 +1323,20 @@ function registerTechnicalsCommand(program2) {
 function registerOptionsCommand(program2) {
   addGlobalOptions(
     program2.command("options-history").description("Options sentiment evolution over time").argument("<symbol>", "Ticker symbol").option("--days <n>", "Lookback days (7-90)", "30").option("--weekly", "Use weekly sampling (default)").option("--daily", "Use daily data").option("--greeks", "Include advanced Greeks analysis")
-  ).action(
+  ).addHelpText("after", `
+Examples:
+  $ bloom options-history AAPL              30-day options sentiment (default)
+  $ bloom options-history TSLA --days 90    90-day lookback
+  $ bloom options-history NVDA --daily      Daily granularity
+  $ bloom options-history AAPL --greeks     Include advanced Greeks analysis
+`).action(
     async (symbol, opts) => {
-      const data = await callTool("analyze_options_history", {
-        symbol: symbol.toUpperCase(),
-        lookback_days: parseIntSafe(opts.days, 30),
-        weekly_sampling: opts.weekly ?? !opts.daily,
-        include_greeks_analysis: !!opts.greeks
-      });
+      const data = await BloomClient.instance().getOptions(
+        symbol.toUpperCase(),
+        parseIntArg(opts.days, "--days", 7, 90),
+        opts.weekly ?? !opts.daily,
+        !!opts.greeks
+      );
       outputResult(data, opts);
     }
   );
@@ -703,12 +1351,14 @@ function registerPortfolioCommand(program2) {
     try {
       holdings = JSON.parse(holdingsStr);
     } catch {
-      console.error(`Error: Invalid JSON for holdings. Use format: '{"AAPL":0.3,"MSFT":0.7}'`);
-      process.exit(1);
     }
-    const args = { holdings };
-    if (opts.strategy) args.strategy = opts.strategy;
-    const data = await callTool("analyze_portfolio", args);
+    const valid = holdings !== null && typeof holdings === "object" && !Array.isArray(holdings) && Object.keys(holdings).length > 0 && Object.values(holdings).every((w) => typeof w === "number" && Number.isFinite(w));
+    if (!valid) {
+      throw new BloomError(
+        `holdings must be a JSON object of symbol to numeric weight, e.g. '{"AAPL":0.3,"MSFT":0.7}'`
+      );
+    }
+    const data = await BloomClient.instance().analyzePortfolio(holdings, opts.strategy);
     outputResult(data, opts);
   });
 }
@@ -717,9 +1367,13 @@ function registerPortfolioCommand(program2) {
 function registerTradesCommand(program2) {
   addGlobalOptions(
     program2.command("trades").description("AI trade evaluation").argument("<trades...>", 'Trade descriptions: "Buy AAPL 30% because..." "Sell MSFT 20% because..."')
-  ).action(async (tradeStrs, opts) => {
+  ).addHelpText("after", `
+Examples:
+  $ bloom trades "Buy AAPL 30% because of strong iPhone sales"
+  $ bloom trades "Sell MSFT 20% to take profits" "Buy GOOGL 15% on AI momentum"
+`).action(async (tradeStrs, opts) => {
     const trades = tradeStrs.map(parseTrade);
-    const data = await callTool("analyze_trades", { trades });
+    const data = await BloomClient.instance().evaluateTrades(trades);
     outputResult(data, opts);
   });
 }
@@ -749,11 +1403,15 @@ Format: "Buy AAPL 30% because thesis" or JSON object`
 // src/commands/catalysts.ts
 function registerCatalystsCommand(program2) {
   addGlobalOptions(
-    program2.command("catalysts").description("Forward-looking value catalysts").argument("<symbols...>", "Ticker symbols (up to 5)")
-  ).action(async (symbols, opts) => {
-    const data = await callTool("generate_catalysts", {
-      symbols: symbols.map((s) => s.toUpperCase()).slice(0, 5)
-    });
+    program2.command("catalysts").description("Forward-looking value catalysts").argument("<symbols...>", "Ticker symbols (up to 10)")
+  ).addHelpText("after", `
+Examples:
+  $ bloom catalysts AAPL              Upcoming catalysts for Apple
+  $ bloom catalysts TSLA NVDA AMZN    Catalysts for multiple stocks
+`).action(async (symbols, opts) => {
+    const data = await BloomClient.instance().getCatalysts(
+      symbols.map((s) => s.toUpperCase()).slice(0, MAX_ANALYSIS_SYMBOLS)
+    );
     outputResult(data, opts);
   });
 }
@@ -782,11 +1440,11 @@ function registerPositionCommand(program2) {
       const args = {
         bull_return: bullReturn,
         bear_return: bearReturn,
-        conviction: parseIntSafe(opts.conviction, 5),
+        conviction: parseIntArg(opts.conviction, "--conviction", 1, 10),
         portfolio_value: portfolioValue
       };
       if (opts.symbol) args.symbol = opts.symbol.toUpperCase();
-      const data = await callTool("calculate_position_size", args);
+      const data = await BloomClient.instance().positionSize(args);
       outputResult(data, opts);
     }
   );
@@ -795,16 +1453,16 @@ function registerPositionCommand(program2) {
 // src/commands/transcript.ts
 function registerTranscriptCommand(program2) {
   addGlobalOptions(
-    program2.command("transcript").description("Search earnings call transcripts").argument("<symbol>", "Ticker symbol").argument("<keywords...>", "Keywords to search (OR logic)").option("--quarter <q>", 'Fiscal quarter, e.g. "Q1 2024"').option("--max <n>", "Max results", "10")
+    program2.command("transcript").alias("transcripts").description("Search earnings call transcripts").argument("<symbol>", "Ticker symbol").argument("<keywords...>", "Keywords to search (OR logic)").option("--quarter <q>", 'Fiscal quarter, e.g. "Q1 2024"').option("--max <n>", "Max results", "10")
   ).action(
     async (symbol, keywords, opts) => {
       const args = {
         symbol: symbol.toUpperCase(),
         keywords,
-        max_results: parseIntSafe(opts.max, 10)
+        max_results: parseIntArg(opts.max, "--max")
       };
       if (opts.quarter) args.fiscal_quarter = opts.quarter;
-      const data = await callTool("search_transcript", args);
+      const data = await BloomClient.instance().searchTranscript(args);
       outputResult(data, opts, (d, o) => formatTranscript(d, o));
     }
   );
@@ -847,11 +1505,11 @@ function registerAiTradesCommand(program2) {
     program2.command("ai-trades").description("Recent trade decisions from AI models competing with real money (InvestingArena)").option("--model <m>", "Filter by AI model: claude|openai|gemini").option("--symbol <s>", "Filter by stock ticker symbol (e.g., AAPL)").option("--limit <n>", "Max recent trades per model (default: 10, max: 50)", "10")
   ).action(async (opts) => {
     const args = {
-      limit: parseIntSafe(opts.limit, 10)
+      limit: parseIntArg(opts.limit, "--limit", 1, 50)
     };
     if (opts.model) args.ai_model = opts.model;
     if (opts.symbol) args.symbol = opts.symbol.toUpperCase();
-    const data = await callTool("get_ai_trade_ideas", args);
+    const data = await BloomClient.instance().getAiTrades(args);
     if (opts.raw) {
       outputResult(data, opts);
       return;
@@ -879,7 +1537,7 @@ function formatTrades(data, opts) {
       String(t.shares ?? "-"),
       t.fill_price != null ? `$${Number(t.fill_price).toFixed(2)}` : "-",
       gain,
-      truncate2(String(t.rationale ?? "-"), 60)
+      truncate(String(t.rationale ?? "-"), 60)
     ];
   });
   return makeTable(
@@ -888,18 +1546,20 @@ function formatTrades(data, opts) {
     opts
   );
 }
-function truncate2(s, max) {
-  return s.length > max ? s.slice(0, max - 1) + "\u2026" : s;
-}
 
 // src/commands/ai-portfolio.ts
 function registerAiPortfolioCommand(program2) {
   addGlobalOptions(
     program2.command("ai-portfolio").description("Current portfolio positions held by AI models (InvestingArena live accounts)").option("--model <m>", "Filter by AI model: claude|openai|gemini")
-  ).action(async (opts) => {
+  ).addHelpText("after", `
+Examples:
+  $ bloom ai-portfolio                     All AI model portfolios
+  $ bloom ai-portfolio --model claude      Claude's current positions
+  $ bloom ai-portfolio --model openai      OpenAI's current positions
+`).action(async (opts) => {
     const args = {};
     if (opts.model) args.ai_model = opts.model;
-    const data = await callTool("get_ai_trade_ideas", args);
+    const data = await BloomClient.instance().getAiPortfolio(args);
     if (opts.raw) {
       outputResult(data, opts);
       return;
@@ -1006,6 +1666,7 @@ function registerMaCommand(program2) {
     program2.command("ma").description("Moving averages (SMA/EMA) for a symbol").argument("<symbol>", "Ticker symbol (e.g., AAPL)").option("--sma <periods>", "Comma-separated SMA periods (e.g., 50,100,200)").option("--ema <periods>", "Comma-separated EMA periods (e.g., 20,50)").option("--limit <n>", "Number of data points to display (default: 20)", "20")
   ).action(
     async (symbol, opts) => {
+      const limit = parseIntArg(opts.limit, "--limit");
       const indicators = [];
       if (opts.sma) {
         for (const p of opts.sma.split(",")) {
@@ -1022,12 +1683,10 @@ function registerMaCommand(program2) {
       if (indicators.length === 0) {
         indicators.push("sma_100", "ema_100");
       }
-      const args = {
-        symbol: symbol.toUpperCase(),
+      const data = await BloomClient.instance().getMovingAverages(
+        symbol.toUpperCase(),
         indicators
-      };
-      const data = await callTool("get_moving_averages", args);
-      const limit = parseInt(opts.limit, 10) || 20;
+      );
       let parsed = null;
       try {
         parsed = typeof data === "string" ? JSON.parse(data) : data;
@@ -1071,7 +1730,7 @@ function registerBacktestCommand(program2) {
   addGlobalOptions(
     program2.command("backtest").description("Backtest a portfolio against a benchmark").requiredOption("--symbols <s>", "Comma-separated symbols (e.g., AAPL,MSFT)").requiredOption("--allocations <a>", "Comma-separated weights (e.g., 0.5,0.5)").option("--benchmark <b>", "Benchmark symbol (default: SPY)", "SPY").option("--strategy <s>", "Strategy: buy_and_hold", "buy_and_hold")
   ).action(async (opts) => {
-    const data = await callRest("backtest/", {
+    const data = await BloomClient.instance().backtest({
       symbols: opts.symbols,
       allocations: opts.allocations,
       benchmark: opts.benchmark,
@@ -1098,7 +1757,9 @@ function formatBacktest(data) {
     ]);
   }
   if (rows.length === 0) return JSON.stringify(data, null, 2);
-  return makeTable(["Interval", "Return", "Benchmark", "Alpha", "Sharpe", "Max DD"], rows);
+  const table = makeTable(["Interval", "Return", "Benchmark", "Alpha", "Sharpe", "Max DD"], rows);
+  const warnings = Array.isArray(obj.warnings) ? obj.warnings : [];
+  return [table, ...warnings.map((w) => `Warning: ${w}`)].join("\n");
 }
 function fmt(v) {
   if (v == null || v === "") return "-";
@@ -1117,13 +1778,18 @@ function fmtNum(v) {
 function registerCorrelationCommand(program2) {
   addGlobalOptions(
     program2.command("correlation").description("Correlation matrix for a set of symbols").argument("<symbols...>", "Ticker symbols (2+)").option("--start <date>", "Start date (YYYY-MM-DD)").option("--end <date>", "End date (YYYY-MM-DD)")
-  ).action(async (symbols, opts) => {
+  ).addHelpText("after", `
+Examples:
+  $ bloom correlation AAPL MSFT GOOGL                                      Correlation matrix
+  $ bloom correlation AAPL TSLA --start 2025-01-01                         Since Jan 2025
+  $ bloom correlation SPY QQQ IWM --start 2024-01-01 --end 2024-12-31     Full year
+`).action(async (symbols, opts) => {
     const params = {
       symbols: symbols.map((s) => s.toUpperCase()).join(",")
     };
     if (opts.start) params.start_date = opts.start;
     if (opts.end) params.end_date = opts.end;
-    const data = await callRest("correlation/", params);
+    const data = await BloomClient.instance().correlation(params);
     outputResult(data, opts, formatCorrelation);
   });
 }
@@ -1140,25 +1806,56 @@ function formatCorrelation(data) {
 }
 
 // src/commands/risk.ts
+var STALE_DAYS = 456;
 function registerRiskCommand(program2) {
   addGlobalOptions(
-    program2.command("risk").description("Risk factors for a stock").argument("<symbol>", "Ticker symbol")
-  ).action(async (symbol, opts) => {
-    const data = await callRest(`investments/${symbol.toUpperCase()}/risk_factors/`);
+    program2.command("risk").description("Risk factors from the company's latest ingested SEC 10-K (check filingDate)").argument("<symbol>", "Ticker symbol")
+  ).addHelpText("after", `
+Each row carries filingDate/periodEnd for its 10-K (null on older rows; use
+created). A warning goes to stderr when the source is over ~15 months old.
+
+Examples:
+  $ bloom risk AAPL       Risk factors for Apple
+  $ bloom risk TSLA       Risk factors for Tesla
+`).action(async (symbol, opts) => {
+    const data = await BloomClient.instance().getRisk(symbol.toUpperCase());
+    const warning = staleWarning(riskRows(data));
+    if (warning && !opts.quiet) console.error(warning);
     outputResult(data, opts, formatRisk);
   });
 }
-function formatRisk(data) {
-  if (!Array.isArray(data)) return JSON.stringify(data, null, 2);
-  if (data.length === 0) return "(no risk factors found)";
-  const rows = data.map((r) => [
-    String(r.category ?? r.risk_type ?? "-"),
-    truncate3(String(r.description ?? r.text ?? "-"), 80)
-  ]);
-  return makeTable(["Category", "Description"], rows);
+function riskRows(data) {
+  return data?.results ?? [];
 }
-function truncate3(s, max) {
-  return s.length > max ? s.slice(0, max - 1) + "\u2026" : s;
+function sourceInfo(rows) {
+  let best = null;
+  for (const r of rows) {
+    const raw = r.filingDate ?? r.created;
+    if (!raw) continue;
+    const date = String(raw).slice(0, 10);
+    if (!best || date > best.date) best = { date, how: r.filingDate ? "filed" : "ingested" };
+  }
+  return best;
+}
+function staleWarning(rows) {
+  const src = sourceInfo(rows);
+  if (!src) return null;
+  const ageDays = (Date.now() - Date.parse(src.date)) / 864e5;
+  if (ageDays <= STALE_DAYS) return null;
+  return `Warning: these risk factors come from a 10-K ${src.how} ${src.date} (${Math.floor(ageDays / 30)} months ago) and may be out of date.`;
+}
+function formatRisk(data) {
+  const rows = riskRows(data);
+  if (rows.length === 0) return "(no risk factors found)";
+  const src = sourceInfo(rows);
+  const period = rows.find((r) => r.periodEnd)?.periodEnd;
+  const header = `Source: SEC 10-K${src ? ` ${src.how} ${src.date}` : ""}${period ? ` (fiscal year ended ${period})` : ""}`;
+  const table = makeTable(
+    ["Risk"],
+    rows.map((r) => [truncate(String(r.keyPoint ?? r.details ?? "-"), 100)])
+  );
+  return `${header}
+${table}`;
 }
 
 // src/commands/drawdown.ts
@@ -1166,64 +1863,41 @@ function registerDrawdownCommand(program2) {
   addGlobalOptions(
     program2.command("drawdown").description("Portfolio drawdown analysis").requiredOption("--symbols <s>", "Comma-separated symbols (e.g., AAPL,MSFT)").requiredOption("--allocations <a>", "Comma-separated weights (e.g., 0.5,0.5)")
   ).action(async (opts) => {
-    const data = await callRest("portfolios/drawdown/", {
+    const data = await BloomClient.instance().getDrawdown({
       symbols: opts.symbols,
       allocations: opts.allocations
     });
     outputResult(data, opts, formatDrawdown);
   });
 }
-function formatDrawdown(data) {
-  const obj = data;
-  if (!obj || typeof obj !== "object") return JSON.stringify(data, null, 2);
-  const intervals = obj.interval_results ?? obj;
-  const rows = [];
-  for (const [interval, dd] of Object.entries(intervals)) {
-    if (typeof dd !== "object" || !dd) continue;
-    const d = dd;
-    let troughDate = "-";
-    let recoveryDate = "not recovered";
-    const plotData = d.plot_data;
-    if (plotData && plotData.length > 0) {
-      let minDD = 0;
-      let minIdx = -1;
-      for (let i = 0; i < plotData.length; i++) {
-        if (plotData[i].drawdown < minDD) {
-          minDD = plotData[i].drawdown;
-          minIdx = i;
-        }
-      }
-      if (minIdx >= 0) {
-        troughDate = plotData[minIdx].date;
-        for (let i = minIdx + 1; i < plotData.length; i++) {
-          if (plotData[i].drawdown >= 0) {
-            recoveryDate = plotData[i].date;
-            break;
-          }
-        }
-      }
-    }
-    rows.push([
-      interval,
-      d.max_drawdown != null ? `${(Number(d.max_drawdown) * 100).toFixed(2)}%` : "-",
-      troughDate,
-      recoveryDate
-    ]);
-  }
-  if (rows.length === 0) return JSON.stringify(data, null, 2);
-  return makeTable(["Interval", "Max Drawdown", "Trough Date", "Recovery"], rows);
+function formatDrawdown(data, opts) {
+  const intervals = data?.interval_results;
+  if (!intervals) return JSON.stringify(data, null, 2);
+  const rows = Object.entries(intervals).map(([iv, r]) => [iv, fmt2(r.max_drawdown ?? r.error)]);
+  return makeTable(["Interval", "Max Drawdown"], rows, opts);
+}
+function fmt2(v) {
+  if (v == null) return "-";
+  const n = Number(v);
+  if (isNaN(n)) return String(v);
+  return `${(n * 100).toFixed(2)}%`;
 }
 
 // src/commands/macro.ts
 function registerMacroCommand(program2) {
   addGlobalOptions(
     program2.command("macro").description("Macroeconomic indicators (GDP, CPI, unemployment, fed funds, treasury, inflation)").option("--indicators <list>", "Comma-separated: GDP,CPI,UNEMPLOYMENT,FED_FUNDS,TREASURY_10Y,INFLATION")
-  ).action(async (opts) => {
+  ).addHelpText("after", `
+Examples:
+  $ bloom macro                                      All macro indicators
+  $ bloom macro --indicators GDP,CPI,UNEMPLOYMENT    Specific indicators only
+  $ bloom macro --indicators FED_FUNDS,TREASURY_10Y  Interest rates
+`).action(async (opts) => {
     const args = {};
     if (opts.indicators) {
       args.indicators = opts.indicators;
     }
-    const data = await callTool("get_macro_indicators", args);
+    const data = await BloomClient.instance().getMacro(args);
     outputResult(data, opts, formatMacro);
   });
 }
@@ -1255,8 +1929,12 @@ function formatMacro(data) {
 function registerSectorsCommand(program2) {
   addGlobalOptions(
     program2.command("sectors").description("Sector performance across time periods")
-  ).action(async (opts) => {
-    const data = await callTool("get_sector_performance", {});
+  ).addHelpText("after", `
+Examples:
+  $ bloom sectors           Sector performance across all time periods
+  $ bloom sectors -f json   Output as JSON
+`).action(async (opts) => {
+    const data = await BloomClient.instance().getSectors();
     outputResult(data, opts, formatSectors);
   });
 }
@@ -1309,9 +1987,13 @@ function formatSectors(data) {
 function registerDcfCommand(program2) {
   addGlobalOptions(
     program2.command("dcf").description("Discounted cash flow valuation").argument("<symbol>", "Ticker symbol")
-  ).action(async (symbol, opts) => {
+  ).addHelpText("after", `
+Examples:
+  $ bloom dcf AAPL   Discounted cash flow valuation for Apple
+  $ bloom dcf TSLA   DCF valuation for Tesla
+`).action(async (symbol, opts) => {
     const sym = symbol.toUpperCase();
-    const result = await callTool("get_dcf_valuation", { symbol: sym });
+    const result = await BloomClient.instance().getDcf(sym);
     outputResult(result, opts, () => formatDcf(result, sym));
   });
 }
@@ -1335,34 +2017,27 @@ function formatDcf(data, symbol) {
 // src/commands/holders.ts
 function registerHoldersCommand(program2) {
   addGlobalOptions(
-    program2.command("holders").description("Institutional and mutual fund holders").argument("<symbol>", "Ticker symbol").option("--type <t>", "institutional or mutual-fund (default: both)").option("--limit <n>", "Max holders to show", "15")
-  ).action(async (symbol, opts) => {
+    program2.command("holders").description("Institutional holders of a stock").argument("<symbol>", "Ticker symbol")
+  ).addHelpText("after", `
+Examples:
+  $ bloom holders AAPL     Top institutional holders of Apple
+  $ bloom holders TSLA     Tesla's institutional ownership
+`).action(async (symbol, opts) => {
     const sym = symbol.toUpperCase();
-    const limit = parseIntSafe(opts.limit, 15);
-    const args = { symbol: sym };
-    if (opts.type) args.holder_type = opts.type;
-    const data = await callTool("get_holders", args);
-    outputResult(data, opts, () => formatHolders(data, limit));
+    const data = await BloomClient.instance().getHolders(sym);
+    outputResult(data, opts, formatHolders);
   });
 }
-function formatHolders(data, limit) {
-  const parts = [];
-  const addSection = (title, list) => {
-    const items = list;
-    if (items && items.length > 0) {
-      const rows = items.slice(0, limit).map((h) => [
-        String(h.holder ?? "-"),
-        fmtNum2(h.shares),
-        h.dateReported ? String(h.dateReported).slice(0, 10) : "-",
-        fmtNum2(h.change)
-      ]);
-      parts.push(`${title}
-${makeTable(["Holder", "Shares", "Date", "Change"], rows)}`);
-    }
-  };
-  addSection("INSTITUTIONAL HOLDERS", data.institutional);
-  addSection("MUTUAL FUND HOLDERS", data.mutual_fund);
-  return parts.length > 0 ? parts.join("\n\n") : "(no holder data found)";
+function formatHolders(data) {
+  if (!Array.isArray(data) || data.length === 0) return "(no holders data)";
+  const rows = data.map((h) => [
+    String(h.holder ?? "-"),
+    fmtNum2(h.shares),
+    h.dateReported ? String(h.dateReported).slice(0, 10) : "-",
+    h.change != null ? String(h.change) : "-",
+    h.weightPercent != null ? `${Number(h.weightPercent).toFixed(2)}%` : "-"
+  ]);
+  return makeTable(["Holder", "Shares", "Date", "Change", "Weight %"], rows);
 }
 function fmtNum2(v) {
   if (v == null) return "-";
@@ -1378,10 +2053,14 @@ function fmtNum2(v) {
 function registerShortInterestCommand(program2) {
   addGlobalOptions(
     program2.command("short-interest").description("Short interest history").argument("<symbol>", "Ticker symbol").option("--limit <n>", "Number of records", "10")
-  ).action(async (symbol, opts) => {
+  ).addHelpText("after", `
+Examples:
+  $ bloom short-interest GME              Short interest history for GameStop
+  $ bloom short-interest AMC --limit 20   Last 20 short interest records
+`).action(async (symbol, opts) => {
     const sym = symbol.toUpperCase();
-    const limit = parseIntSafe(opts.limit, 10);
-    const data = await callTool("get_short_interest", { symbol: sym, limit });
+    const limit = parseIntArg(opts.limit, "--limit");
+    const data = await BloomClient.instance().getShortInterest(sym, limit);
     outputResult(data, opts, formatShort);
   });
 }
@@ -1410,29 +2089,28 @@ function fmtNum3(v) {
 // src/commands/insider.ts
 function registerInsiderCommand(program2) {
   addGlobalOptions(
-    program2.command("insider").description("Insider trading activity (SEC Form 4)").argument("<symbol>", "Ticker symbol").option("--limit <n>", "Max transactions to show", "20")
-  ).action(async (symbol, opts) => {
+    program2.command("insider").description("Insider trading activity").argument("<symbol>", "Ticker symbol").option("--limit <n>", "Max records", "20")
+  ).addHelpText("after", `
+Examples:
+  $ bloom insider AAPL              Recent insider trades for Apple
+  $ bloom insider TSLA --limit 10   Last 10 insider transactions
+`).action(async (symbol, opts) => {
     const sym = symbol.toUpperCase();
-    const limit = parseIntSafe(opts.limit, 20);
-    const data = await callTool("get_insider_trading", { symbol: sym, limit });
+    const limit = parseIntArg(opts.limit, "--limit");
+    const data = await BloomClient.instance().getInsider(sym, limit);
     outputResult(data, opts, formatInsider);
   });
 }
 function formatInsider(data) {
-  if (!Array.isArray(data) || data.length === 0) return "(no insider trading data)";
-  const rows = data.map((t) => {
-    const val = t.securitiesTransacted && t.price ? `$${(Number(t.securitiesTransacted) * Number(t.price)).toLocaleString()}` : "-";
-    return [
-      String(t.filingDate ?? t.transactionDate ?? "-").slice(0, 10),
-      String(t.reportingName ?? "-"),
-      String(t.typeOfOwner ?? "-"),
-      String(t.transactionType ?? t.acquistionOrDisposition ?? "-"),
-      fmtNum4(t.securitiesTransacted),
-      t.price != null ? `$${Number(t.price).toFixed(2)}` : "-",
-      val
-    ];
-  });
-  return makeTable(["Date", "Name", "Title", "Type", "Shares", "Price", "Value"], rows);
+  if (!Array.isArray(data) || data.length === 0) return "(no insider data)";
+  const rows = data.map((r) => [
+    String(r.filingDate ?? r.date ?? "-").slice(0, 10),
+    String(r.reportingName ?? r.name ?? "-"),
+    String(r.transactionType ?? r.type ?? "-"),
+    r.securitiesTransacted != null ? fmtNum4(r.securitiesTransacted) : "-",
+    r.price != null ? `$${Number(r.price).toFixed(2)}` : "-"
+  ]);
+  return makeTable(["Date", "Name", "Type", "Shares", "Price"], rows);
 }
 function fmtNum4(v) {
   if (v == null) return "-";
@@ -1445,12 +2123,17 @@ function fmtNum4(v) {
 function registerDividendsCommand(program2) {
   addGlobalOptions(
     program2.command("dividends").description("Dividend history for a stock").argument("<symbol>", "Ticker symbol").option("--limit <n>", "Number of records", "20").option("--from <date>", "Start date (YYYY-MM-DD)")
-  ).action(async (symbol, opts) => {
+  ).addHelpText("after", `
+Examples:
+  $ bloom dividends KO                       Dividend history for Coca-Cola
+  $ bloom dividends AAPL --limit 8           Last 8 dividends
+  $ bloom dividends JNJ --from 2024-01-01    Dividends since Jan 2024
+`).action(async (symbol, opts) => {
     const sym = symbol.toUpperCase();
-    const limit = parseIntSafe(opts.limit, 20);
+    const limit = parseIntArg(opts.limit, "--limit");
     const args = { symbol: sym, limit };
     if (opts.from) args.from_date = opts.from;
-    const data = await callTool("get_dividends", args);
+    const data = await BloomClient.instance().getDividends(args);
     outputResult(data, opts, formatDividends);
   });
 }
@@ -1471,11 +2154,15 @@ function formatDividends(data) {
 function registerSplitsCommand(program2) {
   addGlobalOptions(
     program2.command("splits").description("Stock split history").argument("<symbol>", "Ticker symbol").option("--from <date>", "Start date (YYYY-MM-DD)")
-  ).action(async (symbol, opts) => {
+  ).addHelpText("after", `
+Examples:
+  $ bloom splits AAPL                    Stock split history for Apple
+  $ bloom splits TSLA --from 2020-01-01  Splits since 2020
+`).action(async (symbol, opts) => {
     const sym = symbol.toUpperCase();
     const args = { symbol: sym };
     if (opts.from) args.from_date = opts.from;
-    const data = await callTool("get_splits", args);
+    const data = await BloomClient.instance().getSplits(args);
     outputResult(data, opts, formatSplits);
   });
 }
@@ -1491,27 +2178,30 @@ function formatSplits(data) {
 // src/commands/ipo.ts
 function registerIpoCommand(program2) {
   addGlobalOptions(
-    program2.command("ipo").description("Upcoming and recent IPOs").option("--from <date>", "Start date (YYYY-MM-DD)").option("--to <date>", "End date (YYYY-MM-DD)")
-  ).action(async (opts) => {
+    program2.command("ipo").description("IPO calendar and recent filings").option("--from <date>", "Start date (YYYY-MM-DD)").option("--to <date>", "End date (YYYY-MM-DD)")
+  ).addHelpText("after", `
+Examples:
+  $ bloom ipo                           Upcoming and recent IPOs
+  $ bloom ipo --from 2025-01-01        IPOs since Jan 2025
+`).action(async (opts) => {
     const args = {};
     if (opts.from) args.from_date = opts.from;
     if (opts.to) args.to_date = opts.to;
-    const data = await callTool("get_ipo_calendar", args);
-    outputResult(data, opts, formatIpos);
+    const data = await BloomClient.instance().getIpo(args);
+    outputResult(data, opts, formatIpo);
   });
 }
-function formatIpos(data) {
-  const ipos = Array.isArray(data) ? data : data?.ipos;
-  if (!Array.isArray(ipos) || ipos.length === 0) return "(no IPO data found)";
-  const rows = ipos.map((ipo) => [
-    String(ipo.date ?? ipo.start_date ?? "-"),
-    String(ipo.name ?? ipo.company ?? "-"),
-    String(ipo.code ?? ipo.ticker ?? ipo.symbol ?? "-"),
-    String(ipo.exchange ?? "-"),
-    ipo.price_from && ipo.price_to ? `$${ipo.price_from}-$${ipo.price_to}` : ipo.price ? `$${ipo.price}` : "-",
-    ipo.shares ? fmtNum5(ipo.shares) : "-"
+function formatIpo(data) {
+  if (!Array.isArray(data) || data.length === 0) return "(no IPO data)";
+  const rows = data.map((r) => [
+    String(r.date ?? "-"),
+    String(r.symbol ?? "-"),
+    String(r.company ?? r.name ?? "-"),
+    String(r.exchange ?? "-"),
+    r.priceRange ? String(r.priceRange) : "-",
+    r.shares ? fmtNum5(r.shares) : "-"
   ]);
-  return makeTable(["Date", "Company", "Symbol", "Exchange", "Price Range", "Shares"], rows);
+  return makeTable(["Date", "Symbol", "Company", "Exchange", "Price Range", "Shares"], rows);
 }
 function fmtNum5(v) {
   if (v == null) return "-";
@@ -1525,9 +2215,14 @@ function fmtNum5(v) {
 function registerCompareCommand(program2) {
   addGlobalOptions(
     program2.command("compare").description("Side-by-side comparison of stocks").argument("<symbols...>", "Ticker symbols (2-10)")
-  ).action(async (symbols, opts) => {
+  ).addHelpText("after", `
+Examples:
+  $ bloom compare AAPL MSFT            Side-by-side comparison
+  $ bloom compare AAPL MSFT GOOGL AMZN Compare big tech stocks
+  $ bloom compare TSLA RIVN LCID       Compare EV manufacturers
+`).action(async (symbols, opts) => {
     const syms = symbols.map((s) => s.toUpperCase()).slice(0, 10);
-    const data = await callTool("get_symbols_metadata", { symbols: syms });
+    const data = await BloomClient.instance().compare(syms);
     outputResult(data, opts, (d) => formatComparison(d, syms));
   });
 }
@@ -1538,12 +2233,10 @@ function formatComparison(data, symbols) {
   const metrics = [
     ["Price", "latest_price", "$"],
     ["Market Cap", "market_cap", "cap"],
-    ["P/E", "pe_ratio", ""],
-    ["EPS", "eps", "$"],
+    ["P/E", "price_to_earnings", ""],
     ["Dividend Yield", "dividend_yield", "%"],
     ["52W High", "week_52_high", "$"],
     ["52W Low", "week_52_low", "$"],
-    ["Beta", "beta", ""],
     ["Sector", "sector", ""]
   ];
   const bySymbol = {};
@@ -1554,15 +2247,15 @@ function formatComparison(data, symbols) {
     bySymbol[sym] = meta;
   }
   const headers = ["Metric", ...symbols];
-  const rows = metrics.map(([label, key, fmt2]) => {
+  const rows = metrics.map(([label, key, fmt3]) => {
     const vals = symbols.map((s) => {
       const meta = bySymbol[s];
       if (!meta) return "-";
       const v = meta[key];
       if (v == null) return "-";
-      if (fmt2 === "$") return `$${Number(v).toFixed(2)}`;
-      if (fmt2 === "%") return `${(Number(v) * 100).toFixed(2)}%`;
-      if (fmt2 === "cap") return fmtCap(v);
+      if (fmt3 === "$") return `$${Number(v).toFixed(2)}`;
+      if (fmt3 === "%") return `${(Number(v) * 100).toFixed(2)}%`;
+      if (fmt3 === "cap") return fmtCap(v);
       return String(v);
     });
     return [label, ...vals];
@@ -1582,10 +2275,14 @@ function fmtCap(v) {
 function registerRatingsCommand(program2) {
   addGlobalOptions(
     program2.command("ratings").description("Analyst ratings, grades, and price targets").argument("<symbol>", "Ticker symbol").option("--limit <n>", "Max records to show", "20")
-  ).action(async (symbol, opts) => {
+  ).addHelpText("after", `
+Examples:
+  $ bloom ratings AAPL              Analyst ratings and price targets
+  $ bloom ratings NVDA --limit 5    Last 5 analyst actions
+`).action(async (symbol, opts) => {
     const sym = symbol.toUpperCase();
-    const limit = parseIntSafe(opts.limit, 20);
-    const result = await callTool("get_analyst_ratings", { symbol: sym, limit });
+    const limit = parseIntArg(opts.limit, "--limit");
+    const result = await BloomClient.instance().getRatings(sym, limit);
     outputResult(result, opts, () => {
       const obj = result;
       return formatRatings(obj.grades, obj.estimates);
@@ -1625,16 +2322,447 @@ function fmtNum6(v) {
   return `$${n.toLocaleString()}`;
 }
 
+// src/commands/analytics.ts
+import { writeFileSync as writeFileSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync4 } from "fs";
+import { dirname as dirname2 } from "path";
+function parseHoldings(input) {
+  let raw = input;
+  try {
+    raw = readFileSync4(input, "utf8");
+  } catch {
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (Array.isArray(parsed)) {
+      return parsed.map((h) => ({
+        symbol: String(h.symbol).toUpperCase(),
+        value: Number(h.value),
+        cost_basis: h.cost_basis !== void 0 ? Number(h.cost_basis) : void 0,
+        shares: h.shares !== void 0 ? Number(h.shares) : void 0
+      }));
+    }
+    return Object.entries(parsed).map(([symbol, value]) => ({
+      symbol: symbol.toUpperCase(),
+      value: Number(value)
+    }));
+  } catch {
+    const parts = raw.split(",").map((s) => s.trim()).filter(Boolean);
+    return parts.map((p) => {
+      const [sym, val] = p.split("=");
+      if (!sym || !val) {
+        throw new Error(`Invalid holding: ${p}. Use 'AAPL=145000' format.`);
+      }
+      return { symbol: sym.toUpperCase().trim(), value: Number(val) };
+    });
+  }
+}
+var DIVIDER = "\u2500".repeat(60);
+function fmtMoney(n) {
+  if (n >= 1e6) return `$${(n / 1e6).toFixed(2)}M`;
+  if (n >= 1e3) return `$${(n / 1e3).toFixed(1)}K`;
+  return `$${n.toFixed(0)}`;
+}
+function fmtPct(n, signed = false) {
+  const v = (n * 100).toFixed(1);
+  return signed && n >= 0 ? `+${v}%` : `${v}%`;
+}
+function bar(pct, width = 16) {
+  const filled = Math.round(pct * width);
+  return "\u2588".repeat(Math.max(0, filled)) + " ".repeat(Math.max(0, width - filled));
+}
+function renderText(data) {
+  const lines = [];
+  const s = data.summary;
+  const headerParts = [fmtMoney(s.total_value)];
+  if (s.ytd_return !== null && s.ytd_return !== void 0) {
+    headerParts.push(`${fmtPct(s.ytd_return, true)} YTD`);
+  }
+  if (s.vs_spy !== null && s.vs_spy !== void 0) {
+    headerParts.push(`${fmtPct(s.vs_spy, true)} SPY`);
+  }
+  lines.push("");
+  lines.push("  " + headerParts.join("  \u2022  "));
+  lines.push("");
+  lines.push("  " + s.headline_insight);
+  lines.push("");
+  lines.push("  " + DIVIDER);
+  lines.push("");
+  lines.push("  CONCENTRATION");
+  lines.push("");
+  for (const sec of data.concentration.by_sector) {
+    const name = sec.name.padEnd(14);
+    lines.push(`  ${name} ${bar(sec.pct)}  ${fmtPct(sec.pct)}`);
+  }
+  lines.push("");
+  lines.push("  " + data.concentration.insight);
+  lines.push("");
+  lines.push("  " + DIVIDER);
+  lines.push("");
+  lines.push("  HOW YOU TRADE");
+  lines.push("");
+  if (!data.behavior.available) {
+    lines.push("  " + (data.behavior.reason || "Not enough trade history yet."));
+  } else {
+    if (data.behavior.insight) lines.push("  " + data.behavior.insight);
+    lines.push("");
+    for (const s2 of data.behavior.strengths) lines.push(`  \u2713 ${s2.text}`);
+    for (const w of data.behavior.weaknesses) lines.push(`  \u26A0 ${w.text}`);
+  }
+  lines.push("");
+  lines.push("  " + DIVIDER);
+  lines.push("");
+  lines.push("  RISK");
+  lines.push("");
+  const r = data.risk;
+  if (r.volatility && r.volatility.value != null) {
+    lines.push(
+      `  Volatility    ${r.volatility.label.padEnd(8)} ${fmtPct(r.volatility.value)}`
+    );
+  }
+  if (r.correlation_spy != null) {
+    const label = r.correlation_spy >= 0.8 ? "High" : r.correlation_spy >= 0.5 ? "Med" : "Low";
+    lines.push(
+      `  Correlation   ${label.padEnd(8)} ${r.correlation_spy.toFixed(2)} to SPY`
+    );
+  }
+  if (r.max_drawdown != null) {
+    lines.push(`  Max drawdown           ${fmtPct(r.max_drawdown)}`);
+  }
+  if (r.sharpe != null) {
+    lines.push(`  Sharpe                 ${r.sharpe.toFixed(2)}`);
+  }
+  lines.push("");
+  lines.push("  " + r.insight);
+  lines.push("");
+  lines.push("  " + DIVIDER);
+  lines.push("");
+  lines.push("  WHAT TO WATCH");
+  lines.push("");
+  if (data.watch.alerts.length === 0) {
+    lines.push("  Nothing flagged.");
+  } else {
+    for (const w of data.watch.alerts) {
+      lines.push(`  ${w.ticker.padEnd(6)} ${w.reason}`);
+    }
+  }
+  lines.push("");
+  lines.push("  " + DIVIDER);
+  lines.push("");
+  lines.push("  PROJECTION");
+  lines.push("");
+  for (const p of data.projection.points) {
+    if (p.year === 0) continue;
+    lines.push(
+      `  ${`${p.year}Y`.padEnd(4)}  p10 ${fmtMoney(p.p10)}   p50 ${fmtMoney(p.p50)}   p90 ${fmtMoney(p.p90)}`
+    );
+  }
+  lines.push("");
+  lines.push("  " + data.projection.disclaimer);
+  lines.push("");
+  return lines.join("\n");
+}
+function renderMarkdown(data) {
+  const lines = [];
+  const s = data.summary;
+  lines.push("# Portfolio Analytics");
+  lines.push("");
+  const hp = [`**${fmtMoney(s.total_value)}**`];
+  if (s.ytd_return != null) hp.push(`${fmtPct(s.ytd_return, true)} YTD`);
+  if (s.vs_spy != null) hp.push(`${fmtPct(s.vs_spy, true)} SPY`);
+  lines.push(hp.join(" \u2022 "));
+  lines.push("");
+  lines.push(`> ${s.headline_insight}`);
+  lines.push("");
+  lines.push("## Concentration");
+  lines.push("");
+  lines.push("| Sector | Allocation | Value |");
+  lines.push("|---|---|---|");
+  for (const sec of data.concentration.by_sector) {
+    lines.push(`| ${sec.name} | ${fmtPct(sec.pct)} | ${fmtMoney(sec.value)} |`);
+  }
+  lines.push("");
+  lines.push(data.concentration.insight);
+  lines.push("");
+  lines.push("## How You Trade");
+  lines.push("");
+  if (!data.behavior.available) {
+    lines.push(data.behavior.reason || "Not enough trade history yet.");
+  } else {
+    if (data.behavior.insight) {
+      lines.push(data.behavior.insight);
+      lines.push("");
+    }
+    for (const x of data.behavior.strengths) lines.push(`- \u2713 ${x.text}`);
+    for (const x of data.behavior.weaknesses) lines.push(`- \u26A0 ${x.text}`);
+  }
+  lines.push("");
+  lines.push("## Risk");
+  lines.push("");
+  const r = data.risk;
+  if (r.volatility && r.volatility.value != null) lines.push(`- Volatility: ${r.volatility.label} (${fmtPct(r.volatility.value)})`);
+  if (r.correlation_spy != null) lines.push(`- Correlation to SPY: ${r.correlation_spy.toFixed(2)}`);
+  if (r.max_drawdown != null) lines.push(`- Max drawdown: ${fmtPct(r.max_drawdown)}`);
+  if (r.sharpe != null) lines.push(`- Sharpe: ${r.sharpe.toFixed(2)}`);
+  lines.push("");
+  lines.push(r.insight);
+  lines.push("");
+  lines.push("## What to Watch");
+  lines.push("");
+  if (data.watch.alerts.length === 0) {
+    lines.push("Nothing flagged.");
+  } else {
+    for (const w of data.watch.alerts) {
+      lines.push(`- **${w.ticker}** \u2014 ${w.reason}`);
+    }
+  }
+  lines.push("");
+  lines.push("## Projection");
+  lines.push("");
+  lines.push("| Year | p10 | p50 | p90 |");
+  lines.push("|---|---|---|---|");
+  for (const p of data.projection.points) {
+    lines.push(`| ${p.year}Y | ${fmtMoney(p.p10)} | ${fmtMoney(p.p50)} | ${fmtMoney(p.p90)} |`);
+  }
+  lines.push("");
+  lines.push(`*${data.projection.disclaimer}*`);
+  return lines.join("\n");
+}
+function emit2(content, opts) {
+  if (opts.output) {
+    mkdirSync5(dirname2(opts.output), { recursive: true });
+    writeFileSync5(opts.output, content, "utf8");
+    if (!opts.quiet) console.error(`Wrote ${opts.output}`);
+  } else {
+    console.log(content);
+  }
+}
+function registerAnalyticsCommand(program2) {
+  addGlobalOptions(
+    program2.command("analytics").description(
+      "One-page portfolio analytics: concentration, risk, watch, projection"
+    ).argument(
+      "<holdings>",
+      "Holdings as JSON, file path, or shorthand (e.g. 'AAPL=145000,MSFT=91000')"
+    ).option(
+      "--section <s>",
+      "Show only one section: concentration, behavior, risk, watch, projection"
+    ).option("--md", "Output as markdown (alias for --format markdown)")
+  ).action(
+    async (holdingsInput, opts) => {
+      let holdings;
+      try {
+        holdings = parseHoldings(holdingsInput);
+      } catch (e) {
+        console.error(`Error parsing holdings: ${e.message}`);
+        process.exit(1);
+      }
+      const result = await callTool("analyze_portfolio", {
+        holdings,
+        parts: [
+          "summary",
+          "concentration",
+          "asset_class",
+          "geography",
+          "behavior",
+          "risk",
+          "watch",
+          "projection"
+        ]
+      });
+      if (result && typeof result === "object" && "error" in result && result.error) {
+        console.error(`Error: ${result.error}`);
+        process.exit(1);
+      }
+      const data = result;
+      if (opts.raw) {
+        emit2(JSON.stringify(data, null, 2), opts);
+        return;
+      }
+      let payload = data;
+      if (opts.section) {
+        const sec = opts.section.toLowerCase();
+        const map = {
+          summary: data.summary,
+          concentration: data.concentration,
+          behavior: data.behavior,
+          risk: data.risk,
+          watch: data.watch,
+          projection: data.projection
+        };
+        if (!(sec in map)) {
+          console.error(
+            `Unknown section: ${sec}. Choose: summary, concentration, behavior, risk, watch, projection`
+          );
+          process.exit(1);
+        }
+        payload = map[sec];
+      }
+      const fmt3 = opts.md ? "markdown" : opts.format ?? resolveFormat(opts);
+      if (fmt3 === "json") {
+        emit2(JSON.stringify(payload, null, 2), opts);
+        return;
+      }
+      if (fmt3 === "markdown") {
+        if (opts.section) {
+          emit2(JSON.stringify(payload, null, 2), opts);
+        } else {
+          emit2(renderMarkdown(data), opts);
+        }
+        return;
+      }
+      if (opts.section) {
+        emit2(JSON.stringify(payload, null, 2), opts);
+      } else {
+        emit2(renderText(data), opts);
+      }
+    }
+  );
+}
+
+// src/commands/stats.ts
+function registerStatsCommand(program2) {
+  addGlobalOptions(
+    program2.command("stats").description("Key stats: beta, 52-week range, volume, P/E, dividend yield").argument("<symbol>", "Ticker symbol")
+  ).addHelpText("after", `
+Examples:
+  $ bloom stats AAPL          Key statistics for Apple
+  $ bloom stats TSLA -f json  Stats as JSON
+`).action(async (symbol, opts) => {
+    const data = await BloomClient.instance().getStats(symbol.toUpperCase());
+    outputResult(data, opts);
+  });
+}
+
+// src/commands/peers.ts
+function registerPeersCommand(program2) {
+  addGlobalOptions(
+    program2.command("peers").description("Peer companies and competitors").argument("<symbol>", "Ticker symbol")
+  ).addHelpText("after", `
+Examples:
+  $ bloom peers AAPL          Companies similar to Apple
+  $ bloom peers TSLA          Tesla's peer group
+`).action(async (symbol, opts) => {
+    const data = await BloomClient.instance().getPeers(symbol.toUpperCase());
+    outputResult(data, opts, formatPeers);
+  });
+}
+function formatPeers(data, opts) {
+  const peers = data?.results;
+  if (!Array.isArray(peers)) return JSON.stringify(data, null, 2);
+  const num = (v, f) => v == null || v === "" || isNaN(Number(v)) ? "-" : f(Number(v));
+  const pct = (n) => `${(n * 100).toFixed(2)}%`;
+  const cap = (n) => n >= 1e12 ? `$${(n / 1e12).toFixed(2)}T` : n >= 1e9 ? `$${(n / 1e9).toFixed(2)}B` : `$${(n / 1e6).toFixed(2)}M`;
+  const rows = peers.map((p) => [
+    String(p.symbol ?? ""),
+    truncate(String(p.name ?? ""), 32),
+    String(p.sector || p.category || ""),
+    num(p.latestPrice, (n) => `$${n.toFixed(2)}`),
+    num(p.changePercent1d, pct),
+    num(p.changePercent1y, pct),
+    num(p.priceToEarnings, (n) => n.toFixed(2)),
+    num(p.marketCap, cap)
+  ]);
+  return makeTable(["Symbol", "Name", "Sector", "Price", "1D", "1Y", "P/E", "Mkt Cap"], rows, opts);
+}
+
+// src/commands/bottom-line.ts
+function registerBottomLineCommand(program2) {
+  addGlobalOptions(
+    program2.command("bottom-line").description("Buy/sell/hold verdict with reasoning").argument("<symbol>", "Ticker symbol")
+  ).addHelpText("after", `
+Examples:
+  $ bloom bottom-line AAPL    Bloom's bottom line on Apple
+  $ bloom bottom-line NVDA    Buy/sell/hold verdict for NVIDIA
+`).action(async (symbol, opts) => {
+    const data = await BloomClient.instance().getBottomLine(symbol.toUpperCase());
+    outputResult(data, opts, formatBottomLine);
+  });
+}
+function formatBottomLine(data, opts) {
+  const bl = data?.results;
+  if (!bl?.verdict) return JSON.stringify(data, null, 2);
+  const rows = bl.details.map((d) => [d.rating, d.title, d.descriptions.map((x) => `- ${x}`).join("\n")]);
+  const table = makeTable(["Rating", "Area", "Reasoning"], rows, opts);
+  return [`${bl.symbol}: ${bl.verdict}`, ...bl.lead ? [bl.lead] : [], "", table].join("\n");
+}
+
+// src/commands/insights.ts
+function registerInsightsCommand(program2) {
+  addGlobalOptions(
+    program2.command("insights").description("AI-generated insights for stocks").argument("[symbols...]", "Ticker symbols (omit for all recent)")
+  ).addHelpText("after", `
+Examples:
+  $ bloom insights AAPL           Insights for Apple
+  $ bloom insights AAPL MSFT      Insights for multiple stocks
+  $ bloom insights                All recent insights
+`).action(async (symbols, opts) => {
+    if (symbols.length === 1) {
+      const data = await BloomClient.instance().getInsights(symbols[0].toUpperCase());
+      outputResult(data, opts);
+    } else {
+      const syms = symbols.length > 0 ? symbols.map((s) => s.toUpperCase()) : void 0;
+      const data = await BloomClient.instance().getInsights(void 0, syms);
+      outputResult(data, opts);
+    }
+  });
+}
+
+// src/commands/arena-activity.ts
+function registerArenaActivityCommand(program2) {
+  addGlobalOptions(
+    program2.command("arena-activity").description("Live AI arena trade activity feed").option("--model <m>", "Filter by model: claude, openai, gemini").option("--limit <n>", "Max results", "20")
+  ).addHelpText("after", `
+Examples:
+  $ bloom arena-activity                    All recent arena trades
+  $ bloom arena-activity --model claude     Claude's trades only
+  $ bloom arena-activity --limit 5          Last 5 trades
+`).action(async (opts) => {
+    const limit = parseIntArg(opts.limit, "--limit");
+    const data = await BloomClient.instance().getArenaActivity(opts.model, limit);
+    outputResult(data, opts);
+  });
+}
+
+// src/commands/portfolio-news.ts
+function registerPortfolioNewsCommand(program2) {
+  addGlobalOptions(
+    program2.command("portfolio-news").description("Smart news summary for portfolio symbols").argument("[symbols...]", "Ticker symbols")
+  ).addHelpText("after", `
+Examples:
+  $ bloom portfolio-news AAPL MSFT GOOG    News digest for holdings
+  $ bloom portfolio-news                   News for all watched symbols
+`).action(async (symbols, opts) => {
+    const syms = symbols.length > 0 ? symbols.map((s) => s.toUpperCase()) : void 0;
+    const data = await BloomClient.instance().getPortfolioNews(syms);
+    outputResult(data, opts);
+  });
+}
+
+// src/commands/collection-returns.ts
+function registerCollectionReturnsCommand(program2) {
+  addGlobalOptions(
+    program2.command("collection-returns").description("Performance returns for the given collections").requiredOption("--ids <ids>", "Comma-separated collection IDs (from `bloom collections`)").option("--timerange <range>", "1d|1w|1m|3m|ytd|1y|5y", "ytd")
+  ).addHelpText("after", `
+Examples:
+  $ bloom collection-returns --ids 113                  YTD return for collection 113
+  $ bloom collection-returns --ids 113,114 --timerange 1y
+  $ bloom collection-returns --ids 113 -f table         As table
+`).action(async (opts) => {
+    const data = await BloomClient.instance().getCollectionReturns(opts.ids, opts.timerange);
+    outputResult(data, opts);
+  });
+}
+
 // src/index.ts
-var program = new Command();
+var program = new Command3();
 var __dirname = path.dirname(fileURLToPath(import.meta.url));
 var pkgPath = path.join(__dirname, "..", "package.json");
-var compiledVersion = "0.1.5".length > 0 ? "0.1.5" : void 0;
+var compiledVersion = "0.1.7".length > 0 ? "0.1.7" : void 0;
 var envVersion = process.env.BLOOM_CLI_VERSION ?? process.env.npm_package_version;
 var fallbackVersion = compiledVersion ?? "unknown";
 var cliVersion = envVersion ?? fallbackVersion;
 try {
-  const pkg = JSON.parse(readFileSync2(pkgPath, "utf8"));
+  const pkg = JSON.parse(readFileSync5(pkgPath, "utf8"));
   if (typeof pkg.version === "string") {
     cliVersion = pkg.version;
   }
@@ -1643,7 +2771,24 @@ try {
 if (cliVersion === "0.0.0") {
   cliVersion = fallbackVersion;
 }
-program.name("bloom").description("Bloom CLI \u2014 financial data for coding agents and humans").version(cliVersion);
+var config = loadConfig();
+if (config.apiBase !== "https://api.getbloom.app") {
+  setApiBase(config.apiBase);
+}
+setCacheDir(config.cacheDir);
+program.hook("preAction", (_thisCommand, actionCommand) => {
+  for (const [key, value] of Object.entries(program.opts())) {
+    if (program.getOptionValueSource(key) === "cli" && actionCommand.getOptionValueSource(key) !== "cli") {
+      actionCommand.setOptionValueWithSource(key, value, "cli");
+    }
+  }
+  const opts = actionCommand.opts();
+  if (opts.debug) setDebug(true);
+  if (opts.cache === false) setNoCache(true);
+});
+addGlobalOptions(
+  program.name("bloom").description("Bloom CLI \u2014 financial data for coding agents and humans").version(cliVersion).enablePositionalOptions()
+);
 registerAuthCommand(program);
 registerInfoCommand(program);
 registerNewsCommand(program);
@@ -1680,7 +2825,50 @@ registerSplitsCommand(program);
 registerIpoCommand(program);
 registerCompareCommand(program);
 registerRatingsCommand(program);
+registerAnalyticsCommand(program);
+registerStatsCommand(program);
+registerPeersCommand(program);
+registerBottomLineCommand(program);
+registerInsightsCommand(program);
+registerArenaActivityCommand(program);
+registerPortfolioNewsCommand(program);
+registerCollectionReturnsCommand(program);
+var cacheCmd = program.command("cache").description("Manage disk cache");
+cacheCmd.command("clear").description("Clear all cached data").action(() => {
+  const { cleared } = clearCache();
+  console.log(`Cleared ${cleared} cached items.`);
+});
+cacheCmd.command("stats").description("Show cache statistics").action(() => {
+  const stats = cacheStats();
+  console.log(`Cache directory: ${stats.cacheDir}`);
+  console.log(`Items: ${stats.items} (${stats.expired} expired)`);
+  console.log(`Total size: ${(stats.totalBytes / 1024).toFixed(1)} KB`);
+  if (Object.keys(stats.byCategory).length > 0) {
+    console.log("By category:");
+    for (const [cat, count] of Object.entries(stats.byCategory)) {
+      console.log(`  ${cat}: ${count}`);
+    }
+  }
+});
 program.parseAsync().catch((err) => {
-  console.error("Error:", err.message || err);
+  if (err instanceof AuthError) {
+    console.error(`Error: ${err.message}`);
+    console.error("Run `bloom auth login` to authenticate.");
+    process.exit(1);
+  }
+  if (err instanceof RateLimitError) {
+    console.error("Rate limited. Try again in a moment.");
+    process.exit(2);
+  }
+  if (err instanceof TickerNotFoundError) {
+    console.error(`Ticker not found: ${err.ticker}`);
+    process.exit(1);
+  }
+  if (err instanceof BloomError) {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+  }
+  const msg = err instanceof Error ? err.message : String(err);
+  console.error("Error:", msg);
   process.exit(1);
 });