gloomberb 0.15.2 → 0.15.4

package/src/cli/commands/plugins.test.ts

@@ -1,29 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import { parseRemoteHead } from "./plugins";
-
-/**
- * `git ls-remote` is the only way to know whether a plugin the registry does
- * not list has moved, and its output is a tab-separated line per ref. Anything
- * else, including the empty answer a repository we cannot reach gives, has to
- * read as "no answer" rather than as a commit.
- */
-describe("parseRemoteHead", () => {
-  test("takes the sha from the HEAD line", () => {
-    expect(parseRemoteHead("abfdcf0aa3e4a0f6f0d2c8ab2cf4b0a0d9e1f234\tHEAD\n"))
-      .toBe("abfdcf0aa3e4a0f6f0d2c8ab2cf4b0a0d9e1f234");
-  });
-
-  test("ignores surrounding whitespace", () => {
-    expect(parseRemoteHead("  2222222bbb3333333ccc4444444ddd5555555eee  \tHEAD  "))
-      .toBe("2222222bbb3333333ccc4444444ddd5555555eee");
-  });
-
-  test("returns null for an empty or non-sha answer", () => {
-    expect(parseRemoteHead("")).toBeNull();
-    expect(parseRemoteHead("\n")).toBeNull();
-    expect(parseRemoteHead("fatal: could not read Username for 'https://github.com'")).toBeNull();
-    // Too short to be a commit, so it is something else that happened to be printed.
-    expect(parseRemoteHead("abc123\tHEAD")).toBeNull();
-  });
-});

package/src/cli/commands/quote-price-basis.test.ts

