gloomberb 0.2.0 → 0.3.1

package/src/utils/ascii-chart.ts

@@ -0,0 +1,172 @@
+/**
+ * ASCII stock chart using braille characters (U+2800-U+28FF).
+ * Each braille char is 2 columns x 4 rows of dots.
+ */
+
+const BRAILLE_BASE = 0x2800;
+// Dot bit positions for each column (left=0, right=1) and row (0=top, 3=bottom)
+const DOT_BITS = [
+  [0x01, 0x02, 0x04, 0x40], // left column
+  [0x08, 0x10, 0x20, 0x80], // right column
+];
+
+export interface StockChartOptions {
+  width: number;   // chart width in characters
+  height: number;  // chart height in terminal rows
+  showAxis?: boolean;
+  showLabels?: boolean;
+}
+
+export interface StockChartData {
+  dates: (Date | string | number)[];
+  prices: number[];
+}
+
+/**
+ * Render a full stock chart with braille line, axis labels, and price range.
+ * Returns an array of strings (one per terminal row).
+ */
+export function renderStockChart(
+  data: StockChartData,
+  opts: StockChartOptions,
+): string[] {
+  const { dates, prices } = data;
+  if (prices.length === 0) return [];
+
+  const showAxis = opts.showAxis !== false;
+  const showLabels = opts.showLabels !== false;
+
+  // Reserve space for labels
+  const priceAxisWidth = showLabels ? 10 : 0;
+  const chartWidth = opts.width - priceAxisWidth;
+  const chartHeight = opts.height - (showAxis ? 1 : 0); // bottom row for time axis
+
+  if (chartWidth < 4 || chartHeight < 2) return [];
+
+  const min = Math.min(...prices);
+  const max = Math.max(...prices);
+  const range = max - min || 1;
+  const totalDotsV = chartHeight * 4; // vertical braille resolution
+
+  // Sample prices to fit chart width (2 data points per braille char)
+  const sampleCount = chartWidth * 2;
+  const sampled: number[] = [];
+  const sampledDates: (Date | string | number)[] = [];
+  for (let i = 0; i < sampleCount; i++) {
+    const srcIdx = Math.floor((i / sampleCount) * prices.length);
+    sampled.push(prices[srcIdx]!);
+    sampledDates.push(dates[srcIdx]!);
+  }
+
+  // Convert to dot Y positions (0 = bottom, totalDotsV-1 = top)
+  const dotPositions = sampled.map(
+    (v) => Math.round(((v - min) / range) * (totalDotsV - 1))
+  );
+
+  // Build braille chart rows with connected lines
+  const chartLines: string[] = [];
+  for (let row = 0; row < chartHeight; row++) {
+    let line = "";
+    for (let col = 0; col < chartWidth; col++) {
+      let bits = 0;
+      for (let subCol = 0; subCol < 2; subCol++) {
+        const valueIdx = col * 2 + subCol;
+        const dotY = dotPositions[valueIdx] ?? 0;
+        // Get previous data point to interpolate a connected line
+        const prevIdx = valueIdx - 1;
+        const prevDotY = prevIdx >= 0 ? (dotPositions[prevIdx] ?? dotY) : dotY;
+        const lo = Math.min(dotY, prevDotY);
+        const hi = Math.max(dotY, prevDotY);
+
+        const rowBottomDot = (chartHeight - 1 - row) * 4;
+        for (let subRow = 0; subRow < 4; subRow++) {
+          const absoluteDot = rowBottomDot + subRow;
+          // Draw connected line: fill between current and previous point
+          if (absoluteDot >= lo && absoluteDot <= hi) {
+            bits |= DOT_BITS[subCol]![subRow]!;
+          }
+        }
+      }
+      line += String.fromCharCode(BRAILLE_BASE + bits);
+    }
+    chartLines.push(line);
+  }
+
+  // Build full output with labels
+  const output: string[] = [];
+
+  for (let row = 0; row < chartHeight; row++) {
+    let line = "";
+    if (showLabels) {
+      // Price label on right side at top, middle, bottom
+      let label = "";
+      if (row === 0) {
+        label = formatAxisPrice(max);
+      } else if (row === Math.floor(chartHeight / 2)) {
+        label = formatAxisPrice((max + min) / 2);
+      } else if (row === chartHeight - 1) {
+        label = formatAxisPrice(min);
+      }
+      line = chartLines[row]! + " " + label.padStart(priceAxisWidth - 1);
+    } else {
+      line = chartLines[row]!;
+    }
+    output.push(line);
+  }
+
+  // Time axis
+  if (showAxis && dates.length > 0) {
+    const firstDate = dates[0]!;
+    const lastDate = dates[dates.length - 1]!;
+    const midDate = dates[Math.floor(dates.length / 2)]!;
+
+    const startLabel = formatAxisDate(firstDate);
+    const midLabel = formatAxisDate(midDate);
+    const endLabel = formatAxisDate(lastDate);
+
+    let axis = startLabel;
+    const midPos = Math.floor(chartWidth / 2) - Math.floor(midLabel.length / 2);
+    const endPos = chartWidth - endLabel.length;
+
+    // Build axis string with proper spacing
+    axis = startLabel.padEnd(midPos) + midLabel;
+    axis = axis.padEnd(endPos) + endLabel;
+    if (axis.length > chartWidth + priceAxisWidth) {
+      axis = axis.slice(0, chartWidth + priceAxisWidth);
+    }
+    output.push(axis);
+  }
+
+  return output;
+}
+
+function formatAxisPrice(value: number): string {
+  if (Math.abs(value) >= 1e6) return `$${(value / 1e6).toFixed(1)}M`;
+  if (Math.abs(value) >= 1e3) return `$${(value / 1e3).toFixed(1)}K`;
+  return `$${value.toFixed(2)}`;
+}
+
+function formatAxisDate(date: Date | string | number): string {
+  const months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+  const d = date instanceof Date ? date : new Date(date);
+  if (isNaN(d.getTime())) return "—";
+  return `${months[d.getMonth()]} ${d.getFullYear()}`;
+}
+
+/** Simple block sparkline for inline use (single line) */
+export function inlineSparkline(values: number[], width: number): string {
+  if (values.length === 0) return " ".repeat(width);
+  const blocks = ["▁", "▂", "▃", "▄", "▅", "▆", "▇", "█"];
+  const min = Math.min(...values);
+  const max = Math.max(...values);
+  const range = max - min || 1;
+
+  let result = "";
+  for (let i = 0; i < width; i++) {
+    const idx = Math.floor((i / width) * values.length);
+    const normalized = (values[idx]! - min) / range;
+    const blockIdx = Math.min(Math.floor(normalized * blocks.length), blocks.length - 1);
+    result += blocks[blockIdx];
+  }
+  return result;
+}

