@bloomai/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,805 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/auth.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var CONFIG_DIR = join(homedir(), ".config", "bloom-cli");
+var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+function readConfig() {
+  if (!existsSync(CONFIG_FILE)) return {};
+  try {
+    return JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeConfig(config) {
+  try {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+    writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n", {
+      mode: 384
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(
+      `Error: Could not write config to ${CONFIG_FILE}: ${msg}
+Try using BLOOM_API_KEY environment variable instead.`
+    );
+    process.exit(1);
+  }
+}
+function getApiKey() {
+  return process.env.BLOOM_API_KEY || readConfig().api_key;
+}
+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);
+  }
+  return key;
+}
+function login(apiKey) {
+  const config = readConfig();
+  config.api_key = apiKey;
+  writeConfig(config);
+  console.log("API key saved to " + CONFIG_FILE);
+}
+function logout() {
+  if (existsSync(CONFIG_FILE)) {
+    const config = readConfig();
+    delete config.api_key;
+    writeConfig(config);
+  }
+  console.log("Logged out. API key cleared.");
+}
+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 {
+    console.log("Not authenticated. Set BLOOM_API_KEY or run: bloom auth login");
+  }
+}
+function maskKey(key) {
+  if (key.length <= 8) return "****";
+  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 MCP_URL = "https://api.getbloom.app/mcp/";
+var requestId = 0;
+async function callTool(toolName, args) {
+  const apiKey = requireApiKey();
+  requestId++;
+  const body = {
+    jsonrpc: "2.0",
+    method: "tools/call",
+    params: {
+      name: toolName,
+      arguments: args
+    },
+    id: requestId
+  };
+  const res = await fetch(MCP_URL, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(body)
+  });
+  if (!res.ok) {
+    const text2 = await res.text().catch(() => "");
+    throw new Error(`API error ${res.status}: ${text2 || res.statusText}`);
+  }
+  const data = await res.json();
+  if (data.error) {
+    throw new Error(`MCP error ${data.error.code}: ${data.error.message}`);
+  }
+  if (!data.result?.content?.length) {
+    throw new Error("Empty response from API");
+  }
+  const text = data.result.content[0].text;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+
+// src/format.ts
+import Table from "cli-table3";
+import { writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { dirname } from "path";
+function resolveFormat(opts) {
+  if (opts.format) return opts.format;
+  if (opts.output || !process.stdout.isTTY) return "json";
+  return "table";
+}
+function outputResult(data, opts, tableFormatter) {
+  if (opts.raw) {
+    emit(JSON.stringify(data, null, 2), opts);
+    return;
+  }
+  const fmt = resolveFormat(opts);
+  if (fmt === "json") {
+    emit(JSON.stringify(data, null, 2), opts);
+    return;
+  }
+  if (fmt === "csv") {
+    emit(toCSV(data), opts);
+    return;
+  }
+  if (tableFormatter) {
+    emit(tableFormatter(data, opts), opts);
+  } else {
+    emit(autoTable(data, opts), opts);
+  }
+}
+function emit(content, opts) {
+  if (opts.output) {
+    mkdirSync2(dirname(opts.output), { recursive: true });
+    writeFileSync2(opts.output, content + "\n");
+    if (!opts.quiet) {
+      console.error(`Written to ${opts.output}`);
+    }
+  } else {
+    console.log(content);
+  }
+}
+function toCSV(data) {
+  const rows = toRows(data);
+  if (rows.length === 0) return "";
+  const headers = Object.keys(rows[0]);
+  const lines = [headers.join(",")];
+  for (const row of rows) {
+    lines.push(
+      headers.map((h) => {
+        const val = String(row[h] ?? "");
+        return val.includes(",") || val.includes('"') || val.includes("\n") ? `"${val.replace(/"/g, '""')}"` : val;
+      }).join(",")
+    );
+  }
+  return lines.join("\n");
+}
+function toRows(data) {
+  const flatten = (v) => flattenObj(v);
+  if (Array.isArray(data)) return data.map(flatten);
+  if (data && typeof data === "object") {
+    const obj = data;
+    for (const key of Object.keys(obj)) {
+      const val = obj[key];
+      if (Array.isArray(val) && val.length > 0 && typeof val[0] === "object" && val[0] !== null) {
+        return val.map(flatten);
+      }
+    }
+    for (const key of Object.keys(obj)) {
+      if (Array.isArray(obj[key]) && obj[key].length > 0) {
+        return obj[key].map(flatten);
+      }
+    }
+    return [flattenObj(obj)];
+  }
+  return [{ value: data }];
+}
+function flattenObj(obj, prefix = "") {
+  if (!obj || typeof obj !== "object") return { value: obj };
+  const result = {};
+  for (const [k, v] of Object.entries(obj)) {
+    const key = prefix ? `${prefix}.${k}` : k;
+    if (v && typeof v === "object" && !Array.isArray(v)) {
+      Object.assign(result, flattenObj(v, key));
+    } else if (Array.isArray(v)) {
+      if (v.length <= 3) {
+        result[key] = v.map(
+          (item) => item && typeof item === "object" ? JSON.stringify(item) : String(item)
+        ).join(", ");
+      } else {
+        result[key] = `[${v.length} items]`;
+      }
+    } else {
+      result[key] = v;
+    }
+  }
+  return result;
+}
+function autoTable(data, opts) {
+  const rows = toRows(data);
+  if (rows.length === 0) return "(no data)";
+  const headers = Object.keys(rows[0]);
+  const table = new Table({
+    head: opts?.quiet ? [] : headers,
+    style: { head: ["cyan"] },
+    wordWrap: true
+  });
+  for (const row of rows) {
+    table.push(headers.map((h) => truncate(String(row[h] ?? ""), 80)));
+  }
+  return table.toString();
+}
+function makeTable(headers, rows, opts) {
+  const table = new Table({
+    head: opts?.quiet ? [] : headers,
+    style: { head: ["cyan"] },
+    wordWrap: true
+  });
+  for (const row of rows) {
+    table.push(row);
+  }
+  return table.toString();
+}
+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;
+}
+
+// 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");
+}
+
+// src/commands/info.ts
+var VALID_FIELDS = [
+  "basic_metadata",
+  "bottom_line_ratings",
+  "embedded_expectations",
+  "peers",
+  "key_events",
+  "holdings"
+];
+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(","))
+  ).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);
+    outputResult(data, opts, (d) => formatInfo(d));
+  });
+}
+function formatInfo(data) {
+  if (!data || typeof data !== "object") return String(data);
+  const obj = data;
+  const sections = [];
+  for (const [key, val] of Object.entries(obj)) {
+    if (key === "timestamp" || key === "source") continue;
+    if (val && typeof val === "object") {
+      sections.push(`
+=== ${key.toUpperCase()} ===`);
+      sections.push(formatSection(val));
+    }
+  }
+  return sections.length > 0 ? sections.join("\n") : JSON.stringify(data, null, 2);
+}
+function formatSection(obj, indent = "") {
+  const lines = [];
+  for (const [k, v] of Object.entries(obj)) {
+    if (v && typeof v === "object" && !Array.isArray(v)) {
+      lines.push(`${indent}${k}:`);
+      lines.push(formatSection(v, indent + "  "));
+    } else if (Array.isArray(v)) {
+      if (v.length === 0) continue;
+      if (typeof v[0] === "string" || typeof v[0] === "number") {
+        lines.push(`${indent}${k}: ${v.join(", ")}`);
+      } else {
+        lines.push(`${indent}${k}:`);
+        for (const item of v) {
+          if (typeof item === "object" && item) {
+            const summary = Object.entries(item).slice(0, 4).map(([ik, iv]) => `${ik}=${iv}`).join("  ");
+            lines.push(`${indent}  - ${summary}`);
+          } else {
+            lines.push(`${indent}  - ${item}`);
+          }
+        }
+      }
+    } else {
+      lines.push(`${indent}${k}: ${v}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/commands/news.ts
+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)
+    });
+    outputResult(data, opts, (d, o) => formatNews(d, o));
+  });
+}
+function formatNews(data, opts) {
+  if (!data || typeof data !== "object") return String(data);
+  const obj = data;
+  let articles = [];
+  if (Array.isArray(data)) {
+    articles = data;
+  } else {
+    for (const val of Object.values(obj)) {
+      if (Array.isArray(val) && val.length > 0) {
+        articles = val;
+        break;
+      }
+    }
+  }
+  if (articles.length === 0) return "(no articles)";
+  const rows = articles.map((a) => [
+    String(a.date || a.published || a.created || "").slice(0, 16),
+    String(a.title || a.headline || "").slice(0, 80),
+    String(a.symbols || a.tickers || a.stocks || "").slice(0, 20),
+    String(a.channel || a.source || "")
+  ]);
+  return makeTable(["Date", "Title", "Symbols", "Channel"], rows, opts);
+}
+
+// src/commands/price.ts
+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
+    });
+    outputResult(data, opts, (d, o) => formatPrices(d, o));
+  });
+}
+function formatPrices(data, opts) {
+  if (!data || typeof data !== "object") return String(data);
+  const obj = data;
+  const sections = [];
+  for (const [tf, val] of Object.entries(obj)) {
+    if (tf === "symbol" || tf === "timestamp" || tf === "source" || tf === "type") continue;
+    if (!val || typeof val !== "object") continue;
+    const tfData = val;
+    let points = [];
+    if (Array.isArray(tfData)) {
+      points = tfData;
+    } else if (tfData.data && Array.isArray(tfData.data)) {
+      points = tfData.data;
+    } else if (tfData.prices && Array.isArray(tfData.prices)) {
+      points = tfData.prices;
+    } else {
+      for (const v of Object.values(tfData)) {
+        if (Array.isArray(v) && v.length > 0 && typeof v[0] === "object" && v[0] !== null) {
+          points = v;
+          break;
+        }
+      }
+    }
+    if (points.length === 0) continue;
+    sections.push(`
+--- ${tf.toUpperCase()} (${points.length} points) ---`);
+    const show = points.length <= 12 ? points : [
+      ...points.slice(0, 5),
+      { date: "...", price: "..." },
+      ...points.slice(-5)
+    ];
+    const rows = show.map((p) => [
+      String(p.date ?? p.datetime ?? p.timestamp ?? ""),
+      String(p.price ?? p.close ?? ""),
+      p.open != null ? String(p.open) : "",
+      p.high != null ? String(p.high) : "",
+      p.low != null ? String(p.low) : "",
+      p.volume != null ? String(p.volume) : ""
+    ]);
+    const headers = ["Date", "Price", "Open", "High", "Low", "Volume"];
+    sections.push(makeTable(headers, rows, opts));
+  }
+  return sections.join("\n") || JSON.stringify(data, null, 2);
+}
+
+// src/commands/financials.ts
+var CHART_TYPES = [
+  "revenue",
+  "revenue_growth",
+  "operating_margin",
+  "net_earnings",
+  "net_earnings_growth",
+  "free_cash_flow",
+  "free_cash_flow_growth"
+];
+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
+    });
+    outputResult(data, opts);
+  });
+}
+
+// src/commands/sentiment.ts
+var SECTIONS = [
+  "aaii_sentiment",
+  "cnn_fear_greed",
+  "volatility_analysis",
+  "momentum_analysis"
+];
+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);
+    outputResult(data, opts, (d) => formatSentiment(d));
+  });
+}
+function formatSentiment(data) {
+  if (!data || typeof data !== "object") return String(data);
+  const obj = data;
+  const lines = [];
+  for (const [section, val] of Object.entries(obj)) {
+    if (section === "timestamp" || section === "source") continue;
+    if (!val || typeof val !== "object") continue;
+    lines.push(`
+=== ${section.replace(/_/g, " ").toUpperCase()} ===`);
+    for (const [k, v] of Object.entries(val)) {
+      if (v && typeof v === "object" && !Array.isArray(v)) {
+        lines.push(`  ${k}:`);
+        for (const [ik, iv] of Object.entries(v)) {
+          lines.push(`    ${ik}: ${iv}`);
+        }
+      } else {
+        lines.push(`  ${k}: ${v}`);
+      }
+    }
+  }
+  return lines.join("\n") || JSON.stringify(data, null, 2);
+}
+
+// src/commands/market.ts
+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")
+  ).action(async (opts) => {
+    const data = await callTool("get_market_map", {
+      map_type: opts.type,
+      period: opts.period,
+      limit: parseIntSafe(opts.limit, 24)
+    });
+    outputResult(data, opts);
+  });
+}
+
+// src/commands/collections.ts
+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)
+    });
+    outputResult(data, opts);
+  });
+}
+
+// src/commands/screen.ts
+function registerScreenCommand(program2) {
+  addGlobalOptions(
+    program2.command("screen").description("Quantitative stock screener").argument("<filters...>", 'Filter expressions, e.g. "market_cap > 10B" "pe_ratio < 25"').option("--or", "Use OR logic (default: AND)").option("--limit <n>", "Max results", "50").option("--symbols <s>", "Comma-separated symbols to filter from").option("--fields <f>", "Comma-separated fields (use * for all)")
+  ).action(
+    async (filters, opts) => {
+      const args = {
+        filter_expressions: filters,
+        and_query: !opts.or,
+        limit: parseIntSafe(opts.limit, 50)
+      };
+      if (opts.symbols) {
+        args.symbols = opts.symbols.split(",").map((s) => s.trim().toUpperCase());
+      }
+      if (opts.fields) {
+        args.fields = opts.fields.split(",").map((f) => f.trim());
+      }
+      const data = await callTool("filter_stocks", args);
+      outputResult(data, opts, (d, o) => formatScreen(d, o));
+    }
+  );
+}
+function formatScreen(data, opts) {
+  if (!data || typeof data !== "object") return String(data);
+  const obj = data;
+  let stocks = [];
+  if (Array.isArray(data)) {
+    stocks = data;
+  } else {
+    for (const val of Object.values(obj)) {
+      if (Array.isArray(val) && val.length > 0) {
+        stocks = val;
+        break;
+      }
+    }
+  }
+  if (stocks.length === 0) return "(no matches)";
+  const headers = Object.keys(stocks[0]).filter(
+    (k) => !k.startsWith("_") && k !== "id"
+  );
+  const rows = stocks.map(
+    (s) => headers.map((h) => {
+      const v = s[h];
+      if (typeof v === "number") {
+        if (Math.abs(v) >= 1e9) return `${(v / 1e9).toFixed(1)}B`;
+        if (Math.abs(v) >= 1e6) return `${(v / 1e6).toFixed(1)}M`;
+        return v.toFixed(2);
+      }
+      return String(v ?? "");
+    })
+  );
+  return makeTable(headers, rows, opts);
+}
+
+// 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)
+    });
+    outputResult(data, opts);
+  });
+}
+
+// src/commands/technicals.ts
+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);
+    outputResult(data, opts);
+  });
+}
+
+// src/commands/options.ts
+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(
+    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
+      });
+      outputResult(data, opts);
+    }
+  );
+}
+
+// src/commands/portfolio.ts
+function registerPortfolioCommand(program2) {
+  addGlobalOptions(
+    program2.command("portfolio").description("Portfolio risk-return analysis").argument("<holdings>", `JSON holdings, e.g. '{"AAPL":0.3,"MSFT":0.7}'`).option("--strategy <s>", "Investment strategy context")
+  ).action(async (holdingsStr, opts) => {
+    let holdings;
+    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);
+    outputResult(data, opts);
+  });
+}
+
+// src/commands/trades.ts
+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) => {
+    const trades = tradeStrs.map(parseTrade);
+    const data = await callTool("analyze_trades", { trades });
+    outputResult(data, opts);
+  });
+}
+function parseTrade(str) {
+  const match = str.match(
+    /^(buy|sell|hold)\s+([A-Z]+)\s+(\d+)%?\s+(?:because\s+)?(.+)$/i
+  );
+  if (match) {
+    return {
+      action: match[1].toLowerCase(),
+      symbol: match[2].toUpperCase(),
+      portfolio_weight: parseInt(match[3], 10) / 100,
+      thesis: match[4]
+    };
+  }
+  try {
+    return JSON.parse(str);
+  } catch {
+    console.error(
+      `Error: Could not parse trade "${str}"
+Format: "Buy AAPL 30% because thesis" or JSON object`
+    );
+    process.exit(1);
+  }
+}
+
+// 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)
+    });
+    outputResult(data, opts);
+  });
+}
+
+// src/commands/position.ts
+function registerPositionCommand(program2) {
+  addGlobalOptions(
+    program2.command("position-size").description("Kelly criterion position sizing").requiredOption("--bull <n>", "Expected bull return (decimal, e.g. 0.6)").requiredOption("--bear <n>", "Expected bear return (decimal, e.g. -0.15)").requiredOption("--conviction <n>", "Conviction level 1-10").requiredOption("--value <n>", "Portfolio value in dollars").option("--symbol <s>", "Optional symbol for valuation context")
+  ).action(
+    async (opts) => {
+      const bullReturn = parseFloat(opts.bull);
+      const bearReturn = parseFloat(opts.bear);
+      const portfolioValue = parseFloat(opts.value);
+      if (isNaN(bullReturn)) {
+        console.error("Error: --bull must be a decimal number (e.g. 0.6)");
+        process.exit(1);
+      }
+      if (isNaN(bearReturn)) {
+        console.error("Error: --bear must be a decimal number (e.g. -0.15)");
+        process.exit(1);
+      }
+      if (isNaN(portfolioValue)) {
+        console.error("Error: --value must be a number");
+        process.exit(1);
+      }
+      const args = {
+        bull_return: bullReturn,
+        bear_return: bearReturn,
+        conviction: parseIntSafe(opts.conviction, 5),
+        portfolio_value: portfolioValue
+      };
+      if (opts.symbol) args.symbol = opts.symbol.toUpperCase();
+      const data = await callTool("calculate_position_size", args);
+      outputResult(data, opts);
+    }
+  );
+}
+
+// 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")
+  ).action(
+    async (symbol, keywords, opts) => {
+      const args = {
+        symbol: symbol.toUpperCase(),
+        keywords,
+        max_results: parseIntSafe(opts.max, 10)
+      };
+      if (opts.quarter) args.fiscal_quarter = opts.quarter;
+      const data = await callTool("search_transcript", args);
+      outputResult(data, opts, (d, o) => formatTranscript(d, o));
+    }
+  );
+}
+function formatTranscript(data, opts) {
+  if (!data || typeof data !== "object") return String(data);
+  const obj = data;
+  let matches = [];
+  if (Array.isArray(data)) {
+    matches = data;
+  } else {
+    for (const val of Object.values(obj)) {
+      if (Array.isArray(val) && val.length > 0) {
+        matches = val;
+        break;
+      }
+      if (val && typeof val === "object" && !Array.isArray(val)) {
+        for (const nested of Object.values(val)) {
+          if (Array.isArray(nested) && nested.length > 0) {
+            matches = nested;
+            break;
+          }
+        }
+      }
+      if (matches.length > 0) break;
+    }
+  }
+  if (matches.length === 0) return "(no matches)";
+  const rows = matches.map((m) => [
+    String(m.speaker || m.name || ""),
+    String(m.role || m.title || ""),
+    String(m.content_with_highlights || m.text || m.content || m.exact_quote || m.quote || "").slice(0, 120)
+  ]);
+  return makeTable(["Speaker", "Role", "Text"], rows, opts);
+}
+
+// src/index.ts
+var program = new Command();
+program.name("bloom").description("Bloom CLI \u2014 financial data for coding agents and humans").version("0.1.0");
+registerAuthCommand(program);
+registerInfoCommand(program);
+registerNewsCommand(program);
+registerPriceCommand(program);
+registerFinancialsCommand(program);
+registerSentimentCommand(program);
+registerMarketCommand(program);
+registerCollectionsCommand(program);
+registerScreenCommand(program);
+registerEarningsCommand(program);
+registerTechnicalsCommand(program);
+registerOptionsCommand(program);
+registerPortfolioCommand(program);
+registerTradesCommand(program);
+registerCatalystsCommand(program);
+registerPositionCommand(program);
+registerTranscriptCommand(program);
+program.parseAsync().catch((err) => {
+  console.error("Error:", err.message || err);
+  process.exit(1);
+});