@bloomai/cli 0.1.0

package/src/commands/screen.ts

@@ -0,0 +1,77 @@
+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 registerScreenCommand(program: Command): void {
+  addGlobalOptions(
+    program
+      .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: string[],
+      opts: OutputOptions & {
+        or?: boolean;
+        limit: string;
+        symbols?: string;
+        fields?: string;
+      }
+    ) => {
+      const args: Record<string, unknown> = {
+        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: unknown, opts: OutputOptions): string {
+  if (!data || typeof data !== "object") return String(data);
+  const obj = data as Record<string, unknown>;
+
+  let stocks: Record<string, unknown>[] = [];
+  if (Array.isArray(data)) {
+    stocks = data as Record<string, unknown>[];
+  } else {
+    for (const val of Object.values(obj)) {
+      if (Array.isArray(val) && val.length > 0) {
+        stocks = val as Record<string, unknown>[];
+        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);
+}

package/src/commands/sentiment.ts

@@ -0,0 +1,51 @@
+import { Command } from "commander";
+import { callTool } from "../api.js";
+import { outputResult, OutputOptions } from "../format.js";
+import { addGlobalOptions } from "../global-opts.js";
+
+const SECTIONS = [
+  "aaii_sentiment",
+  "cnn_fear_greed",
+  "volatility_analysis",
+  "momentum_analysis",
+];
+
+export function registerSentimentCommand(program: Command): void {
+  addGlobalOptions(
+    program
+      .command("sentiment")
+      .description("Market mood: AAII, Fear&Greed, VIX, momentum")
+      .option("--sections <s>", "Comma-separated: " + SECTIONS.join(","))
+  ).action(async (opts: OutputOptions & { sections?: string }) => {
+    const args: Record<string, unknown> = {};
+    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: unknown): string {
+  if (!data || typeof data !== "object") return String(data);
+  const obj = data as Record<string, unknown>;
+  const lines: string[] = [];
+
+  for (const [section, val] of Object.entries(obj)) {
+    if (section === "timestamp" || section === "source") continue;
+    if (!val || typeof val !== "object") continue;
+    lines.push(`\n=== ${section.replace(/_/g, " ").toUpperCase()} ===`);
+    for (const [k, v] of Object.entries(val as Record<string, unknown>)) {
+      if (v && typeof v === "object" && !Array.isArray(v)) {
+        lines.push(`  ${k}:`);
+        for (const [ik, iv] of Object.entries(v as Record<string, unknown>)) {
+          lines.push(`    ${ik}: ${iv}`);
+        }
+      } else {
+        lines.push(`  ${k}: ${v}`);
+      }
+    }
+  }
+
+  return lines.join("\n") || JSON.stringify(data, null, 2);
+}

package/src/commands/technicals.ts

@@ -0,0 +1,25 @@
+import { Command } from "commander";
+import { callTool } from "../api.js";
+import { outputResult, OutputOptions } from "../format.js";
+import { addGlobalOptions } from "../global-opts.js";
+
+const SECTIONS = ["technical_indicators", "options_analysis", "insider_activity"];
+
+export function registerTechnicalsCommand(program: Command): void {
+  addGlobalOptions(
+    program
+      .command("technicals")
+      .description("RSI, MAs, patterns, options flow, insider trades")
+      .argument("<symbols...>", "Ticker symbols (up to 5)")
+      .option("--sections <s>", "Comma-separated: " + SECTIONS.join(","))
+  ).action(async (symbols: string[], opts: OutputOptions & { sections?: string }) => {
+    const args: Record<string, unknown> = {
+      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);
+  });
+}

package/src/commands/trades.ts

@@ -0,0 +1,41 @@
+import { Command } from "commander";
+import { callTool } from "../api.js";
+import { outputResult, OutputOptions } from "../format.js";
+import { addGlobalOptions } from "../global-opts.js";
+
+export function registerTradesCommand(program: Command): void {
+  addGlobalOptions(
+    program
+      .command("trades")
+      .description("AI trade evaluation")
+      .argument("<trades...>", 'Trade descriptions: "Buy AAPL 30% because..." "Sell MSFT 20% because..."')
+  ).action(async (tradeStrs: string[], opts: OutputOptions) => {
+    const trades = tradeStrs.map(parseTrade);
+    const data = await callTool("analyze_trades", { trades });
+    outputResult(data, opts);
+  });
+}
+
+function parseTrade(str: string): Record<string, unknown> {
+  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}"\n` +
+        'Format: "Buy AAPL 30% because thesis" or JSON object'
+    );
+    process.exit(1);
+  }
+}

package/src/commands/transcript.ts

@@ -0,0 +1,69 @@
+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 registerTranscriptCommand(program: Command): void {
+  addGlobalOptions(
+    program
+      .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: string,
+      keywords: string[],
+      opts: OutputOptions & { quarter?: string; max: string }
+    ) => {
+      const args: Record<string, unknown> = {
+        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: unknown, opts: OutputOptions): string {
+  if (!data || typeof data !== "object") return String(data);
+  const obj = data as Record<string, unknown>;
+
+  let matches: Record<string, unknown>[] = [];
+  if (Array.isArray(data)) {
+    matches = data as Record<string, unknown>[];
+  } else {
+    for (const val of Object.values(obj)) {
+      if (Array.isArray(val) && val.length > 0) {
+        matches = val as Record<string, unknown>[];
+        break;
+      }
+      // Check one level deeper (e.g. transcript_search_results.matches)
+      if (val && typeof val === "object" && !Array.isArray(val)) {
+        for (const nested of Object.values(val as Record<string, unknown>)) {
+          if (Array.isArray(nested) && nested.length > 0) {
+            matches = nested as Record<string, unknown>[];
+            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);
+}

package/src/format.ts

@@ -0,0 +1,179 @@
+import Table from "cli-table3";
+import { writeFileSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+
+export interface OutputOptions {
+  format?: "json" | "csv" | "table";
+  output?: string;
+  quiet?: boolean;
+  raw?: boolean;
+}
+
+export function resolveFormat(opts: OutputOptions): "json" | "csv" | "table" {
+  if (opts.format) return opts.format;
+  if (opts.output || !process.stdout.isTTY) return "json";
+  return "table";
+}
+
+export function outputResult(
+  data: unknown,
+  opts: OutputOptions,
+  tableFormatter?: (data: unknown, opts: OutputOptions) => string
+): void {
+  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;
+  }
+
+  // table format
+  if (tableFormatter) {
+    emit(tableFormatter(data, opts), opts);
+  } else {
+    emit(autoTable(data, opts), opts);
+  }
+}
+
+function emit(content: string, opts: OutputOptions): void {
+  if (opts.output) {
+    mkdirSync(dirname(opts.output), { recursive: true });
+    writeFileSync(opts.output, content + "\n");
+    if (!opts.quiet) {
+      console.error(`Written to ${opts.output}`);
+    }
+  } else {
+    console.log(content);
+  }
+}
+
+function toCSV(data: unknown): string {
+  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: unknown): Record<string, unknown>[] {
+  const flatten = (v: unknown) => flattenObj(v);
+  if (Array.isArray(data)) return data.map(flatten);
+  if (data && typeof data === "object") {
+    const obj = data as Record<string, unknown>;
+    // Prefer arrays of objects over arrays of primitives
+    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);
+      }
+    }
+    // Fallback: any non-empty array
+    for (const key of Object.keys(obj)) {
+      if (Array.isArray(obj[key]) && (obj[key] as unknown[]).length > 0) {
+        return (obj[key] as unknown[]).map(flatten);
+      }
+    }
+    return [flattenObj(obj)];
+  }
+  return [{ value: data }];
+}
+
+function flattenObj(
+  obj: unknown,
+  prefix = ""
+): Record<string, unknown> {
+  if (!obj || typeof obj !== "object") return { value: obj };
+  const result: Record<string, unknown> = {};
+  for (const [k, v] of Object.entries(obj as Record<string, unknown>)) {
+    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;
+}
+
+export function autoTable(data: unknown, opts?: OutputOptions): string {
+  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();
+}
+
+export function makeTable(
+  headers: string[],
+  rows: string[][],
+  opts?: { quiet?: boolean }
+): string {
+  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: string, max: number): string {
+  return s.length > max ? s.slice(0, max - 1) + "…" : s;
+}
+
+/**
+ * Parse a string as an integer, returning `fallback` if the result is NaN.
+ */
+export function parseIntSafe(value: string, fallback: number): number {
+  const n = parseInt(value, 10);
+  return Number.isNaN(n) ? fallback : n;
+}

package/src/global-opts.ts

@@ -0,0 +1,9 @@
+import { Command } from "commander";
+
+export function addGlobalOptions(cmd: Command): Command {
+  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");
+}

package/src/index.ts

@@ -0,0 +1,49 @@
+import { Command } from "commander";
+import { registerAuthCommand } from "./commands/auth.js";
+import { registerInfoCommand } from "./commands/info.js";
+import { registerNewsCommand } from "./commands/news.js";
+import { registerPriceCommand } from "./commands/price.js";
+import { registerFinancialsCommand } from "./commands/financials.js";
+import { registerSentimentCommand } from "./commands/sentiment.js";
+import { registerMarketCommand } from "./commands/market.js";
+import { registerCollectionsCommand } from "./commands/collections.js";
+import { registerScreenCommand } from "./commands/screen.js";
+import { registerEarningsCommand } from "./commands/earnings.js";
+import { registerTechnicalsCommand } from "./commands/technicals.js";
+import { registerOptionsCommand } from "./commands/options.js";
+import { registerPortfolioCommand } from "./commands/portfolio.js";
+import { registerTradesCommand } from "./commands/trades.js";
+import { registerCatalystsCommand } from "./commands/catalysts.js";
+import { registerPositionCommand } from "./commands/position.js";
+import { registerTranscriptCommand } from "./commands/transcript.js";
+
+const program = new Command();
+
+program
+  .name("bloom")
+  .description("Bloom CLI — financial data for coding agents and humans")
+  .version("0.1.0");
+
+// Register all commands (each command adds its own global options via addGlobalOptions)
+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);
+});

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "declaration": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"]
+}

package/tsup.config.ts

@@ -0,0 +1,12 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+  entry: ["src/index.ts"],
+  format: ["esm"],
+  target: "node20",
+  clean: true,
+  splitting: false,
+  banner: {
+    js: "#!/usr/bin/env node",
+  },
+});