gloomberb 0.2.0 → 0.3.1

package/src/cli/helpers.ts

@@ -0,0 +1,85 @@
+import {
+  formatCompact,
+  formatCurrency,
+  formatNumber,
+  formatPercentRaw,
+} from "../utils/format";
+import type { AppConfig } from "../types/config";
+import type { Watchlist, TickerRecord } from "../types/ticker";
+
+export function slugifyName(name: string, fallbackPrefix: string): string {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || `${fallbackPrefix}-${Date.now()}`;
+}
+
+export function formatSignedCurrency(value: number, currency: string): string {
+  return value > 0 ? `+${formatCurrency(value, currency)}` : formatCurrency(value, currency);
+}
+
+export function formatSignedPercentRaw(value: number): string {
+  return formatPercentRaw(value);
+}
+
+export function formatTimestamp(timestamp: number | undefined): string {
+  if (!timestamp) return "—";
+  return new Date(timestamp).toLocaleString("en-US", {
+    month: "short",
+    day: "numeric",
+    year: "numeric",
+    hour: "numeric",
+    minute: "2-digit",
+  });
+}
+
+export function formatNullableCompact(value: number | undefined): string {
+  return value == null ? "—" : formatCompact(value);
+}
+
+export function formatStatementValue(value: number | undefined, kind: "compact" | "eps" = "compact"): string {
+  if (value == null) return "—";
+  return kind === "eps" ? formatNumber(value, 2) : formatCompact(value);
+}
+
+export function formatBidAsk(
+  bid: number | undefined,
+  ask: number | undefined,
+  bidSize: number | undefined,
+  askSize: number | undefined,
+  currency: string,
+): string {
+  if (bid == null && ask == null) return "—";
+  const bidText = bid != null
+    ? `${formatCurrency(bid, currency)}${bidSize != null ? ` x ${formatNumber(bidSize, 0)}` : ""}`
+    : "—";
+  const askText = ask != null
+    ? `${formatCurrency(ask, currency)}${askSize != null ? ` x ${formatNumber(askSize, 0)}` : ""}`
+    : "—";
+  return `${bidText} / ${askText}`;
+}
+
+export function formatWatchlistNames(config: AppConfig, watchlistIds: string[]): string[] {
+  return watchlistIds
+    .map((id) => config.watchlists.find((watchlist) => watchlist.id === id)?.name)
+    .filter((name): name is string => !!name);
+}
+
+export function formatPortfolioNames(config: AppConfig, portfolioIds: string[]): string[] {
+  return portfolioIds
+    .map((id) => config.portfolios.find((portfolio) => portfolio.id === id)?.name)
+    .filter((name): name is string => !!name);
+}
+
+export function countCollectionTickers(
+  tickers: TickerRecord[],
+  field: "portfolios" | "watchlists",
+  id: string,
+): number {
+  return tickers.filter((ticker) => ticker.metadata[field].includes(id)).length;
+}
+
+export function findWatchlist(config: AppConfig, rawName: string): Watchlist | null {
+  const normalized = rawName.trim().toLowerCase();
+  if (!normalized) return null;
+  return config.watchlists.find((watchlist) =>
+    watchlist.id.toLowerCase() === normalized || watchlist.name.toLowerCase() === normalized
+  ) ?? null;
+}

package/src/cli/index.ts