package/src/utils/broker-instances.ts

@@ -0,0 +1,47 @@
+import type { BrokerInstanceConfig } from "../types/config";
+
+function slugify(value: string): string {
+  return value
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-|-$/g, "");
+}
+
+export function createBrokerInstanceId(
+  brokerType: string,
+  label: string,
+  existingIds: Iterable<string>,
+): string {
+  const base = `${brokerType}-${slugify(label) || "account"}`;
+  const seen = new Set(existingIds);
+  if (!seen.has(base)) return base;
+
+  let suffix = 2;
+  while (seen.has(`${base}-${suffix}`)) {
+    suffix += 1;
+  }
+  return `${base}-${suffix}`;
+}
+
+export function buildBrokerPortfolioId(brokerInstanceId: string, accountId?: string): string {
+  return `broker:${brokerInstanceId}:${accountId?.trim() || "default"}`;
+}
+
+export function isBrokerPortfolioId(collectionId: string | undefined | null): collectionId is string {
+  return typeof collectionId === "string" && collectionId.startsWith("broker:");
+}
+
+export function getBrokerInstance(
+  brokerInstances: BrokerInstanceConfig[],
+  instanceId: string | undefined,
+): BrokerInstanceConfig | undefined {
+  if (!instanceId) return undefined;
+  return brokerInstances.find((instance) => instance.id === instanceId);
+}
+
+export function getBrokerInstancesByType(
+  brokerInstances: BrokerInstanceConfig[],
+  brokerType: string,
+): BrokerInstanceConfig[] {
+  return brokerInstances.filter((instance) => instance.brokerType === brokerType);
+}

package/src/utils/cli-output.ts

