@bloomai/cli 0.1.0

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@bloomai/cli",
+  "version": "0.1.0",
+  "description": "CLI tool for Bloom financial data - download market data to files for analysis",
+  "type": "module",
+  "bin": {
+    "bloom": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch"
+  },
+  "keywords": ["finance", "stocks", "cli", "bloom", "market-data"],
+  "license": "MIT",
+  "dependencies": {
+    "cli-table3": "^0.6.5",
+    "commander": "^13.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.0",
+    "tsup": "^8.4.0",
+    "typescript": "^5.7.0"
+  }
+}

package/src/api.ts

@@ -0,0 +1,67 @@
+import { requireApiKey } from "./auth.js";
+
+const MCP_URL = "https://api.getbloom.app/mcp/";
+
+let requestId = 0;
+
+interface McpResponse {
+  jsonrpc: string;
+  id: number;
+  result?: {
+    content: Array<{ type: string; text: string }>;
+  };
+  error?: {
+    code: number;
+    message: string;
+  };
+}
+
+export async function callTool(
+  toolName: string,
+  args: Record<string, unknown>
+): Promise<unknown> {
+  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 text = await res.text().catch(() => "");
+    throw new Error(`API error ${res.status}: ${text || res.statusText}`);
+  }
+
+  const data = (await res.json()) as McpResponse;
+
+  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");
+  }
+
+  // The MCP response wraps the data as a JSON string inside content[0].text
+  const text = data.result.content[0].text;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}

package/src/auth.ts

