gloomberb 0.4.1 → 0.5.1

package/src/notifications/app-notifier.ts

@@ -0,0 +1,241 @@
+import { spawn } from "child_process";
+import type { AppNotificationRequest, AppNotificationType } from "../types/plugin";
+import { debugLog } from "../utils/debug-log";
+
+const DEFAULT_NOTIFICATION_TITLE = "Gloomberb";
+const notificationLog = debugLog.createLogger("notifications");
+
+export interface DesktopNotificationCommand {
+  command: string;
+  args: string[];
+}
+
+export interface DesktopNotificationRunner {
+  run(
+    command: string,
+    args: string[],
+    handlers?: { onError?: (error: NodeJS.ErrnoException) => void },
+  ): void;
+}
+
+export interface DesktopNotificationSink {
+  notify(notification: AppNotificationRequest): void;
+}
+
+export interface AppNotifier {
+  notify(notification: AppNotificationRequest): void;
+}
+
+interface CreateAppNotifierOptions {
+  isAppActive: () => boolean;
+  renderToast: (notification: AppNotificationRequest) => void;
+  desktop?: DesktopNotificationSink | null;
+}
+
+function escapeAppleScriptString(value: string): string {
+  return `"${value
+    .replace(/\\/g, "\\\\")
+    .replace(/"/g, "\\\"")}"`;
+}
+
+function escapePowerShellString(value: string): string {
+  return `'${value.replace(/'/g, "''")}'`;
+}
+
+function mapLinuxUrgency(type: AppNotificationType | undefined): "low" | "normal" | "critical" {
+  if (type === "error") return "critical";
+  if (type === "success") return "low";
+  return "normal";
+}
+
+function mapWindowsIcon(type: AppNotificationType | undefined): string {
+  if (type === "error") return "Error";
+  if (type === "success") return "Information";
+  return "Information";
+}
+
+function buildLinuxBody(notification: AppNotificationRequest): string | undefined {
+  const parts = [notification.subtitle?.trim(), notification.body.trim()].filter(Boolean);
+  return parts.length > 0 ? parts.join("\n") : undefined;
+}
+
+function buildWindowsBody(notification: AppNotificationRequest): string {
+  const parts = [notification.subtitle?.trim(), notification.body.trim()].filter(Boolean);
+  return parts.length > 0 ? parts.join("\n") : notification.body.trim();
+}
+
+export function buildDesktopNotificationCommand(
+  notification: AppNotificationRequest,
+  platform: NodeJS.Platform = process.platform,
+): DesktopNotificationCommand | null {
+  const title = notification.title?.trim() || DEFAULT_NOTIFICATION_TITLE;
+  const body = notification.body.trim();
+  const subtitle = notification.subtitle?.trim();
+
+  if (!body) {
+    return null;
+  }
+
+  if (platform === "darwin") {
+    const script = [
+      `display notification ${escapeAppleScriptString(body)} with title ${escapeAppleScriptString(title)}`,
+      subtitle ? `subtitle ${escapeAppleScriptString(subtitle)}` : "",
+      notification.sound ? `sound name ${escapeAppleScriptString(notification.sound)}` : "",
+    ].filter(Boolean).join(" ");
+    return {
+      command: "osascript",
+      args: ["-e", script],
+    };
+  }
+
+  if (platform === "linux") {
+    const linuxBody = buildLinuxBody(notification);
+    return {
+      command: "notify-send",
+      args: [
+        "--app-name",
+        DEFAULT_NOTIFICATION_TITLE,
+        "--urgency",
+        mapLinuxUrgency(notification.type),
+        title,
+        ...(linuxBody ? [linuxBody] : []),
+      ],
+    };
+  }
+
+  if (platform === "win32") {
+    const balloonBody = buildWindowsBody(notification);
+    const script = [
+      "Add-Type -AssemblyName System.Windows.Forms;",
+      "Add-Type -AssemblyName System.Drawing;",
+      "$notify = New-Object System.Windows.Forms.NotifyIcon;",
+      `$notify.Icon = [System.Drawing.SystemIcons]::${mapWindowsIcon(notification.type)};`,
+      `$notify.BalloonTipTitle = ${escapePowerShellString(title)};`,
+      `$notify.BalloonTipText = ${escapePowerShellString(balloonBody)};`,
+      "$notify.Visible = $true;",
+      "$notify.ShowBalloonTip(5000);",
+      "Start-Sleep -Seconds 6;",
+      "$notify.Dispose();",
+    ].join(" ");
+    return {
+      command: "powershell.exe",
+      args: ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", script],
+    };
+  }
+
+  return null;
+}
+
+function defaultDesktopNotificationRunner(
+  command: string,
+  args: string[],
+  handlers?: { onError?: (error: NodeJS.ErrnoException) => void },
+): void {
+  const child = spawn(command, args, { detached: true, stdio: "ignore" });
+  child.once("error", (error) => {
+    handlers?.onError?.(error);
+  });
+  child.unref();
+}
+
+export function buildSoundCommand(
+  soundName: string,
+  platform: NodeJS.Platform = process.platform,
+): DesktopNotificationCommand | null {
+  if (platform === "darwin") {
+    return {
+      command: "afplay",
+      args: [`/System/Library/Sounds/${soundName}.aiff`],
+    };
+  }
+
+  if (platform === "linux") {
+    const soundFile = soundName === "Glass" ? "dialog-information"
+      : soundName === "Ping" ? "message-new-instant"
+      : soundName === "Hero" ? "dialog-warning"
+      : "bell";
+    return {
+      command: "paplay",
+      args: [`/usr/share/sounds/freedesktop/stereo/${soundFile}.oga`],
+    };
+  }
+
+  if (platform === "win32") {
+    return {
+      command: "powershell.exe",
+      args: ["-NoProfile", "-NonInteractive", "-Command", "[System.Media.SystemSounds]::Beep.Play()"],
+    };
+  }
+
+  return null;
+}
+
+export function createDesktopNotifier(
+  options: {
+    platform?: NodeJS.Platform;
+    runner?: DesktopNotificationRunner;
+  } = {},
+): DesktopNotificationSink {
+  const platform = options.platform ?? process.platform;
+  const runner = options.runner ?? { run: defaultDesktopNotificationRunner };
+  let disabledCommand: string | null = null;
+
+  return {
+    notify(notification) {
+      const desktopCommand = buildDesktopNotificationCommand(notification, platform);
+      if (desktopCommand && disabledCommand !== desktopCommand.command) {
+        runner.run(desktopCommand.command, desktopCommand.args, {
+          onError: (error) => {
+            if (error.code === "ENOENT") {
+              disabledCommand = desktopCommand.command;
+            }
+            notificationLog.warn("desktop notification failed", {
+              command: desktopCommand.command,
+              code: error.code,
+              message: error.message,
+            });
+          },
+        });
+      }
+
+      if (notification.sound) {
+        const soundCommand = buildSoundCommand(notification.sound, platform);
+        if (soundCommand) {
+          runner.run(soundCommand.command, soundCommand.args, {
+            onError: (error) => {
+              notificationLog.warn("sound playback failed", {
+                command: soundCommand.command,
+                code: error.code,
+                message: error.message,
+              });
+            },
+          });
+        }
+      }
+    },
+  };
+}
+
+export function createAppNotifier({
+  isAppActive,
+  renderToast,
+  desktop = createDesktopNotifier(),
+}: CreateAppNotifierOptions): AppNotifier {
+  return {
+    notify(notification) {
+      const toastEnabled = notification.toast !== false;
+      const desktopMode = notification.desktop ?? "never";
+
+      if (toastEnabled) {
+        renderToast(notification);
+      }
+
+      if (
+        desktopMode === "always" ||
+        (desktopMode === "when-inactive" && !isAppActive())
+      ) {
+        desktop?.notify(notification);
+      }
+    },
+  };
+}