@@ -1,88 +0,0 @@
-import { expect, test } from "bun:test";
-import { createDefaultConfig } from "../../types/config";
-import type { Quote, TickerFinancials } from "../../types/financials";
-import type { CliCommandContext } from "../../types/plugin";
-import type { HeadlessPaneContext } from "../../types/headless";
-import { createTestDataProvider } from "../../test-support/data-provider";
-import { renderHeadlessPaneText } from "../pane-functions/headless";
-import { quoteComparisonHeadless } from "../../plugins/builtin/ticker-detail/headless";
-import { marketDataCliCommands } from "./market";
-import { buildTickerReport } from "./ticker";
-
-const config = createDefaultConfig("/tmp/gloom-quote-basis-test");
-const rawQuote = { symbol: "BONDTEST", price: 87, change: 1, changePercent: 100 / 86,
-  currency: "USD", lastUpdated: 1_789_200_000_000, instrumentType: "BOND" } satisfies Quote;
-
-// The same raw values travel through different display adapters. The convention
-// belongs to the successful quote, independent of saved holdings/classification.
-test("ticker report keeps quote and change units consistent without a saved ticker", async () => {
-  for (const [quote, quoteMetadata, price, change] of [
-    [{ ...rawQuote, priceBasis: "percent-of-par" }, undefined, "87% par", "+1% par"],
-    [rawQuote, undefined, null, "—"],
-    [{ ...rawQuote, instrumentType: undefined }, { instrumentType: "BOND" }, null, "—"],
-    [{ ...rawQuote, priceBasis: "per-unit" }, undefined, "$87", "+$1.00"],
-    [{ ...rawQuote, instrumentType: "STK" }, { instrumentType: "BOND" }, "$87", "+$1.00"],
-  ] as const) {
-    const financials = { quote, quoteMetadata, annualStatements: [], quarterlyStatements: [], priceHistory: [] } as TickerFinancials;
-    const text = await buildTickerReport({ symbol: rawQuote.symbol, tickerFile: null, financials, config, toBase: async value => value });
-    const lastLine = text.split("\n").find(line => line.includes("Last")) ?? "";
-    const changeLine = text.split("\n").find(line => line.includes("Change")) ?? "";
-    if (price === null) expect(lastLine === "" || lastLine.includes("—")).toBe(true);
-    else expect(lastLine).toContain(price);
-    expect(changeLine).toContain(change);
-    if (price === "87% par") expect(changeLine).not.toContain("$");
-  }
-});
-
-test("quote command preserves raw declarations and formats its actual output rows", async () => {
-  const quotes = [
-    { ...rawQuote, symbol: "PAR", priceBasis: "percent-of-par" as const },
-    { ...rawQuote, symbol: "UNKNOWN" },
-    { ...rawQuote, symbol: "UNIT", priceBasis: "per-unit" as const },
-    { ...rawQuote, symbol: "^IDX", instrumentType: "INDEX" },
-    { ...rawQuote, symbol: "^N225", instrumentType: "INDEX", currency: "JPY", price: 65018.95, change: 882.75 },
-    { ...rawQuote, symbol: "7203.T", instrumentType: "EQUITY", currency: "JPY", price: 2710, change: 12 },
-  ];
-  let closed = 0;
-  let captured: unknown;
-  let rows: Array<Record<string, unknown>> = [];
-  const ctx = {
-    cliOptions: {},
-    initMarketData: async () => ({ config, persistence: { close() { closed++; } }, dataProvider: {
-      getQuotesBatch: async () => quotes.map(quote => ({ target: { symbol: quote.symbol, exchange: "" }, quote })),
-    } }),
-    printResult: (result: { data: unknown }, options: { rows: (data: unknown) => Array<Record<string, unknown>> }) => {
-      captured = result.data;
-      rows = options.rows(result.data);
-    },
-    fail(message: string): never { throw new Error(message); },
-  } as unknown as CliCommandContext;
-  await marketDataCliCommands.find(command => command.name === "quote")!.execute(quotes.map(quote => quote.symbol), ctx);
-  expect((captured as Array<{ quote: Quote }>).map(row => row.quote)).toEqual(quotes);
-  // An index level is in points, never dollars.
-  // A yen-listed index pads its points like any other; yen prices keep no decimals.
-  expect(rows.map(row => row.price)).toEqual(["87.00% par", "—", "$87.00", "87.00", "65,018.95", "¥2,710"]);
-  expect(rows[4]!.previousClose).toBe("64,136.20");
-  expect(rows.map(row => row.rawPrice)).toEqual([87, 87, 87, 87, 65018.95, 2710]);
-  expect(closed).toBe(1);
-});
-
-test("quote monitor headless text and raw rows agree on par, unknown and monetary units", async () => {
-  for (const basis of ["percent-of-par", undefined, "per-unit"] as const) {
-    const quote = { ...rawQuote, priceBasis: basis };
-    const args = { symbols: [quote.symbol], argument: [quote.symbol], rawArgument: quote.symbol, options: {} };
-    const ctx = { signal: new AbortController().signal, marketData: createTestDataProvider({ getQuote: async () => quote }) } as HeadlessPaneContext;
-    const result = await quoteComparisonHeadless.load(args, ctx);
-    const restored = JSON.parse(JSON.stringify(result));
-    expect(restored.rows[0]).toMatchObject({ price: 87, change: 1, instrumentType: "BOND", currency: "USD" });
-    expect(restored.rows[0].priceBasis).toBe(basis);
-    const text = renderHeadlessPaneText(quoteComparisonHeadless, result, args, "Quote Monitor");
-    if (basis === "percent-of-par") {
-      expect(text).toContain("87.00% par"); expect(text).toContain("+1.00% par"); expect(text).not.toContain("$");
-    } else if (basis === "per-unit") {
-      expect(text).toContain("$87.00"); expect(text).toContain("+$1.00");
-    } else {
-      expect(text).not.toContain("$87"); expect(text).not.toContain("+$1"); expect(text).not.toContain("+—");
-    }
-  }
-});

package/src/cli/commands/ticker-financial-units.test.ts