@@ -0,0 +1,143 @@
+import { VERSION } from "../version";
+import {
+  cliStyles,
+  renderSection,
+  renderTable,
+} from "../utils/cli-output";
+import { fail } from "./errors";
+import { portfolio } from "./commands/portfolio";
+import { watchlist } from "./commands/watchlist";
+import { search, searchCandidatesForCli, buildSearchReport } from "./commands/search";
+import { ticker, buildTickerReport } from "./commands/ticker";
+import {
+  installPlugin,
+  listPlugins,
+  removePlugin,
+  updatePlugins,
+} from "./commands/plugins";
+
+function help() {
+  console.log(`${cliStyles.bold(`gloomberb v${VERSION}`)}\n${cliStyles.muted("Bloomberg-style portfolio tracker for the terminal")}`);
+  console.log("");
+  console.log(renderSection("Usage"));
+  console.log("gloomberb [command]");
+  console.log("");
+  console.log(renderSection("Commands"));
+  console.log(renderTable(
+    [
+      { header: "Command" },
+      { header: "Description" },
+    ],
+    [
+      ["(no command)", "Launch the terminal UI"],
+      ["predictions [...]", "Launch the UI with Prediction Markets focused"],
+      ["help", "Show this help message"],
+      ["portfolio [name]", "List collections or show a portfolio/watchlist"],
+      ["watchlist [action]", "List, create, delete, add, or remove watchlists"],
+      ["search <query>", "Search tickers and company names"],
+      ["ticker <symbol>", "Show quote, ownership, and detailed financials"],
+      ["install <user/repo>", "Install a plugin from GitHub"],
+      ["remove <name>", "Remove an installed plugin"],
+      ["update [name]", "Update plugins"],
+      ["plugins", "List installed plugins"],
+    ],
+  ));
+  console.log("");
+  console.log(renderSection("Prediction Launch"));
+  console.log(renderTable(
+    [
+      { header: "Input" },
+      { header: "Example" },
+    ],
+    [
+      ["gloomberb predictions [venue] [category] [browse-tab] [search...]", "gloomberb predictions world"],
+      ["venue", "all | polymarket | kalshi"],
+      ["category", "all | politics | world | macro | crypto | science | sports | entertainment | climate | social"],
+      ["browse-tab", "top | ending | new | watchlist"],
+    ],
+  ));
+  console.log("");
+  console.log(renderSection("Watchlist Actions"));
+  console.log(renderTable(
+    [
+      { header: "Action" },
+      { header: "Example" },
+    ],
+    [
+      ["list", "gloomberb watchlist list"],
+      ["show", "gloomberb watchlist show Growth"],
+      ["create", "gloomberb watchlist create Growth"],
+      ["delete", "gloomberb watchlist delete Growth"],
+      ["add", "gloomberb watchlist add Growth NVDA"],
+      ["remove", "gloomberb watchlist remove Growth NVDA"],
+    ],
+  ));
+}
+
+export { buildSearchReport, buildTickerReport, searchCandidatesForCli };
+
+export async function runCli(args: string[]): Promise<boolean> {
+  const command = args[0];
+
+  switch (command) {
+    case "help":
+    case "--help":
+    case "-h": {
+      help();
+      return true;
+    }
+    case "portfolio": {
+      await portfolio(args.slice(1).join(" ") || undefined);
+      return true;
+    }
+    case "watchlist":
+    case "watchlists": {
+      await watchlist(args.slice(1));
+      return true;
+    }
+    case "search": {
+      const query = args.slice(1).join(" ");
+      if (!query) {
+        fail("Usage: gloomberb search <query>");
+      }
+      await search(query);
+      return true;
+    }
+    case "ticker": {
+      const symbol = args[1];
+      if (!symbol) {
+        fail("Usage: gloomberb ticker <symbol>");
+      }
+      await ticker(symbol);
+      return true;
+    }
+    case "install": {
+      const ref = args[1];
+      if (!ref) {
+        fail("Usage: gloomberb install <github-user/repo>");
+      }
+      await installPlugin(ref);
+      return true;
+    }
+    case "remove":
+    case "uninstall": {
+      const name = args[1];
+      if (!name) {
+        fail("Usage: gloomberb remove <plugin-name>");
+      }
+      await removePlugin(name);
+      return true;
+    }
+    case "update": {
+      await updatePlugins(args[1]);
+      return true;
+    }
+    case "plugins":
+    case "list": {
+      listPlugins();
+      return true;
+    }
+    default:
+      return false;
+  }
+}

package/src/cli/ticker-resolution.ts

@@ -0,0 +1,39 @@
+import type { DataProvider } from "../types/data-provider";
+import type { TickerRecord } from "../types/ticker";
+import type { TickerRepository } from "../data/ticker-repository";
+import { resolveTickerSearch, upsertTickerFromSearchResult } from "../utils/ticker-search";
+
+export async function resolveTickerForCli(
+  symbol: string,
+  store: TickerRepository,
+  dataProvider: DataProvider,
+): Promise<TickerRecord> {
+  const normalized = symbol.trim().toUpperCase();
+  if (!normalized) {
+    throw new Error("Ticker symbol is required.");
+  }
+
+  const localTicker = await store.loadTicker(normalized);
+  if (localTicker) return localTicker;
+
+  const localTickers = new Map(
+    (await store.loadAllTickers()).map((ticker) => [ticker.metadata.ticker.toUpperCase(), ticker] as const),
+  );
+  const resolved = await resolveTickerSearch({
+    query: normalized,
+    activeTicker: null,
+    tickers: localTickers,
+    dataProvider,
+  });
+
+  if (!resolved) {
+    throw new Error(`No ticker match found for "${normalized}".`);
+  }
+
+  if (resolved.kind === "local") {
+    return resolved.ticker;
+  }
+
+  const { ticker } = await upsertTickerFromSearchResult(store, resolved.result);
+  return ticker;
+}