@@ -0,0 +1,83 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+const CONFIG_DIR = join(homedir(), ".config", "bloom-cli");
+const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+
+interface Config {
+  api_key?: string;
+}
+
+function readConfig(): Config {
+  if (!existsSync(CONFIG_FILE)) return {};
+  try {
+    return JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+
+function writeConfig(config: Config): void {
+  try {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+    writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n", {
+      mode: 0o600,
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(
+      `Error: Could not write config to ${CONFIG_FILE}: ${msg}\n` +
+      `Try using BLOOM_API_KEY environment variable instead.`
+    );
+    process.exit(1);
+  }
+}
+
+export function getApiKey(): string | undefined {
+  return process.env.BLOOM_API_KEY || readConfig().api_key;
+}
+
+export function requireApiKey(): string {
+  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;
+}
+
+export function login(apiKey: string): void {
+  const config = readConfig();
+  config.api_key = apiKey;
+  writeConfig(config);
+  console.log("API key saved to " + CONFIG_FILE);
+}
+
+export function logout(): void {
+  if (existsSync(CONFIG_FILE)) {
+    const config = readConfig();
+    delete config.api_key;
+    writeConfig(config);
+  }
+  console.log("Logged out. API key cleared.");
+}
+
+export function status(): void {
+  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: string): string {
+  if (key.length <= 8) return "****";
+  return key.slice(0, 4) + "..." + key.slice(-4);
+}

package/src/commands/auth.ts

@@ -0,0 +1,45 @@
+import { Command } from "commander";
+import { login, logout, status } from "../auth.js";
+import { createInterface } from "node:readline";
+
+export function registerAuthCommand(program: Command): void {
+  const auth = program.command("auth").description("Manage API authentication");
+
+  auth
+    .command("login")
+    .description("Store API key")
+    .argument("[key]", "API key (or pass via stdin)")
+    .action(async (key?: string) => {
+      if (!key) {
+        const rl = createInterface({
+          input: process.stdin,
+          output: process.stderr,
+        });
+        key = await new Promise<string>((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();
+    });
+}

package/src/commands/catalysts.ts

@@ -0,0 +1,18 @@
+import { Command } from "commander";
+import { callTool } from "../api.js";
+import { outputResult, OutputOptions } from "../format.js";
+import { addGlobalOptions } from "../global-opts.js";
+
+export function registerCatalystsCommand(program: Command): void {
+  addGlobalOptions(
+    program
+      .command("catalysts")
+      .description("Forward-looking value catalysts")
+      .argument("<symbols...>", "Ticker symbols (up to 5)")
+  ).action(async (symbols: string[], opts: OutputOptions) => {
+    const data = await callTool("generate_catalysts", {
+      symbols: symbols.map((s) => s.toUpperCase()).slice(0, 5),
+    });
+    outputResult(data, opts);
+  });
+}

package/src/commands/collections.ts

@@ -0,0 +1,20 @@
+import { Command } from "commander";
+import { callTool } from "../api.js";
+import { outputResult, OutputOptions, parseIntSafe } from "../format.js";
+import { addGlobalOptions } from "../global-opts.js";
+
+export function registerCollectionsCommand(program: Command): void {
+  addGlobalOptions(
+    program
+      .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: OutputOptions & { section: string; limit: string }) => {
+    const data = await callTool("get_collections", {
+      section: opts.section,
+      limit: parseIntSafe(opts.limit, 6),
+    });
+    outputResult(data, opts);
+  });
+}

package/src/commands/earnings.ts

@@ -0,0 +1,18 @@
+import { Command } from "commander";
+import { callTool } from "../api.js";
+import { outputResult, OutputOptions } from "../format.js";
+import { addGlobalOptions } from "../global-opts.js";
+
+export function registerEarningsCommand(program: Command): void {
+  addGlobalOptions(
+    program
+      .command("earnings")
+      .description("Earnings history, estimates, surprises")
+      .argument("<symbols...>", "Ticker symbols (up to 5)")
+  ).action(async (symbols: string[], opts: OutputOptions) => {
+    const data = await callTool("analyze_earnings", {
+      symbols: symbols.map((s) => s.toUpperCase()).slice(0, 5),
+    });
+    outputResult(data, opts);
+  });
+}

package/src/commands/financials.ts

@@ -0,0 +1,30 @@
+import { Command } from "commander";
+import { callTool } from "../api.js";
+import { outputResult, OutputOptions } from "../format.js";
+import { addGlobalOptions } from "../global-opts.js";
+
+const CHART_TYPES = [
+  "revenue",
+  "revenue_growth",
+  "operating_margin",
+  "net_earnings",
+  "net_earnings_growth",
+  "free_cash_flow",
+  "free_cash_flow_growth",
+];
+
+export function registerFinancialsCommand(program: Command): void {
+  addGlobalOptions(
+    program
+      .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: string, opts: OutputOptions & { type: string }) => {
+    const data = await callTool("get_financial_charts", {
+      symbol: symbol.toUpperCase(),
+      chart_type: opts.type,
+    });
+    outputResult(data, opts);
+  });
+}

package/src/commands/info.ts

@@ -0,0 +1,79 @@
+import { Command } from "commander";
+import { callTool } from "../api.js";
+import { outputResult, OutputOptions } from "../format.js";
+import { addGlobalOptions } from "../global-opts.js";
+
+const VALID_FIELDS = [
+  "basic_metadata",
+  "bottom_line_ratings",
+  "embedded_expectations",
+  "peers",
+  "key_events",
+  "holdings",
+];
+
+export function registerInfoCommand(program: Command): void {
+  addGlobalOptions(
+    program
+      .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: string[], opts: OutputOptions & { fields?: string }) => {
+    const args: Record<string, unknown> = {
+      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: unknown): string {
+  if (!data || typeof data !== "object") return String(data);
+  const obj = data as Record<string, unknown>;
+  const sections: string[] = [];
+
+  for (const [key, val] of Object.entries(obj)) {
+    if (key === "timestamp" || key === "source") continue;
+    if (val && typeof val === "object") {
+      sections.push(`\n=== ${key.toUpperCase()} ===`);
+      sections.push(formatSection(val as Record<string, unknown>));
+    }
+  }
+
+  return sections.length > 0 ? sections.join("\n") : JSON.stringify(data, null, 2);
+}
+
+function formatSection(obj: Record<string, unknown>, indent = ""): string {
+  const lines: string[] = [];
+  for (const [k, v] of Object.entries(obj)) {
+    if (v && typeof v === "object" && !Array.isArray(v)) {
+      lines.push(`${indent}${k}:`);
+      lines.push(formatSection(v as Record<string, unknown>, 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 as Record<string, unknown>)
+              .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");
+}

package/src/commands/market.ts

@@ -0,0 +1,22 @@
+import { Command } from "commander";
+import { callTool } from "../api.js";
+import { outputResult, OutputOptions, parseIntSafe } from "../format.js";
+import { addGlobalOptions } from "../global-opts.js";
+
+export function registerMarketCommand(program: Command): void {
+  addGlobalOptions(
+    program
+      .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: OutputOptions & { type: string; period: string; limit: string }) => {
+    const data = await callTool("get_market_map", {
+      map_type: opts.type,
+      period: opts.period,
+      limit: parseIntSafe(opts.limit, 24),
+    });
+    outputResult(data, opts);
+  });
+}

package/src/commands/news.ts

@@ -0,0 +1,48 @@
+import { Command } from "commander";
+import { callTool } from "../api.js";
+import { outputResult, OutputOptions, makeTable, parseIntSafe } from "../format.js";
+import { addGlobalOptions } from "../global-opts.js";
+
+export function registerNewsCommand(program: Command): void {
+  addGlobalOptions(
+    program
+      .command("news")
+      .description("Recent news from Benzinga channels")
+      .argument("<symbols...>", "Ticker symbols")
+      .option("--limit <n>", "Max articles (default: 15)", "15")
+  ).action(async (symbols: string[], opts: OutputOptions & { limit: string }) => {
+    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: unknown, opts: OutputOptions): string {
+  if (!data || typeof data !== "object") return String(data);
+  const obj = data as Record<string, unknown>;
+
+  let articles: Record<string, unknown>[] = [];
+  if (Array.isArray(data)) {
+    articles = data as Record<string, unknown>[];
+  } else {
+    for (const val of Object.values(obj)) {
+      if (Array.isArray(val) && val.length > 0) {
+        articles = val as Record<string, unknown>[];
+        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);
+}

package/src/commands/options.ts

@@ -0,0 +1,35 @@
+import { Command } from "commander";
+import { callTool } from "../api.js";
+import { outputResult, OutputOptions, parseIntSafe } from "../format.js";
+import { addGlobalOptions } from "../global-opts.js";
+
+export function registerOptionsCommand(program: Command): void {
+  addGlobalOptions(
+    program
+      .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: string,
+      opts: OutputOptions & {
+        days: string;
+        weekly?: boolean;
+        daily?: boolean;
+        greeks?: boolean;
+      }
+    ) => {
+      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);
+    }
+  );
+}

package/src/commands/portfolio.ts

@@ -0,0 +1,28 @@
+import { Command } from "commander";
+import { callTool } from "../api.js";
+import { outputResult, OutputOptions } from "../format.js";
+import { addGlobalOptions } from "../global-opts.js";
+
+export function registerPortfolioCommand(program: Command): void {
+  addGlobalOptions(
+    program
+      .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: string, opts: OutputOptions & { strategy?: string }) => {
+    let holdings: Record<string, number>;
+    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: Record<string, unknown> = { holdings };
+    if (opts.strategy) args.strategy = opts.strategy;
+
+    const data = await callTool("analyze_portfolio", args);
+    outputResult(data, opts);
+  });
+}

package/src/commands/position.ts

@@ -0,0 +1,44 @@
+import { Command } from "commander";
+import { callTool } from "../api.js";
+import { outputResult, OutputOptions, parseIntSafe } from "../format.js";
+import { addGlobalOptions } from "../global-opts.js";
+
+export function registerPositionCommand(program: Command): void {
+  addGlobalOptions(
+    program
+      .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: OutputOptions & {
+        bull: string;
+        bear: string;
+        conviction: string;
+        value: string;
+        symbol?: string;
+      }
+    ) => {
+      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: Record<string, unknown> = {
+        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);
+    }
+  );
+}

package/src/commands/price.ts

@@ -0,0 +1,76 @@
+import { Command } from "commander";
+import { callTool } from "../api.js";
+import { outputResult, OutputOptions, makeTable } from "../format.js";
+import { addGlobalOptions } from "../global-opts.js";
+
+export function registerPriceCommand(program: Command): void {
+  addGlobalOptions(
+    program
+      .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: string, opts: OutputOptions & { timeframes: string; ohlc?: boolean }) => {
+    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: unknown, opts: OutputOptions): string {
+  if (!data || typeof data !== "object") return String(data);
+  const obj = data as Record<string, unknown>;
+  const sections: string[] = [];
+
+  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 as Record<string, unknown>;
+    let points: Record<string, unknown>[] = [];
+
+    if (Array.isArray(tfData)) {
+      points = tfData as Record<string, unknown>[];
+    } else if (tfData.data && Array.isArray(tfData.data)) {
+      points = tfData.data as Record<string, unknown>[];
+    } else if (tfData.prices && Array.isArray(tfData.prices)) {
+      points = tfData.prices as Record<string, unknown>[];
+    } else {
+      // Fallback: find the first array of objects (skip primitive arrays)
+      for (const v of Object.values(tfData)) {
+        if (Array.isArray(v) && v.length > 0 && typeof v[0] === "object" && v[0] !== null) {
+          points = v as Record<string, unknown>[];
+          break;
+        }
+      }
+    }
+
+    if (points.length === 0) continue;
+
+    sections.push(`\n--- ${tf.toUpperCase()} (${points.length} points) ---`);
+
+    const show = points.length <= 12 ? points : [
+      ...points.slice(0, 5),
+      { date: "...", price: "..." } as Record<string, unknown>,
+      ...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);
+}