@@ -0,0 +1,83 @@
+export type CliAlign = "left" | "right" | "center";
+
+export interface CliTableColumn {
+  header: string;
+  align?: CliAlign;
+  width?: number;
+}
+
+const ANSI_PATTERN = /\x1b\[[0-9;]*m/g;
+
+function colorEnabled(): boolean {
+  return !!process.stdout.isTTY && process.env.NO_COLOR !== "1" && process.env.TERM !== "dumb";
+}
+
+function applyAnsi(text: string, code: string): string {
+  if (!colorEnabled()) return text;
+  return `\x1b[${code}m${text}\x1b[0m`;
+}
+
+export function stripAnsi(text: string): string {
+  return text.replace(ANSI_PATTERN, "");
+}
+
+export function visibleLength(text: string): number {
+  return stripAnsi(text).length;
+}
+
+export function padDisplay(text: string, width: number, align: CliAlign = "left"): string {
+  const padding = Math.max(0, width - visibleLength(text));
+  if (padding === 0) return text;
+
+  if (align === "right") return `${" ".repeat(padding)}${text}`;
+  if (align === "center") {
+    const left = Math.floor(padding / 2);
+    const right = padding - left;
+    return `${" ".repeat(left)}${text}${" ".repeat(right)}`;
+  }
+  return `${text}${" ".repeat(padding)}`;
+}
+
+export const cliStyles = {
+  bold: (text: string) => applyAnsi(text, "1"),
+  dim: (text: string) => applyAnsi(text, "2"),
+  muted: (text: string) => applyAnsi(text, "90"),
+  accent: (text: string) => applyAnsi(text, "1;36"),
+  success: (text: string) => applyAnsi(text, "32"),
+  warning: (text: string) => applyAnsi(text, "33"),
+  danger: (text: string) => applyAnsi(text, "31"),
+  positive: (text: string) => applyAnsi(text, "32"),
+  negative: (text: string) => applyAnsi(text, "31"),
+};
+
+export function colorBySign(text: string, value: number | undefined | null): string {
+  if (value == null || value === 0) return text;
+  return value > 0 ? cliStyles.positive(text) : cliStyles.negative(text);
+}
+
+export function renderSection(title: string): string {
+  return `${cliStyles.accent(title)}\n${cliStyles.muted("-".repeat(Math.max(12, title.length)))}`;
+}
+
+export function renderStat(label: string, value: string, labelWidth = 16): string {
+  return `${cliStyles.dim(padDisplay(`${label}:`, labelWidth))} ${value}`;
+}
+
+export function renderTable(columns: CliTableColumn[], rows: string[][]): string {
+  const widths = columns.map((column, index) => {
+    const cellWidths = rows.map((row) => visibleLength(row[index] ?? ""));
+    return column.width ?? Math.max(visibleLength(column.header), ...cellWidths);
+  });
+
+  const header = columns
+    .map((column, index) => cliStyles.bold(padDisplay(column.header, widths[index]!, column.align ?? "left")))
+    .join("  ");
+  const divider = widths.map((width) => cliStyles.muted("-".repeat(width))).join("  ");
+  const body = rows.map((row) =>
+    row
+      .map((cell, index) => padDisplay(cell ?? "", widths[index]!, columns[index]?.align ?? "left"))
+      .join("  ")
+  );
+
+  return [header, divider, ...body].join("\n");
+}

package/src/utils/currency-units.test.ts

@@ -0,0 +1,49 @@
+import { describe, expect, test } from "bun:test";
+import { hasLikelyQuoteUnitMismatch, normalizePriceValueByDivisor, resolveCurrencyUnit } from "./currency-units";
+
+describe("currency unit helpers", () => {
+  test("normalizes known sub-unit currencies to their main currency", () => {
+    expect(resolveCurrencyUnit("GBp")).toEqual({ currency: "GBP", divisor: 100 });
+    expect(resolveCurrencyUnit("GBP")).toEqual({ currency: "GBP", divisor: 1 });
+  });
+
+  test("scales quote prices by the configured divisor", () => {
+    expect(normalizePriceValueByDivisor(23.1, 100)).toBeCloseTo(0.231, 8);
+    expect(normalizePriceValueByDivisor(125, 1)).toBe(125);
+  });
+
+  test("detects sub-unit quotes that match the same main-currency price", () => {
+    expect(hasLikelyQuoteUnitMismatch(
+      { price: 23.1, currency: "GBp" },
+      { price: 0.231, currency: "GBP" },
+    )).toBe(true);
+  });
+
+  test("detects classic same-currency 100x mismatches", () => {
+    expect(hasLikelyQuoteUnitMismatch(
+      { price: 24.5, currency: "GBP" },
+      { price: 0.245, currency: "GBP" },
+    )).toBe(true);
+  });
+
+  test("detects likely 1000x mismatches for three-decimal currencies", () => {
+    expect(hasLikelyQuoteUnitMismatch(
+      { price: 721, currency: "KWD" },
+      { price: 0.721, currency: "KWD" },
+    )).toBe(true);
+  });
+
+  test("does not flag similar quotes that already use the same unit", () => {
+    expect(hasLikelyQuoteUnitMismatch(
+      { price: 0.231, currency: "GBP" },
+      { price: 0.245, currency: "GBP" },
+    )).toBe(false);
+  });
+
+  test("does not assume 1000x mismatches for ordinary two-decimal currencies", () => {
+    expect(hasLikelyQuoteUnitMismatch(
+      { price: 231, currency: "USD" },
+      { price: 0.231, currency: "USD" },
+    )).toBe(false);
+  });
+});

package/src/utils/currency-units.ts

@@ -0,0 +1,82 @@
+const SUB_UNIT_CURRENCIES: Record<string, { currency: string; divisor: number }> = {
+  GBp: { currency: "GBP", divisor: 100 },
+  GBX: { currency: "GBP", divisor: 100 },
+  ILA: { currency: "ILS", divisor: 100 },
+  ZAc: { currency: "ZAR", divisor: 100 },
+};
+
+const LIKELY_UNIT_MISMATCH_RATIOS: Record<string, number[]> = {
+  BHD: [1000],
+  GBP: [100],
+  ILS: [100],
+  JOD: [1000],
+  KWD: [1000],
+  OMR: [1000],
+  TND: [1000],
+  ZAR: [100],
+};
+
+export interface CurrencyUnitInfo {
+  currency: string;
+  divisor: number;
+}
+
+export function resolveCurrencyUnit(currency?: string | null): CurrencyUnitInfo {
+  const raw = (currency ?? "").trim();
+  if (!raw) {
+    return { currency: "", divisor: 1 };
+  }
+
+  const normalized = SUB_UNIT_CURRENCIES[raw];
+  if (normalized) {
+    return normalized;
+  }
+
+  return {
+    currency: raw.toUpperCase(),
+    divisor: 1,
+  };
+}
+
+export function normalizePriceValueByDivisor(value: number | undefined, divisor: number): number | undefined {
+  if (value == null || !Number.isFinite(value) || divisor === 1) return value;
+  return value / divisor;
+}
+
+function normalizedRatio(left: number, right: number): number {
+  const ratio = left / right;
+  return ratio >= 1 ? ratio : 1 / ratio;
+}
+
+function isRatioWithin(ratio: number, target: number, tolerance = 0.05): boolean {
+  return Math.abs(ratio - target) / target < tolerance;
+}
+
+function likelyUnitMismatchRatios(currency: string): number[] {
+  return LIKELY_UNIT_MISMATCH_RATIOS[currency] ?? [100];
+}
+
+export function hasLikelyQuoteUnitMismatch(
+  left: { currency?: string; price: number } | null | undefined,
+  right: { currency?: string; price: number } | null | undefined,
+): boolean {
+  if (!left || !right) return false;
+
+  const leftUnit = resolveCurrencyUnit(left.currency);
+  const rightUnit = resolveCurrencyUnit(right.currency);
+  if (!leftUnit.currency || !rightUnit.currency) return false;
+  if (leftUnit.currency !== rightUnit.currency) return false;
+  if (!Number.isFinite(left.price) || !Number.isFinite(right.price)) return false;
+  if (left.price <= 0 || right.price <= 0) return false;
+
+  if (leftUnit.divisor !== rightUnit.divisor) {
+    const leftCanonicalPrice = left.price / leftUnit.divisor;
+    const rightCanonicalPrice = right.price / rightUnit.divisor;
+    if (isRatioWithin(normalizedRatio(leftCanonicalPrice, rightCanonicalPrice), 1)) {
+      return true;
+    }
+  }
+
+  const ratio = normalizedRatio(left.price, right.price);
+  return likelyUnitMismatchRatios(leftUnit.currency).some((target) => isRatioWithin(ratio, target));
+}

package/src/utils/debug-log.ts

@@ -0,0 +1,133 @@
+export type LogLevel = "debug" | "info" | "warn" | "error";
+
+export interface LogEntry {
+  id: number;
+  timestamp: number;
+  level: LogLevel;
+  source: string;
+  message: string;
+  data?: unknown;
+}
+
+type LogListener = (entry: LogEntry) => void;
+
+class DebugLog {
+  private entries: LogEntry[] = [];
+  private listeners = new Set<LogListener>();
+  private nextId = 1;
+  private maxEntries = 5000;
+
+  /** Create a logger scoped to a source (plugin id, module name, etc.) */
+  createLogger(source: string) {
+    return {
+      debug: (message: string, data?: unknown) => this.add("debug", source, message, data),
+      info: (message: string, data?: unknown) => this.add("info", source, message, data),
+      warn: (message: string, data?: unknown) => this.add("warn", source, message, data),
+      error: (message: string, data?: unknown) => this.add("error", source, message, data),
+    };
+  }
+
+  private add(level: LogLevel, source: string, message: string, data?: unknown) {
+    const entry: LogEntry = {
+      id: this.nextId++,
+      timestamp: Date.now(),
+      level,
+      source,
+      message,
+      data,
+    };
+    this.entries.push(entry);
+    if (this.entries.length > this.maxEntries) {
+      this.entries = this.entries.slice(-Math.floor(this.maxEntries * 0.8));
+    }
+    for (const listener of this.listeners) {
+      try { listener(entry); } catch { /* ignore */ }
+    }
+  }
+
+  /** Subscribe to new log entries. Returns unsubscribe function. */
+  subscribe(listener: LogListener): () => void {
+    this.listeners.add(listener);
+    return () => { this.listeners.delete(listener); };
+  }
+
+  /** Get all entries, optionally filtered */
+  getEntries(filter?: { level?: LogLevel; source?: string }): LogEntry[] {
+    if (!filter) return this.entries;
+    return this.entries.filter((e) => {
+      if (filter.level && e.level !== filter.level) return false;
+      if (filter.source && e.source !== filter.source) return false;
+      return true;
+    });
+  }
+
+  /** Get unique source names seen so far */
+  getSources(): string[] {
+    const sources = new Set<string>();
+    for (const entry of this.entries) sources.add(entry.source);
+    return [...sources].sort();
+  }
+
+  /** Clear all entries */
+  clear() {
+    this.entries = [];
+    this.nextId = 1;
+  }
+
+  /** Export entries as a formatted text string */
+  exportAsText(filter?: { level?: LogLevel; source?: string }): string {
+    const entries = this.getEntries(filter);
+    const lines: string[] = [
+      `Gloomberb Debug Log — exported ${new Date().toISOString()}`,
+      `Total entries: ${entries.length}`,
+      "=".repeat(80),
+      "",
+    ];
+    for (const e of entries) {
+      const ts = new Date(e.timestamp).toISOString().slice(11, 23);
+      const lvl = e.level.toUpperCase().padEnd(5);
+      let dataStr = "";
+      if (e.data !== undefined) {
+        const serialized = JSON.stringify(e.data);
+        if (serialized.length <= 500) dataStr = `  ${serialized}`;
+      }
+      lines.push(`[${ts}] ${lvl} [${e.source}] ${e.message}${dataStr}`);
+    }
+    return lines.join("\n");
+  }
+
+  /** Intercept console methods and route them through the debug log */
+  interceptConsole() {
+    const orig = {
+      log: console.log.bind(console),
+      warn: console.warn.bind(console),
+      error: console.error.bind(console),
+      info: console.info.bind(console),
+    };
+
+    const format = (args: unknown[]): string =>
+      args.map((a) => (typeof a === "string" ? a : JSON.stringify(a))).join(" ");
+
+    console.log = (...args: unknown[]) => {
+      this.add("debug", "console", format(args));
+      orig.log(...args);
+    };
+    console.info = (...args: unknown[]) => {
+      this.add("info", "console", format(args));
+      orig.info(...args);
+    };
+    console.warn = (...args: unknown[]) => {
+      this.add("warn", "console", format(args));
+      orig.warn(...args);
+    };
+    console.error = (...args: unknown[]) => {
+      this.add("error", "console", format(args));
+      orig.error(...args);
+    };
+  }
+}
+
+/** Singleton debug log instance */
+export const debugLog = new DebugLog();
+
+export type PluginLogger = ReturnType<DebugLog["createLogger"]>;

package/src/utils/exchange-rate-map.ts

@@ -0,0 +1,8 @@
+export function selectEffectiveExchangeRates(
+  fetchedRates: Map<string, number>,
+  persistedRates: Map<string, number>,
+): Map<string, number> {
+  return fetchedRates.size > 1 || persistedRates.size === 0
+    ? fetchedRates
+    : persistedRates;
+}