package/src/pane-settings.test.ts

@@ -15,6 +15,8 @@ describe("pane settings helpers", () => {
     });
     expect(portfolioPane?.settings?.columnIds).toEqual(DEFAULT_PORTFOLIO_COLUMN_IDS);
     expect(detailPane?.settings).toEqual({
+      chartRangePreset: "5Y",
+      chartResolution: "auto",
       hideTabs: false,
       lockedTabId: "overview",
     });

package/src/plugins/builtin/ai/index.test.tsx

@@ -63,7 +63,7 @@ function createPluginContext() {
     emit: () => {},
     showWidget: () => {},
     hideWidget: () => {},
-    showToast: () => {},
+    notify: () => {},
   } satisfies GloomPluginContext;
 
   return { ctx, panes, templates, detailTabs };

package/src/plugins/builtin/ai/screener-pane.test.tsx

@@ -21,6 +21,8 @@ function makeRuntime(): PluginRuntimeAccess {
   const listeners = new Map<string, Set<() => void>>();
 
   return {
+    pinTicker() {},
+    navigateTicker() {},
     subscribeResumeState(pluginId, key, listener) {
       const storeKey = `${pluginId}:${key}`;
       if (!listeners.has(storeKey)) listeners.set(storeKey, new Set());

package/src/plugins/builtin/ai/screener-pane.tsx

@@ -142,6 +142,7 @@ function ScreenerPromptEditor({
         placeholderColor={colors.textDim}
         backgroundColor={colors.panel}
         flexGrow={1}
+        wrapText
       />
     </box>
   );

package/src/plugins/builtin/ai/ticker-context.ts

@@ -1,4 +1,5 @@
 import { convertCurrency, formatCompact, formatCompactCurrency, formatCurrency, formatPercent } from "../../../utils/format";
+import { formatMarketPriceWithCurrency } from "../../../utils/market-format";
 import type { TickerFinancials } from "../../../types/financials";
 import type { TickerRecord } from "../../../types/ticker";
 
@@ -28,9 +29,9 @@ export function buildTickerAiContext(
   if (profile?.description) lines.push(`Description: ${profile.description}`);
 
   if (quote) {
-    lines.push(`Current Price: ${formatCurrency(quote.price, quote.currency)} (${quote.change >= 0 ? "+" : ""}${quote.changePercent.toFixed(2)}%)`);
+    lines.push(`Current Price: ${formatMarketPriceWithCurrency(quote.price, quote.currency, { assetCategory: metadata.assetCategory })} (${quote.change >= 0 ? "+" : ""}${quote.changePercent.toFixed(2)}%)`);
     if (quote.marketCap) lines.push(`Market Cap: ${formatCompactCurrency(toBase(quote.marketCap, quoteCurrency), baseCurrency)}`);
-    if (quote.high52w && quote.low52w) lines.push(`52W Range: ${formatCurrency(quote.low52w, quote.currency)} - ${formatCurrency(quote.high52w, quote.currency)}`);
+    if (quote.high52w && quote.low52w) lines.push(`52W Range: ${formatMarketPriceWithCurrency(quote.low52w, quote.currency, { assetCategory: metadata.assetCategory })} - ${formatMarketPriceWithCurrency(quote.high52w, quote.currency, { assetCategory: metadata.assetCategory })}`);
   }
 
   if (fundamentals) {

package/src/plugins/builtin/alerts/alert-engine.test.ts

@@ -0,0 +1,90 @@
+import { describe, expect, test } from "bun:test";
+import { evaluateAlert, createAlert, formatAlertDescription, serializeAlerts, deserializeAlerts } from "./alert-engine";
+
+describe("evaluateAlert", () => {
+  test("above: triggers when price exceeds target", () => {
+    const alert = createAlert("AAPL", "above", 200);
+    expect(evaluateAlert(alert, 199)).toBe(false);
+    expect(evaluateAlert(alert, 200)).toBe(false);
+    expect(evaluateAlert(alert, 201)).toBe(true);
+  });
+
+  test("below: triggers when price drops below target", () => {
+    const alert = createAlert("AAPL", "below", 150);
+    expect(evaluateAlert(alert, 151)).toBe(false);
+    expect(evaluateAlert(alert, 150)).toBe(false);
+    expect(evaluateAlert(alert, 149)).toBe(true);
+  });
+
+  test("crosses: triggers when price crosses target in either direction", () => {
+    const alert = createAlert("AAPL", "crosses", 180);
+    expect(evaluateAlert(alert, 175)).toBe(false);
+    alert.lastCheckedPrice = 175;
+    expect(evaluateAlert(alert, 185)).toBe(true);
+  });
+
+  test("crosses: triggers downward crossing", () => {
+    const alert = createAlert("AAPL", "crosses", 180);
+    alert.lastCheckedPrice = 185;
+    expect(evaluateAlert(alert, 175)).toBe(true);
+  });
+
+  test("crosses: does not trigger without prior price", () => {
+    const alert = createAlert("AAPL", "crosses", 180);
+    expect(evaluateAlert(alert, 185)).toBe(false);
+  });
+
+  test("does not evaluate triggered alerts", () => {
+    const alert = createAlert("AAPL", "above", 200);
+    alert.status = "triggered";
+    expect(evaluateAlert(alert, 999)).toBe(false);
+  });
+});
+
+describe("createAlert", () => {
+  test("creates alert with active status", () => {
+    const alert = createAlert("TSLA", "below", 100);
+    expect(alert.symbol).toBe("TSLA");
+    expect(alert.condition).toBe("below");
+    expect(alert.targetPrice).toBe(100);
+    expect(alert.status).toBe("active");
+    expect(alert.id).toBeTruthy();
+  });
+
+  test("uppercases symbol", () => {
+    expect(createAlert("aapl", "above", 200).symbol).toBe("AAPL");
+  });
+});
+
+describe("formatAlertDescription", () => {
+  test("formats above", () => {
+    expect(formatAlertDescription(createAlert("AAPL", "above", 200))).toBe("AAPL > 200");
+  });
+  test("formats below", () => {
+    expect(formatAlertDescription(createAlert("AAPL", "below", 150))).toBe("AAPL < 150");
+  });
+  test("formats crosses", () => {
+    expect(formatAlertDescription(createAlert("AAPL", "crosses", 180))).toBe("AAPL ↕ 180");
+  });
+});
+
+describe("serializeAlerts / deserializeAlerts", () => {
+  test("roundtrips alerts", () => {
+    const alerts = [createAlert("AAPL", "above", 200), createAlert("TSLA", "below", 100)];
+    const json = serializeAlerts(alerts);
+    const restored = deserializeAlerts(json);
+    expect(restored).toHaveLength(2);
+    expect(restored[0]!.symbol).toBe("AAPL");
+    expect(restored[1]!.symbol).toBe("TSLA");
+  });
+
+  test("handles invalid JSON", () => {
+    expect(deserializeAlerts("not json")).toEqual([]);
+    expect(deserializeAlerts("null")).toEqual([]);
+    expect(deserializeAlerts("[]")).toEqual([]);
+  });
+
+  test("filters invalid entries", () => {
+    expect(deserializeAlerts('[{"bad": true}]')).toEqual([]);
+  });
+});

package/src/plugins/builtin/alerts/alert-engine.ts

@@ -0,0 +1,55 @@
+import type { AlertCondition, AlertRule } from "./types";
+
+export type { AlertRule };
+
+export function createAlert(symbol: string, condition: AlertCondition, targetPrice: number): AlertRule {
+  return {
+    id: `alert-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`,
+    symbol: symbol.toUpperCase(),
+    condition,
+    targetPrice,
+    createdAt: Date.now(),
+    status: "active",
+  };
+}
+
+export function evaluateAlert(alert: AlertRule, currentPrice: number): boolean {
+  if (alert.status !== "active") return false;
+
+  switch (alert.condition) {
+    case "above":
+      return currentPrice > alert.targetPrice;
+    case "below":
+      return currentPrice < alert.targetPrice;
+    case "crosses": {
+      if (alert.lastCheckedPrice == null) return false;
+      const wasBelowOrAt = alert.lastCheckedPrice <= alert.targetPrice;
+      const wasAboveOrAt = alert.lastCheckedPrice >= alert.targetPrice;
+      const isAbove = currentPrice > alert.targetPrice;
+      const isBelow = currentPrice < alert.targetPrice;
+      return (wasBelowOrAt && isAbove) || (wasAboveOrAt && isBelow);
+    }
+  }
+}
+
+export function formatAlertDescription(alert: AlertRule): string {
+  const prefix = alert.condition === "above" ? ">"
+    : alert.condition === "below" ? "<" : "↕";
+  return `${alert.symbol} ${prefix} ${alert.targetPrice}`;
+}
+
+export function serializeAlerts(alerts: AlertRule[]): string {
+  return JSON.stringify(alerts);
+}
+
+export function deserializeAlerts(json: string): AlertRule[] {
+  try {
+    const parsed = JSON.parse(json);
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter((a: any) =>
+      a?.id && a?.symbol && a?.condition && typeof a?.targetPrice === "number"
+    );
+  } catch {
+    return [];
+  }
+}