@@ -1,78 +0,0 @@
-import { expect, test } from "bun:test";
-import { createDefaultConfig } from "../../types/config";
-import type { TickerFinancials } from "../../types/financials";
-import { buildTickerReport, renderFundamentalsReport } from "./ticker";
-
-const config = createDefaultConfig("/tmp/gloom-ticker-units-unused");
-const quote = { symbol: "UNITTEST", price: 100, currency: "USD", change: 0, changePercent: 0, lastUpdated: Date.parse("2026-09-11") };
-async function report(financials: TickerFinancials): Promise<string> {
-  return (await buildTickerReport({ symbol: "UNITTEST", tickerFile: null, financials, config, toBase: async value => value }))
-    .replace(/\u001b\[[0-9;]*m/g, "").replace(/ {2,}/g, " ");
-}
-
-test("ticker monetary fundamentals keep reported units across foreign, minor and unknown currencies", async () => {
-  for (const [currency, eps] of [["CNY", "CN¥2.50"], ["GBp", "2.50 GBp"], ["GBX", "2.50 GBX"], ["ILA", "2.50 ILA"], ["ZAc", "2.50 ZAc"], [" ", "2.50 (ccy?)"]] as const) {
-    const financials: TickerFinancials = { quote, annualStatements: [], quarterlyStatements: [], priceHistory: [],
-      fundamentals: { eps: 2.5, revenue: 1_000_000, netIncome: 0, freeCashFlow: -25_000, financialCurrency: currency },
-    };
-    const text = await report(financials);
-    expect(text).toContain(`EPS ${eps}`);
-    expect(text).toContain(`Revenue 1M ${currency.trim() || "(ccy?)"}`);
-    expect(text).toContain(`Net Income 0 ${currency.trim() || "(ccy?)"}`);
-    expect(text).toContain(`Free Cash Flow -25k ${currency.trim() || "(ccy?)"}`);
-    expect(financials.fundamentals?.eps).toBe(2.5);
-  }
-});
-
-test("statement units use compatible history, keep explicit overrides and exclude share counts", async () => {
-  const financials: TickerFinancials = { quote, priceHistory: [], financialCurrency: "CNY",
-    annualStatements: [{ date: "2025-12-31", eps: 0, totalRevenue: 1_000_000, dilutedShares: 400_000 }], quarterlyStatements: [],
-  };
-  expect(await report(financials)).toContain("Diluted EPS CN¥0.00");
-  financials.quarterlyStatements.push({ date: "2026-06-30", currency: "EUR", eps: -1.25, totalRevenue: 200_000 });
-  const mixed = await report(financials);
-  expect(mixed).toContain("Diluted EPS 0.00 (ccy?)");
-  expect(mixed).toContain("Diluted EPS -€1.25");
-  expect(mixed).toContain("Revenue 200k EUR");
-  expect(mixed).toContain("Diluted Shares 400k");
-  expect(mixed).not.toContain("Diluted Shares 400k CNY");
-  financials.annualStatements[0]!.currency = "GBp";
-  expect(await report(financials)).toContain("Diluted EPS 0.00 GBp");
-  financials.annualStatements[0]!.eps = Number.NaN;
-  expect(await report(financials)).not.toContain("NaN");
-});
-
-test("enterprise value is shown in the market cap's currency, converted or labelled", async () => {
-  const financials: TickerFinancials = { quote: { ...quote, currency: "CHF", marketCap: 200e9 }, annualStatements: [], quarterlyStatements: [], priceHistory: [],
-    fundamentals: { marketCap: 200e9, marketCapCurrency: "CHF", enterpriseValue: 255e9 },
-  };
-  const render = async (toBase: (value: number, currency: string) => Promise<number>) => (
-    await buildTickerReport({ symbol: "UNITTEST", tickerFile: null, financials, config, toBase })
-  ).replace(/\u001b\[[0-9;]*m/g, "").replace(/ {2,}/g, " ");
-  const converted = await render(async (value, currency) => currency === "CHF" ? value * 1.2 : value);
-  expect(converted).toContain("Market Cap 240B USD");
-  expect(converted).toContain("Enterprise Value 306B USD");
-  const unconverted = await render(async () => Number.NaN);
-  expect(unconverted).toContain("Market Cap 200B CHF");
-  expect(unconverted).toContain("Enterprise Value 255B CHF");
-  // Local Yahoo fundamentals declare no capitalization unit: the listing's quote currency applies.
-  const undeclared: TickerFinancials = { quote: { ...quote, marketCap: 3.8e12 }, annualStatements: [], quarterlyStatements: [], priceHistory: [],
-    fundamentals: { enterpriseValue: 3.85e12 },
-  };
-  const plain = await report(undeclared);
-  expect(plain).toContain("Market Cap 3.8T USD");
-  expect(plain).toContain("Enterprise Value 3.85T USD");
-  expect(renderFundamentalsReport({ ...undeclared, symbol: "UNITTEST" }, "valuation").replace(/\u001b\[[0-9;]*m/g, "").replace(/ {2,}/g, " "))
-    .toContain("Enterprise Value 3.85T USD");
-});
-
-test("a pence-quoted range shares one decimal count, other ranges are unchanged", async () => {
-  const pence = { ...quote, currency: "GBP", instrumentType: "EQUITY", providerPriceDivisor: 100, price: 35.32, low: 35.1, high: 35.4871, low52w: 25.5377, high52w: 37.585 };
-  const london = await report({ quote: pence, annualStatements: [], quarterlyStatements: [], priceHistory: [] });
-  expect(london).toContain("Day Range £35.1000 - £35.4871");
-  expect(london).toContain("52W Range £25.5377 - £37.5850");
-  const yen = await report({ quote: { ...quote, currency: "JPY", instrumentType: "EQUITY", price: 3000, low: 2950, high: 3012 }, annualStatements: [], quarterlyStatements: [], priceHistory: [] });
-  expect(yen).toContain("Day Range ¥2,950 - ¥3,012");
-  const dollars = await report({ quote: { ...quote, instrumentType: "EQUITY", low: 99.5, high: 101.25 }, annualStatements: [], quarterlyStatements: [], priceHistory: [] });
-  expect(dollars).toContain("Day Range $99.50 - $101.25");
-});

package/src/cli/commands/ticker-period.test.ts

@@ -1,62 +0,0 @@
-import { expect, test } from "bun:test";
-import { createDefaultConfig } from "../../types/config";
-import type { TickerFinancials } from "../../types/financials";
-import type { MarketContext } from "../types";
-import { createTestDataProvider } from "../../test-support/data-provider";
-import { buildFinancialTableModel } from "../../plugins/builtin/ticker-detail/financials/model";
-import { buildTickerReport, ticker } from "./ticker";
-
-const config = createDefaultConfig("/tmp/gloom-ticker-period-unused");
-async function reports(financials: TickerFinancials) {
-  const text = (await buildTickerReport({ symbol: "PERIOD", tickerFile: null, financials, config, toBase: async value => value }))
-    .replace(/\u001b\[[0-9;]*m/g, "");
-  let data: any;
-  await ticker("PERIOD", {
-    initMarketData: async () => ({
-      config, dataDir: "/tmp/gloom-ticker-period-unused",
-      store: { loadTicker: async () => null }, persistence: { close: () => {} },
-      dataProvider: { ...createTestDataProvider({ getTickerFinancials: async () => financials }), getNews: async () => [] },
-    }) as unknown as MarketContext,
-    fail: message => { throw new Error(message); }, printResult: result => { data = result.data; },
-  });
-  return { text, data };
-}
-
-test("ticker text and JSON agree with Financials for ascending, descending and mixed provider periods", async () => {
-  for (const order of [[0, 1, 2], [2, 1, 0], [1, 2, 0]]) {
-    const annual = ["2023-12-31", "2024-12-31", "2025-12-31"].map((date, index) => ({ date, currency: "USD", totalRevenue: index === 2 ? 0 : 100 }));
-    const quarterly = ["2025-12-31", "2026-03-31", "2026-06-30"].map((date, index) => ({ date, currency: "EUR", totalRevenue: index === 2 ? 0 : 50 }));
-    const financials = { annualStatements: order.map(i => annual[i]!), quarterlyStatements: order.map(i => quarterly[i]!), priceHistory: [] };
-    const original = JSON.stringify(financials);
-    const { text, data } = await reports(financials);
-    expect(data.latestAnnual).toEqual(annual[2]); expect(data.latestQuarter).toEqual(quarterly[2]);
-    expect(text).toContain("Latest Annual (2025-12-31)"); expect(text).toContain("Latest Quarter (2026-06-30)");
-    expect(buildFinancialTableModel(financials, { period: "annual" })?.statements[0]?.date).toBe(data.latestAnnual.date);
-    expect(buildFinancialTableModel(financials, { period: "quarterly" })?.statements[0]?.date).toBe(data.latestQuarter.date);
-    expect(JSON.stringify(financials)).toBe(original);
-  }
-});
-
-test("latest selection retains partial rows, original equal-period precedence and raw statement counts", async () => {
-  const latest = { date: "2026-06-30", netIncome: 0 };
-  const finalAnnual = { date: "2025-12-31", totalRevenue: 0, currency: "GBP" };
-  const financials: TickerFinancials = {
-    priceHistory: [],
-    annualStatements: [{ date: "2025-12-31", totalRevenue: 100 }, finalAnnual, { date: "2024-12-31", totalRevenue: 200 }],
-    quarterlyStatements: [latest, { date: "2026-03-31", totalRevenue: 100 }],
-  };
-  const { text, data } = await reports(financials);
-  expect(data.latestAnnual).toEqual(finalAnnual); expect(data.latestQuarter).toEqual(latest);
-  expect(data.latestQuarter.totalRevenue).toBeUndefined();
-  expect(data.annualStatementCount).toBe(3); expect(data.quarterlyStatementCount).toBe(2);
-  expect(text).toContain("Latest Quarter (2026-06-30)");
-});
-
-test("unqualified or absent periods never become a latest-period report", async () => {
-  const financials: TickerFinancials = { annualStatements: [{ date: "TTM", totalRevenue: 1 }], quarterlyStatements: [{ date: "2026-02-29", netIncome: 2 }], priceHistory: [] };
-  const { text, data } = await reports(financials);
-  expect(data.latestAnnual).toBeNull(); expect(data.latestQuarter).toBeNull(); expect(text).not.toContain("Latest");
-  financials.annualStatements = []; financials.quarterlyStatements = []; financials.profile = { description: "Known profile without dated reports." };
-  const empty = await reports(financials);
-  expect(empty.data.latestAnnual).toBeNull(); expect(empty.data.latestQuarter).toBeNull(); expect(empty.text).not.toContain("Latest");
-});

package/src/cli/context.test.ts

@@ -1,63 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { CliCommandContext } from "../types/plugin";
-import type { CliServicesContext, ConfigContext, MarketContext } from "./types";
-import {
-  ensureCliServicesReady,
-  withCliServices,
-  withConfigData,
-  withMarketData,
-} from "./context";
-
-function initializer<K extends "initConfigData" | "initMarketData" | "initServices", T>(
-  key: K,
-  value: T,
-): Pick<CliCommandContext, K> {
-  return { [key]: async () => value } as Pick<CliCommandContext, K>;
-}
-
-describe("CLI scoped contexts", () => {
-  test("closes config and market persistence after successful operations", async () => {
-    let configCloses = 0;
-    let marketCloses = 0;
-    const config = { persistence: { close: () => configCloses++ } } as unknown as ConfigContext;
-    const market = { persistence: { close: () => marketCloses++ } } as unknown as MarketContext;
-
-    expect(await withConfigData(initializer("initConfigData", config), async () => "config"))
-      .toBe("config");
-    expect(await withMarketData(initializer("initMarketData", market), async () => "market"))
-      .toBe("market");
-    expect(configCloses).toBe(1);
-    expect(marketCloses).toBe(1);
-  });
-
-  test("destroys services when an operation throws", async () => {
-    let destroys = 0;
-    const services = { destroy: () => destroys++ } as unknown as CliServicesContext;
-
-    await expect(withCliServices(initializer("initServices", services), async () => {
-      throw new Error("operation failed");
-    })).rejects.toThrow("operation failed");
-    expect(destroys).toBe(1);
-  });
-
-  test("accepts an injected market initializer and closes it when an operation throws", async () => {
-    let closes = 0;
-    const market = { persistence: { close: () => closes++ } } as unknown as MarketContext;
-
-    await expect(withMarketData(async () => market, async () => {
-      throw new Error("market operation failed");
-    })).rejects.toThrow("market operation failed");
-    expect(closes).toBe(1);
-  });
-
-  test("destroys partially initialized services when plugin setup rejects", async () => {
-    let destroys = 0;
-    const services = {
-      ready: Promise.reject(new Error("plugin setup failed")),
-      destroy: () => destroys++,
-    };
-
-    await expect(ensureCliServicesReady(services)).rejects.toThrow("plugin setup failed");
-    expect(destroys).toBe(1);
-  });
-});

package/src/cli/entry.test.ts

@@ -1,58 +0,0 @@
-import { expect, test } from "bun:test";
-import { mkdtemp, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-test("packaged UI launches restore once before loading the TUI catalog; headless commands do not restore", async () => {
-  const root = join(import.meta.dir, "../..");
-  const directory = await mkdtemp(join(tmpdir(), "gloom-cli-entry-"));
-  const preload = join(directory, "preload.ts");
-  const modulePath = (path: string) => JSON.stringify(join(root, "src", path));
-  try {
-    // Isolate module mocks from the rest of the suite, while exercising the shipped bin entry.
-    await Bun.write(preload, `
-      import { mock } from "bun:test";
-      const calls = [];
-      let restored = false;
-      mock.module(${modulePath("cli/restore-plugins.ts")}, () => ({ restoreExtractedPlugins: async () => {
-        calls.push("restore"); restored = true;
-      }}));
-      mock.module(${modulePath("plugins/loader.ts")}, () => ({ loadExternalPlugins: async (target = "cli") => {
-        calls.push("catalog:" + target);
-        return restored ? [{ plugin: { id: "tv" }, path: "tv" }] : [];
-      }}));
-      mock.module(${modulePath("cli/index.ts")}, () => ({
-        dispatchCli: async (args) => {
-          calls.push("dispatch:" + args[0]);
-          return args[0] === "handoff" ? { kind: "launch-ui", request: { source: "handoff" } } : { kind: "handled" };
-        },
-        failUnknownCliCommand: async () => {},
-      }));
-      mock.module(${modulePath("renderers/opentui/start.tsx")}, () => ({ startOpenTuiApp: async (options) => {
-        calls.push({ launch: options.externalPlugins.map((entry) => entry.plugin.id), args: options.cliArgs, request: options.cliLaunchRequest });
-      }}));
-      process.on("beforeExit", () => console.log(JSON.stringify(calls)));
-    `);
-    for (const args of [[], ["ui"], ["launch-ui", "TV"], ["handoff"], ["help"]]) {
-      const child = Bun.spawn([process.execPath, "--preload", preload, join(root, "bin/gloomberb"), ...args], {
-        cwd: root, stdout: "pipe", stderr: "pipe",
-      });
-      const [stdout, stderr, status] = await Promise.all([
-        new Response(child.stdout).text(), new Response(child.stderr).text(), child.exited,
-      ]);
-      expect({ status, stderr }).toEqual({ status: 0, stderr: "" });
-      const calls = JSON.parse(stdout.trim());
-      if (args[0] === "help") {
-        expect(calls).toEqual(["catalog:cli", "dispatch:help"]);
-      } else {
-        expect(calls).toEqual([
-          ...(args[0] === "handoff" ? ["catalog:cli", "dispatch:handoff"] : []),
-          "restore", "catalog:tui",
-          { launch: ["tv"], args: args[0] === "launch-ui" ? ["TV"] : [], request: args[0] === "handoff" ? { source: "handoff" } : null },
-        ]);
-      }
-    }
-  } finally {
-    await rm(directory, { recursive: true, force: true });
-  }
-});

package/src/cli/history-rows.test.ts

@@ -1,47 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { cleanFloat32Price, historyPriceDecimals, historyRows } from "./history-rows";
-
-const daily = (bars: number[][]) => historyRows(bars.map(([open, high, low, close], index) => ({
-  date: new Date(Date.UTC(2026, 0, index + 1)), open, high, low, close: close!,
-})), "1d");
-
-describe("history rows", () => {
-  test("float32 noise from either source becomes the intended decimal while real precision stays", () => {
-    // Yahoo sends the exact float32.
-    expect(cleanFloat32Price(Math.fround(340.33))).toBe(340.33);
-    expect(cleanFloat32Price(Math.fround(109556.16))).toBe(109556.16);
-    expect(cleanFloat32Price(Math.fround(0.00000537))).toBe(0.00000537);
-    // Cloud daily sends the float32 already rounded to five or six decimals.
-    expect([254.42999, 251.039993, 255.74001, 377.059998].map(cleanFloat32Price)).toEqual([254.43, 251.04, 255.74, 377.06]);
-    // Doubles, FX quotes and sub-cent coins that are already the shortest form keep every digit.
-    for (const value of [750123.45, 342.615, 1.147934, 1.1801081, 0.0000053712]) expect(cleanFloat32Price(value)).toBe(value);
-  });
-
-  test("intraday bars keep their UTC time; daily bars stay trading dates", () => {
-    const intraday = historyRows([
-      { date: new Date("2026-09-22T13:30:00Z"), close: 1 },
-      { date: new Date("2026-09-22T13:35:00Z"), close: 1 },
-    ], "5m");
-    expect(intraday.map((row) => row.date)).toEqual(["2026-09-22T13:30:00Z", "2026-09-22T13:35:00Z"]);
-    // Without a declared cadence, spacing decides: daily bars stamped at the session open stay dates.
-    const sessionOpens = ["2026-09-21T13:30:00Z", "2026-09-22T13:30:00Z", "2026-09-23T13:30:00Z"];
-    expect(historyRows(sessionOpens.map((date) => ({ date: new Date(date), close: 1 })), null).map((row) => row.date))
-      .toEqual(["2026-09-21", "2026-09-22", "2026-09-23"]);
-    expect(historyRows([{ date: new Date("2026-09-22T15:00:00Z"), close: 1 }, { date: new Date("2026-09-22T15:15:00Z"), close: 1 }], null)[1]!.date)
-      .toBe("2026-09-22T15:15:00Z");
-  });
-
-  test("one decimal count per table that neither pads BTC nor zeroes sub-cent coins", () => {
-    // Cloud AAPL daily, with one bar carrying a genuine sub-penny print.
-    expect(historyPriceDecimals(daily([
-      [255.88, 257.34, 253.58, 254.42999], [255.22, 255.74001, 251.039993, 252.31],
-      [253.21001, 257.17001, 251.71001, 256.87], [254.1, 257.6, 253.7812, 255.46],
-    ]))).toBe(2);
-    expect(historyPriceDecimals(daily([[73031.086, 79463.71, 73011.414, 78335.19], [78332.555, 78801.15, 76526.71, 77083.414]]))).toBe(2);
-    expect(historyPriceDecimals(daily([[1.1684973, 1.1691804, 1.1660856, 1.168156], [1.1668475, 1.1675423, 1.1651752, 1.1668339]]))).toBe(6);
-    const shib = [[0.00000537, 0.00000539, 0.00000537, 0.00000539], [0.00000539, 0.00000546, 0.00000538, 0.00000546]];
-    expect(historyPriceDecimals(daily(shib.map((bar) => bar.map(Math.fround))))).toBe(8);
-    // A known kind applies the app's price rules: an equity shows cents even with sub-penny prints.
-    expect(historyPriceDecimals(daily([[334.5795, 335.48, 333.1697, 334.225], [334.26, 334.1216, 332.8706, 333.8972]]), "STK")).toBe(2);
-  });
-});

package/src/cli/options.test.ts

@@ -1,45 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { parseCliGlobalArgs } from "./options";
-
-describe("parseCliGlobalArgs", () => {
-  test("extracts global output and execution flags anywhere before --", () => {
-    const parsed = parseCliGlobalArgs([
-      "quote",
-      "--json",
-      "AAPL",
-      "--limit",
-      "2",
-      "--refresh",
-      "--dry-run",
-      "--yes",
-      "--no-color",
-    ]);
-
-    expect(parsed.args).toEqual(["quote", "AAPL"]);
-    expect(parsed.options).toMatchObject({
-      format: "json",
-      limit: 2,
-      refresh: true,
-      dryRun: true,
-      yes: true,
-      color: false,
-    });
-  });
-
-  test("takes help flags out of the arguments so a command never reads them as input", () => {
-    const parsed = parseCliGlobalArgs(["notes", "set", "-h", "AAPL", "--help"]);
-    expect(parsed.args).toEqual(["notes", "set", "AAPL"]);
-    expect(parsed.help).toBe(true);
-  });
-
-  test("leaves arguments after -- untouched", () => {
-    const parsed = parseCliGlobalArgs(["ai", "ask", "--", "--json", "--help"]);
-    expect(parsed.args).toEqual(["ai", "ask", "--json", "--help"]);
-    expect(parsed.options.format).toBe("text");
-    expect(parsed.help).toBe(false);
-  });
-
-  test("rejects invalid limits", () => {
-    expect(() => parseCliGlobalArgs(["quote", "AAPL", "--limit=0"])).toThrow("--limit");
-  });
-});

package/src/cli/pane-functions/cloud-session.test.ts

@@ -1,77 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { apiClient } from "../../api-client";
-import type { MarketContext } from "../types";
-import {
-  resolvePersistedCloudSessionToken,
-  withPersistedCloudSession,
-} from "./cloud-session";
-
-function contextWithSession(
-  key: string,
-  sessionToken: string,
-): Pick<MarketContext, "persistence"> {
-  return {
-    persistence: {
-      pluginState: {
-        get: (_pluginId: string, candidate: string) => candidate === key
-          ? { value: { sessionToken }, schemaVersion: 1, updatedAt: 1 }
-          : null,
-      },
-    },
-  } as Pick<MarketContext, "persistence">;
-}
-
-describe("pane function Cloud session", () => {
-  test("restores the current and legacy persisted session keys", () => {
-    expect(resolvePersistedCloudSessionToken(
-      contextWithSession("resume:session", "current-session"),
-    )).toBe("current-session");
-    expect(resolvePersistedCloudSessionToken(
-      contextWithSession("session", "legacy-session"),
-    )).toBe("legacy-session");
-  });
-
-  test("scopes the persisted session to one report load", async () => {
-    const initial = apiClient.getSessionToken();
-    apiClient.setSessionToken("previous-session");
-    try {
-      let activeSession: string | null = null;
-      const result = await withPersistedCloudSession(
-        contextWithSession("resume:session", "report-session"),
-        async () => {
-          activeSession = apiClient.getSessionToken();
-          return 42;
-        },
-      );
-
-      expect(result).toBe(42);
-      expect(activeSession).toBe("report-session");
-      expect(apiClient.getSessionToken()).toBe("previous-session");
-    } finally {
-      apiClient.setSessionToken(initial);
-    }
-  });
-});
-
-describe("cloud session token from the environment", () => {
-  test("prefers GLOOMBERB_SESSION_TOKEN over persisted state so containers can authenticate", () => {
-    const context = {
-      persistence: {
-        pluginState: {
-          get: () => ({ value: { sessionToken: "persisted-token" } }),
-        },
-      },
-    } as unknown as Parameters<typeof resolvePersistedCloudSessionToken>[0];
-
-    const previous = process.env.GLOOMBERB_SESSION_TOKEN;
-    try {
-      process.env.GLOOMBERB_SESSION_TOKEN = "env-token";
-      expect(resolvePersistedCloudSessionToken(context)).toBe("env-token");
-      delete process.env.GLOOMBERB_SESSION_TOKEN;
-      expect(resolvePersistedCloudSessionToken(context)).toBe("persisted-token");
-    } finally {
-      if (previous === undefined) delete process.env.GLOOMBERB_SESSION_TOKEN;
-      else process.env.GLOOMBERB_SESSION_TOKEN = previous;
-    }
-  });
-});

package/src/cli/pane-functions/data.test.ts

@@ -1,17 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { clipPriceHistoryToRange } from "./data";
-
-describe("clipPriceHistoryToRange", () => {
-  test("anchors the requested window to the newest provider observation", () => {
-    const points = [
-      { date: new Date("2025-07-16T00:00:00Z"), close: 100 },
-      { date: new Date("2025-07-17T00:00:00Z"), close: 101 },
-      { date: new Date("2026-07-17T00:00:00Z"), close: 120 },
-    ];
-
-    expect(clipPriceHistoryToRange(points, "1Y").map(({ date }) => date.toISOString().slice(0, 10))).toEqual([
-      "2025-07-17",
-      "2026-07-17",
-    ]);
-  });
-});

package/src/cli/pane-functions/discovery.test.ts

@@ -1,36 +0,0 @@
-import { expect, test } from "bun:test";
-import { createDefaultConfig } from "../../types/config";
-import type { GloomPlugin } from "../../types/plugin";
-import type { MarketContext } from "../types";
-import { createPaneCatalog } from "./discovery";
-
-const context = { config: createDefaultConfig("/tmp/discovery-test") } as MarketContext;
-
-function plugin(id: string, overrides: Partial<GloomPlugin> = {}): GloomPlugin {
-  return { id, name: id, version: "1", setup() {}, ...overrides };
-}
-
-test("failed discovery unwinds every started plugin, preserving the setup error", async () => {
-  const disposed: string[] = [];
-  const failure = new Error("setup failed");
-  await expect(createPaneCatalog(context, [
-    plugin("first", { dispose() { disposed.push("first"); } }),
-    plugin("second", {
-      setup() { throw failure; },
-      dispose() { disposed.push("second"); throw new Error("dispose failed"); },
-    }),
-    plugin("never started", { dispose() { disposed.push("never started"); } }),
-  ])).rejects.toBe(failure);
-  expect(disposed).toEqual(["second", "first"]);
-});
-
-test("destroy drains discovery once even when a disposer throws", async () => {
-  const disposed: string[] = [];
-  const catalog = await createPaneCatalog(context, [
-    plugin("first", { dispose() { disposed.push("first"); } }),
-    plugin("second", { dispose() { disposed.push("second"); throw new Error("dispose failed"); } }),
-  ]);
-  expect(() => catalog.destroy()).toThrow("dispose failed");
-  expect(() => catalog.destroy()).not.toThrow();
-  expect(disposed).toEqual(["second", "first"]);
-});