package/src/cli/types.ts

@@ -0,0 +1,15 @@
+import type { AppConfig } from "../types/config";
+import { AppPersistence } from "../data/app-persistence";
+import { TickerRepository } from "../data/ticker-repository";
+import { ProviderRouter } from "../sources/provider-router";
+
+export type ConfigContext = {
+  config: AppConfig;
+  persistence: AppPersistence;
+  store: TickerRepository;
+  dataDir: string;
+};
+
+export type MarketContext = ConfigContext & {
+  dataProvider: ProviderRouter;
+};

package/src/cli.test.ts

@@ -0,0 +1,361 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { mkdtemp, mkdir, rm, writeFile } from "fs/promises";
+import { join } from "path";
+import { tmpdir } from "os";
+import { AppPersistence } from "./data/app-persistence";
+import { loadConfig, saveConfig } from "./data/config-store";
+import {
+  buildSearchReport,
+  buildTickerReport,
+  runCli,
+  searchCandidatesForCli,
+} from "./cli/index";
+import { createDefaultConfig } from "./types/config";
+import { TickerRepository } from "./data/ticker-repository";
+import type { TickerFinancials } from "./types/financials";
+import type { NewsItem, SecFilingItem } from "./types/data-provider";
+import type { TickerRecord } from "./types/ticker";
+import { createTestDataProvider } from "./test-support/data-provider";
+
+const tempDirs: string[] = [];
+const originalHome = process.env.HOME;
+
+afterEach(async () => {
+  process.env.HOME = originalHome;
+  await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })));
+});
+
+async function createTempDir(prefix: string): Promise<string> {
+  const dir = await mkdtemp(join(tmpdir(), prefix));
+  tempDirs.push(dir);
+  return dir;
+}
+
+async function createCliFixture({
+  watchlists,
+  tickers = [],
+}: {
+  watchlists: Array<{ id: string; name: string }>;
+  tickers?: TickerRecord[];
+}) {
+  const homeDir = await createTempDir("gloomberb-cli-home-");
+  const dataDir = await createTempDir("gloomberb-cli-data-");
+  process.env.HOME = homeDir;
+
+  await mkdir(join(homeDir, ".gloomberb"), { recursive: true });
+  await writeFile(join(homeDir, ".gloomberb", "config.json"), JSON.stringify({ dataDir }), "utf-8");
+
+  const config = createDefaultConfig(dataDir);
+  config.watchlists = watchlists;
+  await saveConfig(config);
+
+  const persistence = new AppPersistence(join(dataDir, ".gloomberb-cache.db"));
+  const store = new TickerRepository(persistence.tickers);
+  for (const ticker of tickers) {
+    await store.saveTicker(ticker);
+  }
+  persistence.close();
+
+  return { dataDir };
+}
+
+async function captureConsole<T>(fn: () => Promise<T> | T): Promise<{ result: T; stdout: string; stderr: string }> {
+  const logs: string[] = [];
+  const errors: string[] = [];
+  const originalLog = console.log;
+  const originalError = console.error;
+
+  console.log = (...args: unknown[]) => {
+    logs.push(args.map(String).join(" "));
+  };
+  console.error = (...args: unknown[]) => {
+    errors.push(args.map(String).join(" "));
+  };
+
+  try {
+    const result = await fn();
+    return {
+      result,
+      stdout: logs.join("\n"),
+      stderr: errors.join("\n"),
+    };
+  } finally {
+    console.log = originalLog;
+    console.error = originalError;
+  }
+}
+
+function makeTicker(overrides: Partial<TickerRecord["metadata"]> = {}): TickerRecord {
+  return {
+    metadata: {
+      ticker: "NVDA",
+      exchange: "NASDAQ",
+      currency: "USD",
+      name: "NVIDIA Corporation",
+      portfolios: [],
+      watchlists: [],
+      positions: [],
+      custom: {},
+      tags: [],
+      ...overrides,
+    },
+  };
+}
+
+describe("CLI watchlist commands", () => {
+  test("help lists the prediction markets launcher", async () => {
+    const { result, stdout } = await captureConsole(() => runCli(["help"]));
+
+    expect(result).toBe(true);
+    expect(stdout).toContain("predictions [...]");
+    expect(stdout).toContain("Prediction Launch");
+    expect(stdout).toContain("gloomberb predictions world");
+  });
+
+  test("creates a watchlist and persists the generated id", async () => {
+    const { dataDir } = await createCliFixture({ watchlists: [] });
+
+    const { stdout } = await captureConsole(() => runCli(["watchlist", "create", "Growth Radar"]));
+    const config = await loadConfig(dataDir);
+
+    expect(config.watchlists).toEqual([{ id: "growth-radar", name: "Growth Radar" }]);
+    expect(stdout).toContain('Created watchlist "Growth Radar".');
+    expect(stdout).toContain("growth-radar");
+  });
+
+  test("adds a local ticker to a watchlist and cleans memberships on delete", async () => {
+    const { dataDir } = await createCliFixture({
+      watchlists: [{ id: "growth", name: "Growth" }],
+      tickers: [makeTicker()],
+    });
+
+    const addResult = await captureConsole(() => runCli(["watchlist", "add", "Growth", "NVDA"]));
+    expect(addResult.stdout).toContain('Added NVDA to "Growth".');
+
+    let persistence = new AppPersistence(join(dataDir, ".gloomberb-cache.db"));
+    let store = new TickerRepository(persistence.tickers);
+    let savedTicker = await store.loadTicker("NVDA");
+    persistence.close();
+
+    expect(savedTicker?.metadata.watchlists).toEqual(["growth"]);
+
+    const deleteResult = await captureConsole(() => runCli(["watchlist", "delete", "Growth"]));
+    expect(deleteResult.stdout).toContain('Deleted watchlist "Growth".');
+    expect(deleteResult.stdout).toContain("Cleaned Tickers");
+
+    const config = await loadConfig(dataDir);
+    expect(config.watchlists).toEqual([]);
+
+    persistence = new AppPersistence(join(dataDir, ".gloomberb-cache.db"));
+    store = new TickerRepository(persistence.tickers);
+    savedTicker = await store.loadTicker("NVDA");
+    persistence.close();
+
+    expect(savedTicker?.metadata.watchlists).toEqual([]);
+  });
+});
+
+describe("buildTickerReport", () => {
+  test("includes deeper fundamentals and recent statement sections", async () => {
+    const config = createDefaultConfig("/tmp/gloomberb-cli-report");
+    config.watchlists = [{ id: "growth", name: "Growth" }];
+
+    const ticker = makeTicker({
+      portfolios: ["main"],
+      watchlists: ["growth"],
+      positions: [{
+        portfolio: "main",
+        shares: 10,
+        avgCost: 400,
+        broker: "manual",
+      }],
+      assetCategory: "STK",
+      sector: "Technology",
+      industry: "Semiconductors",
+    });
+
+    const financials: TickerFinancials = {
+      quote: {
+        symbol: "NVDA",
+        price: 912.34,
+        currency: "USD",
+        change: 12.5,
+        changePercent: 1.39,
+        lastUpdated: Date.UTC(2026, 3, 1, 14, 30),
+        marketCap: 2_240_000_000_000,
+        volume: 48_000_000,
+        name: "NVIDIA Corporation",
+        exchangeName: "NMS",
+        marketState: "REGULAR",
+        bid: 912.3,
+        ask: 912.4,
+        bidSize: 100,
+        askSize: 200,
+        open: 905,
+        high: 918,
+        low: 901,
+        high52w: 980,
+        low52w: 500,
+        dataSource: "live",
+      },
+      fundamentals: {
+        trailingPE: 35.2,
+        forwardPE: 29.8,
+        pegRatio: 1.4,
+        enterpriseValue: 2_300_000_000_000,
+        operatingCashFlow: 82_000_000_000,
+        freeCashFlow: 67_000_000_000,
+        dividendYield: 0.001,
+        revenue: 128_000_000_000,
+        netIncome: 73_000_000_000,
+        eps: 2.97,
+        operatingMargin: 0.58,
+        profitMargin: 0.57,
+        revenueGrowth: 0.42,
+        return1Y: 0.88,
+        return3Y: 2.45,
+        lastQuarterGrowth: 0.61,
+        sharesOutstanding: 2_450_000_000,
+      },
+      profile: {
+        description: "Designs GPUs and accelerated computing platforms.",
+        sector: "Technology",
+        industry: "Semiconductors",
+      },
+      annualStatements: [{
+        date: "2025-12-31",
+        totalRevenue: 128_000_000_000,
+        grossProfit: 97_000_000_000,
+        operatingIncome: 76_000_000_000,
+        netIncome: 73_000_000_000,
+        ebitda: 79_000_000_000,
+        operatingCashFlow: 82_000_000_000,
+        freeCashFlow: 67_000_000_000,
+        cashAndCashEquivalents: 40_000_000_000,
+        totalAssets: 110_000_000_000,
+        totalLiabilities: 36_000_000_000,
+        totalDebt: 9_000_000_000,
+        totalEquity: 74_000_000_000,
+        eps: 11.84,
+        dilutedShares: 2_450_000_000,
+      }],
+      quarterlyStatements: [{
+        date: "2026-03-31",
+        totalRevenue: 38_000_000_000,
+        grossProfit: 28_000_000_000,
+        operatingIncome: 22_000_000_000,
+        netIncome: 21_000_000_000,
+        ebitda: 23_000_000_000,
+        operatingCashFlow: 24_000_000_000,
+        freeCashFlow: 19_000_000_000,
+        cashAndCashEquivalents: 42_000_000_000,
+        totalAssets: 118_000_000_000,
+        totalLiabilities: 38_000_000_000,
+        totalDebt: 9_000_000_000,
+        totalEquity: 80_000_000_000,
+        eps: 3.4,
+        dilutedShares: 2_455_000_000,
+      }],
+      priceHistory: [],
+    };
+
+    const recentNews: NewsItem[] = [{
+      title: "NVIDIA unveils next platform",
+      source: "Example News",
+      url: "https://example.com/nvda-platform",
+      publishedAt: new Date(Date.UTC(2026, 3, 1, 15, 45)),
+      summary: "Analysts expect the launch to expand datacenter demand.",
+    }];
+
+    const recentSecFilings: SecFilingItem[] = [{
+      accessionNumber: "0000000000-26-000001",
+      form: "8-K",
+      filingDate: new Date(Date.UTC(2026, 2, 31)),
+      cik: "0001045810",
+      filingUrl: "https://www.sec.gov/Archives/example-8k",
+      primaryDocument: "nvda-8k.htm",
+      primaryDocDescription: "Current report announcing a product launch",
+      items: "2.02, 7.01",
+    }];
+
+    const report = await buildTickerReport({
+      symbol: "NVDA",
+      tickerFile: ticker,
+      financials,
+      config,
+      toBase: async (value) => value,
+      notes: "Conviction remains high.\nWatch gross margin guidance.",
+      recentNews,
+      recentSecFilings,
+    });
+
+    expect(report).toContain("Fundamentals");
+    expect(report).toContain("(+1.39%)");
+    expect(report).not.toContain("++1.39%");
+    expect(report).toContain("Operating Cash Flow");
+    expect(report).toContain("Latest Annual (2025-12-31)");
+    expect(report).toContain("Latest Quarter (2026-03-31)");
+    expect(report).toContain("Watchlists Growth");
+    expect(report).toContain("Designs GPUs and accelerated computing platforms.");
+    expect(report).toContain("Notes");
+    expect(report).toContain("Conviction remains high.");
+    expect(report).toContain("Recent News");
+    expect(report).toContain("NVIDIA unveils next platform");
+    expect(report).toContain("Example News");
+    expect(report).toContain("Recent SEC Filings");
+    expect(report).toContain("8-K | Mar 31, 2026");
+    expect(report).toContain("Current report announcing a product launch");
+  });
+});
+
+describe("CLI search helpers", () => {
+  test("merges local ticker matches with provider company search results", async () => {
+    const candidates = await searchCandidatesForCli({
+      query: "micro",
+      tickers: [
+        makeTicker({
+          ticker: "MSFT",
+          name: "Microsoft Corporation",
+          exchange: "NASDAQ",
+          assetCategory: "STK",
+        }),
+      ],
+      dataProvider: createTestDataProvider({
+        search: async () => [{
+          providerId: "yahoo",
+          symbol: "MSTR",
+          name: "MicroStrategy Incorporated",
+          exchange: "NASDAQ",
+          type: "EQUITY",
+          currency: "USD",
+        }],
+      }),
+    });
+
+    expect(candidates.some((candidate) => candidate.label === "MSFT")).toBe(true);
+    expect(candidates.some((candidate) => candidate.label === "MSTR")).toBe(true);
+
+    const report = buildSearchReport({
+      query: "micro",
+      candidates,
+    });
+
+    expect(report).toContain("Search: micro");
+    expect(report).toContain("MSFT");
+    expect(report).toContain("Microsoft Corporation");
+    expect(report).toContain("MSTR");
+    expect(report).toContain("MicroStrategy Incorporated");
+    expect(report).toContain("Saved");
+    expect(report).toContain("yahoo");
+  });
+
+  test("renders an empty state when no search results match", () => {
+    const report = buildSearchReport({
+      query: "zzzz",
+      candidates: [],
+    });
+
+    expect(report).toContain("Search: zzzz");
+    expect(report).toContain("No matches found.");
+  });
+});