gloomberb 0.4.0 → 0.5.0

package/src/plugins/builtin/analytics/metrics.test.ts

@@ -0,0 +1,125 @@
+import { describe, expect, test } from "bun:test";
+import {
+  computeBeta,
+  computeDatedBeta,
+  computeDatedReturns,
+  computeSectorAllocation,
+  computeSharpeRatio,
+  computeWeightedPortfolioReturns,
+  type DatedReturn,
+} from "./metrics";
+
+function datedReturns(values: number[], startDay = 1): DatedReturn[] {
+  return values.map((value, index) => ({
+    dateKey: `2024-01-${String(startDay + index).padStart(2, "0")}`,
+    value,
+  }));
+}
+
+describe("computeSharpeRatio", () => {
+  test("computes positive Sharpe for good returns", () => {
+    const returns = Array.from({ length: 20 }, () => 0.005 + (Math.random() - 0.5) * 0.001);
+    const sharpe = computeSharpeRatio(returns);
+    expect(sharpe).not.toBeNull();
+    expect(sharpe!).toBeGreaterThan(0);
+  });
+
+  test("returns null for insufficient data", () => {
+    expect(computeSharpeRatio([0.01, 0.02])).toBeNull();
+  });
+
+  test("returns null for zero variance", () => {
+    expect(computeSharpeRatio(Array(20).fill(0.01))).toBeNull();
+  });
+});
+
+describe("computeBeta", () => {
+  test("beta of 1 when returns match market", () => {
+    const returns = Array.from({ length: 20 }, () => Math.random() * 0.02 - 0.01);
+    const beta = computeBeta(returns, returns);
+    expect(beta).toBeCloseTo(1.0, 1);
+  });
+
+  test("returns null for insufficient data", () => {
+    expect(computeBeta([0.01], [0.01])).toBeNull();
+  });
+
+  test("aligns dated returns before computing beta", () => {
+    const market = datedReturns([
+      -0.010, 0.015, 0.004, -0.006, 0.011,
+      0.008, -0.012, 0.009, 0.013, -0.007,
+      0.005, 0.010,
+    ], 2);
+    const asset = [
+      { dateKey: "2024-01-01", value: 0.25 },
+      ...market.map((point) => ({ dateKey: point.dateKey, value: point.value * 2 })),
+    ];
+
+    expect(computeDatedBeta(asset, market)).toBeCloseTo(2, 5);
+  });
+
+  test("weights portfolio returns by holding value", () => {
+    const market = datedReturns([
+      -0.010, 0.015, 0.004, -0.006, 0.011,
+      0.008, -0.012, 0.009, 0.013, -0.007,
+      0.005, 0.010,
+    ]);
+    const portfolio = computeWeightedPortfolioReturns([
+      {
+        weight: 80,
+        returns: market.map((point) => ({ dateKey: point.dateKey, value: point.value * 2 })),
+      },
+      {
+        weight: 20,
+        returns: market.map((point) => ({ dateKey: point.dateKey, value: 0 })),
+      },
+    ]);
+
+    expect(computeDatedBeta(portfolio, market)).toBeCloseTo(1.6, 5);
+  });
+
+  test("computes dated returns from closing prices", () => {
+    const returns = computeDatedReturns([
+      { date: new Date("2024-01-01T00:00:00Z"), close: 100 },
+      { date: new Date("2024-01-02T00:00:00Z"), close: 110 },
+      { date: new Date("2024-01-03T00:00:00Z"), close: 99 },
+    ]);
+
+    expect(returns).toEqual([
+      { dateKey: "2024-01-02", value: 0.1 },
+      { dateKey: "2024-01-03", value: -0.1 },
+    ]);
+  });
+});
+
+describe("computeSectorAllocation", () => {
+  test("computes weights from positions", () => {
+    const alloc = computeSectorAllocation([
+      { sector: "Technology", marketValue: 60000 },
+      { sector: "Healthcare", marketValue: 40000 },
+    ]);
+    expect(alloc).toHaveLength(2);
+    expect(alloc[0]!.sector).toBe("Technology");
+    expect(alloc[0]!.weight).toBeCloseTo(0.6, 2);
+  });
+
+  test("groups same sectors", () => {
+    const alloc = computeSectorAllocation([
+      { sector: "Tech", marketValue: 30000 },
+      { sector: "Tech", marketValue: 20000 },
+      { sector: "Health", marketValue: 50000 },
+    ]);
+    expect(alloc).toHaveLength(2);
+    expect(alloc[0]!.sector).toBe("Health");
+    expect(alloc[0]!.weight).toBeCloseTo(0.5, 2);
+  });
+
+  test("returns empty for zero total value", () => {
+    expect(computeSectorAllocation([])).toEqual([]);
+  });
+
+  test("uses Unknown for missing sector", () => {
+    const alloc = computeSectorAllocation([{ sector: "", marketValue: 100 }]);
+    expect(alloc[0]!.sector).toBe("Unknown");
+  });
+});

package/src/plugins/builtin/analytics/metrics.ts

@@ -0,0 +1,155 @@
+import type { PricePoint } from "../../../types/financials";
+import type { TickerRecord } from "../../../types/ticker";
+
+export interface DatedReturn {
+  dateKey: string;
+  value: number;
+}
+
+export interface WeightedReturnSeries {
+  weight: number;
+  returns: DatedReturn[];
+}
+
+function getPricePointTimestamp(point: PricePoint): number {
+  const value = point.date as Date | string | number | null | undefined;
+  if (value instanceof Date) return value.getTime();
+  if (value == null) return Number.NaN;
+  return new Date(value).getTime();
+}
+
+function toDateKey(timestamp: number): string {
+  const date = new Date(timestamp);
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${date.getFullYear()}-${month}-${day}`;
+}
+
+export function computeSharpeRatio(returns: number[], riskFreeRate = 0.05): number | null {
+  if (returns.length < 10) return null;
+  const n = returns.length;
+  const meanReturn = returns.reduce((s, r) => s + r, 0) / n;
+  const variance = returns.reduce((s, r) => s + (r - meanReturn) ** 2, 0) / (n - 1);
+  const stdDev = Math.sqrt(variance);
+  if (variance < Number.EPSILON) return null;
+  const annualizedReturn = meanReturn * 252;
+  const annualizedStdDev = stdDev * Math.sqrt(252);
+  return (annualizedReturn - riskFreeRate) / annualizedStdDev;
+}
+
+export function computeBeta(assetReturns: number[], marketReturns: number[]): number | null {
+  const n = Math.min(assetReturns.length, marketReturns.length);
+  if (n < 10) return null;
+  let sumMarket = 0, sumAsset = 0;
+  for (let i = 0; i < n; i++) {
+    sumMarket += marketReturns[i]!;
+    sumAsset += assetReturns[i]!;
+  }
+  const meanMarket = sumMarket / n;
+  const meanAsset = sumAsset / n;
+  let covariance = 0, marketVariance = 0;
+  for (let i = 0; i < n; i++) {
+    const dm = marketReturns[i]! - meanMarket;
+    const da = assetReturns[i]! - meanAsset;
+    covariance += dm * da;
+    marketVariance += dm * dm;
+  }
+  if (marketVariance === 0) return null;
+  return covariance / marketVariance;
+}
+
+export function computeDatedReturns(history: PricePoint[]): DatedReturn[] {
+  const points = history
+    .map((point) => ({ point, timestamp: getPricePointTimestamp(point) }))
+    .filter(({ point, timestamp }) => (
+      Number.isFinite(timestamp)
+      && Number.isFinite(point.close)
+      && point.close > 0
+    ))
+    .sort((left, right) => left.timestamp - right.timestamp);
+
+  const returns: DatedReturn[] = [];
+  for (let i = 1; i < points.length; i++) {
+    const previous = points[i - 1]!;
+    const current = points[i]!;
+    const value = (current.point.close - previous.point.close) / previous.point.close;
+    if (!Number.isFinite(value)) continue;
+    returns.push({
+      dateKey: toDateKey(current.timestamp),
+      value,
+    });
+  }
+  return returns;
+}
+
+export function computeWeightedPortfolioReturns(series: WeightedReturnSeries[]): DatedReturn[] {
+  const totals = new Map<string, { weightedReturn: number; weight: number }>();
+
+  for (const entry of series) {
+    if (!Number.isFinite(entry.weight) || entry.weight <= 0) continue;
+    for (const point of entry.returns) {
+      if (!Number.isFinite(point.value)) continue;
+      const current = totals.get(point.dateKey) ?? { weightedReturn: 0, weight: 0 };
+      current.weightedReturn += point.value * entry.weight;
+      current.weight += entry.weight;
+      totals.set(point.dateKey, current);
+    }
+  }
+
+  return [...totals.entries()]
+    .filter(([, total]) => total.weight > 0)
+    .map(([dateKey, total]) => ({
+      dateKey,
+      value: total.weightedReturn / total.weight,
+    }))
+    .sort((left, right) => left.dateKey.localeCompare(right.dateKey));
+}
+
+export function alignReturnSeries(
+  assetReturns: DatedReturn[],
+  marketReturns: DatedReturn[],
+): { asset: number[]; market: number[] } {
+  const marketByDate = new Map(marketReturns.map((point) => [point.dateKey, point.value]));
+  const asset: number[] = [];
+  const market: number[] = [];
+
+  for (const point of assetReturns) {
+    const marketValue = marketByDate.get(point.dateKey);
+    if (marketValue == null) continue;
+    asset.push(point.value);
+    market.push(marketValue);
+  }
+
+  return { asset, market };
+}
+
+export function computeDatedBeta(assetReturns: DatedReturn[], marketReturns: DatedReturn[]): number | null {
+  const aligned = alignReturnSeries(assetReturns, marketReturns);
+  return computeBeta(aligned.asset, aligned.market);
+}
+
+export interface SectorAllocation {
+  sector: string;
+  weight: number;
+  value: number;
+}
+
+export function computeSectorAllocation(
+  positions: Array<{ sector: string; marketValue: number }>,
+): SectorAllocation[] {
+  const sectorMap = new Map<string, number>();
+  let total = 0;
+  for (const pos of positions) {
+    const sector = pos.sector || "Unknown";
+    sectorMap.set(sector, (sectorMap.get(sector) ?? 0) + pos.marketValue);
+    total += pos.marketValue;
+  }
+  if (total === 0) return [];
+  return [...sectorMap.entries()]
+    .map(([sector, value]) => ({ sector, weight: value / total, value }))
+    .sort((a, b) => b.weight - a.weight || a.sector.localeCompare(b.sector));
+}
+
+export function hasPortfolioPosition(ticker: TickerRecord, portfolioId: string): boolean {
+  return ticker.metadata.positions.some((position) => position.portfolio === portfolioId);
+}

package/src/plugins/builtin/ask-ai.test.tsx

@@ -17,6 +17,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/chat-controller.test.ts

@@ -1,5 +1,5 @@
 import { afterEach, describe, expect, test } from "bun:test";
-import type { PluginPersistence } from "../../types/plugin";
+import type { AppNotificationRequest, PluginPersistence } from "../../types/plugin";
 import type { PersistedResourceValue } from "../../types/persistence";
 import { apiClient, type ChatMessage } from "../../utils/api-client";
 import { ChatController } from "./chat-controller";
@@ -84,6 +84,7 @@ class MemoryPersistence implements PluginPersistence {
 }
 
 afterEach(() => {
+  apiClient.dispose();
   apiClient.setSessionToken(null);
   apiClient.connectChannel = originalConnectChannel;
   apiClient.getSession = originalGetSession;
@@ -203,6 +204,35 @@ describe("ChatController", () => {
     controller.reset(true);
   });
 
+  test("dispose stops verification polling and closes the live connection", () => {
+    const controller = new ChatController();
+    let closed = false;
+
+    apiClient.setSessionToken("token-123");
+    (controller as any).user = { id: "u1", username: "vince", emailVerified: false };
+    (controller as any).syncVerificationPolling();
+    expect((controller as any).verificationPollTimer).not.toBeNull();
+
+    (controller as any).user = { id: "u1", username: "vince", emailVerified: true };
+    apiClient.connectChannel = () => ({
+      send: async () => {
+        throw new Error("not implemented");
+      },
+      close: () => {
+        closed = true;
+      },
+    });
+
+    controller.ensureConnection();
+    expect((controller as any).wsConnection).not.toBeNull();
+
+    controller.dispose();
+
+    expect(closed).toBe(true);
+    expect((controller as any).verificationPollTimer).toBeNull();
+    expect((controller as any).wsConnection).toBeNull();
+  });
+
   test("keeps the cached session when session refresh fails transiently", async () => {
     const persistence = new MemoryPersistence();
     const controller = new ChatController();
@@ -382,15 +412,15 @@ describe("ChatController", () => {
   test("marks a pending message as failed when sending errors", async () => {
     const persistence = new MemoryPersistence();
     const controller = new ChatController();
-    const toasts: string[] = [];
+    const notifications: AppNotificationRequest[] = [];
 
     persistence.setState("session", {
       sessionToken: "token-123",
       user: { id: "u1", username: "vince", emailVerified: true },
     }, { schemaVersion: 1 });
 
-    controller.setToastNotifier((message) => {
-      toasts.push(message);
+    controller.setNotifier((notification) => {
+      notifications.push(notification);
     });
     controller.attachPersistence(persistence);
 
@@ -411,13 +441,13 @@ describe("ChatController", () => {
       clientStatus: "failed",
       clientError: "server offline",
     });
-    expect(toasts).toEqual(["server offline"]);
+    expect(notifications).toEqual([{ body: "server offline", type: "error" }]);
   });
 
-  test("tracks unread mentions and shows a toast while chat is closed", () => {
+  test("tracks unread mentions and emits an app notification while chat is closed", () => {
     const persistence = new MemoryPersistence();
     const controller = new ChatController();
-    const toasts: string[] = [];
+    const notifications: AppNotificationRequest[] = [];
     const message: ChatMessage = {
       id: "m1",
       channelId: "everyone",
@@ -432,25 +462,64 @@ describe("ChatController", () => {
       user: { id: "u1", username: "vince", emailVerified: true },
     }, { schemaVersion: 1 });
 
-    controller.setToastNotifier((toast) => {
-      toasts.push(toast);
+    controller.setNotifier((notification) => {
+      notifications.push(notification);
     });
     controller.attachPersistence(persistence);
 
     (controller as any).mergeMessages([message]);
 
     expect(controller.getSnapshot().unreadMentionCount).toBe(1);
-    expect(toasts).toEqual(["@bob mentioned you: hey @Vince can you take a look?"]);
+    expect(notifications).toEqual([{
+      title: "Gloomberb chat",
+      body: "@bob mentioned you: hey @Vince can you take a look?",
+      type: "info",
+      desktop: "when-inactive",
+    }]);
     expect(persistence.getState<{ lastCursor: string | null; lastViewedMessageId: string | null }>("channel:everyone", { schemaVersion: 1 })).toMatchObject({
       lastCursor: "m1",
       lastViewedMessageId: null,
     });
   });
 
+  test("keeps emitting mention notifications while the app is backgrounded", () => {
+    const persistence = new MemoryPersistence();
+    const controller = new ChatController();
+    const notifications: AppNotificationRequest[] = [];
+    const message: ChatMessage = {
+      id: "m1",
+      channelId: "everyone",
+      content: "hey @vince",
+      replyToId: null,
+      createdAt: "2026-03-28T00:00:00.000Z",
+      user: { id: "u2", username: "bob", displayName: "Bob" },
+    };
+
+    persistence.setState("session", {
+      sessionToken: "token-123",
+      user: { id: "u1", username: "vince", emailVerified: true },
+    }, { schemaVersion: 1 });
+
+    controller.setNotifier((notification) => {
+      notifications.push(notification);
+    });
+    controller.attachPersistence(persistence);
+    controller.setAppActive(false);
+
+    (controller as any).mergeMessages([message]);
+
+    expect(notifications).toEqual([{
+      title: "Gloomberb chat",
+      body: "@bob mentioned you: hey @vince",
+      type: "info",
+      desktop: "when-inactive",
+    }]);
+  });
+
   test("marks mentions viewed when a chat view opens", () => {
     const persistence = new MemoryPersistence();
     const controller = new ChatController();
-    const toasts: string[] = [];
+    const notifications: AppNotificationRequest[] = [];
     const message: ChatMessage = {
       id: "m1",
       channelId: "everyone",
@@ -465,8 +534,8 @@ describe("ChatController", () => {
       user: { id: "u1", username: "vince", emailVerified: true },
     }, { schemaVersion: 1 });
 
-    controller.setToastNotifier((toast) => {
-      toasts.push(toast);
+    controller.setNotifier((notification) => {
+      notifications.push(notification);
     });
     controller.attachPersistence(persistence);
 
@@ -477,7 +546,12 @@ describe("ChatController", () => {
     const detachView = controller.attachView();
 
     expect(controller.getSnapshot().unreadMentionCount).toBe(0);
-    expect(toasts).toEqual(["@bob mentioned you: hey @vince"]);
+    expect(notifications).toEqual([{
+      title: "Gloomberb chat",
+      body: "@bob mentioned you: hey @vince",
+      type: "info",
+      desktop: "when-inactive",
+    }]);
     expect(persistence.getState<{ lastViewedMessageId: string | null }>("channel:everyone", { schemaVersion: 1 })).toMatchObject({
       lastViewedMessageId: "m1",
     });
@@ -487,7 +561,7 @@ describe("ChatController", () => {
   test("does not keep mentions unread while a chat view is already open", () => {
     const persistence = new MemoryPersistence();
     const controller = new ChatController();
-    const toasts: string[] = [];
+    const notifications: AppNotificationRequest[] = [];
     const message: ChatMessage = {
       id: "m1",
       channelId: "everyone",
@@ -502,8 +576,8 @@ describe("ChatController", () => {
       user: { id: "u1", username: "vince", emailVerified: true },
     }, { schemaVersion: 1 });
 
-    controller.setToastNotifier((toast) => {
-      toasts.push(toast);
+    controller.setNotifier((notification) => {
+      notifications.push(notification);
     });
     controller.attachPersistence(persistence);
     const detachView = controller.attachView();
@@ -511,7 +585,7 @@ describe("ChatController", () => {
     (controller as any).mergeMessages([message]);
 
     expect(controller.getSnapshot().unreadMentionCount).toBe(0);
-    expect(toasts).toEqual([]);
+    expect(notifications).toEqual([]);
     expect(persistence.getState<{ lastViewedMessageId: string | null }>("channel:everyone", { schemaVersion: 1 })).toMatchObject({
       lastViewedMessageId: "m1",
     });

package/src/plugins/builtin/chat-controller.ts

@@ -1,5 +1,6 @@
-import type { PluginPersistence, PluginResumeState } from "../../types/plugin";
+import type { AppNotificationRequest, PluginPersistence, PluginResumeState } from "../../types/plugin";
 import { apiClient, type ChatMessage, type PersistedAuthUser } from "../../utils/api-client";
+import { debugLog } from "../../utils/debug-log";
 import { toTimestampMillis } from "../../utils/timestamp";
 
 const SESSION_STATE_KEY = "session";
@@ -18,6 +19,7 @@ const VERIFICATION_POLL_MS = 5_000;
 const ISO_TIMESTAMP_CURSOR = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z$/;
 const USERNAME_MENTION = /(^|[^A-Za-z0-9_])@([A-Za-z][A-Za-z0-9_]{2,29})(?![A-Za-z0-9_])/g;
 const PENDING_RECONCILE_WINDOW_MS = 2 * 60_000;
+const chatLog = debugLog.createLogger("chat-controller");
 
 interface PersistedSessionState {
   sessionToken: string | null;
@@ -47,7 +49,6 @@ export interface ChatControllerSnapshot {
 }
 
 type ChatConnection = { send: (content: string, replyToId?: string) => Promise<ChatMessage>; close: () => void };
-type ChatToastOptions = { duration?: number; type?: "info" | "success" | "error" };
 
 function normalizeUsername(username: string | null | undefined): string | null {
   const trimmed = username?.trim();
@@ -80,7 +81,9 @@ function isLegacyTimestampCursor(cursor: string | null): boolean {
 }
 
 function compareMessages(a: ChatMessage, b: ChatMessage): number {
-  return a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id);
+  // Preserve server/insertion order inside same-timestamp batches so the bottom-most
+  // rendered message stays the one selected first from the composer.
+  return a.createdAt.localeCompare(b.createdAt);
 }
 
 export class ChatController {
@@ -103,7 +106,7 @@ export class ChatController {
   private verificationPollTimer: ReturnType<typeof setInterval> | null = null;
   private openViewCount = 0;
   private pendingMessageSeq = 0;
-  private toastFn: (message: string, options?: ChatToastOptions) => void = () => {};
+  private notifyFn: (notification: AppNotificationRequest) => void = () => {};
   private listeners = new Set<(snapshot: ChatControllerSnapshot) => void>();
 
   attachPersistence(persistence: PluginPersistence, resume?: PluginResumeState): void {
@@ -112,8 +115,8 @@ export class ChatController {
     this.hydrate();
   }
 
-  setToastNotifier(notify: (message: string, options?: ChatToastOptions) => void): void {
-    this.toastFn = notify;
+  setNotifier(notify: (notification: AppNotificationRequest) => void): void {
+    this.notifyFn = notify;
   }
 
   hydrate(): void {
@@ -259,6 +262,7 @@ export class ChatController {
   }
 
   setDraft(draft: string): void {
+    if (draft === this.draft) return;
     this.draft = draft;
     this.persistChannelState();
     this.emit();
@@ -326,6 +330,22 @@ export class ChatController {
     this.emit();
   }
 
+  dispose(): void {
+    chatLog.info("dispose controller", {
+      listeners: this.listeners.size,
+      hasConnection: !!this.wsConnection,
+    });
+    this.stopVerificationPolling();
+    this.wsConnection?.close();
+    this.wsConnection = null;
+    this.wsConnected = false;
+    this.messagesLoading = false;
+    this.refreshMessagesPromise = null;
+    this.openViewCount = 0;
+    this.notifyFn = () => {};
+    this.listeners.clear();
+  }
+
   send(content: string, replyToId?: string): void {
     if (!this.user?.emailVerified || !apiClient.getSessionToken()) return;
     if (!this.wsConnection && this.user?.emailVerified && apiClient.getSessionToken()) {
@@ -333,7 +353,7 @@ export class ChatController {
     }
     const connection = this.wsConnection;
     if (!connection) {
-      this.toastFn("Unable to send message right now.", { type: "error" });
+      this.notifyFn({ body: "Unable to send message right now.", type: "error" });
       return;
     }
 
@@ -355,7 +375,7 @@ export class ChatController {
           : entry
       ));
       this.emit();
-      this.toastFn(errorMessage, { type: "error" });
+      this.notifyFn({ body: errorMessage, type: "error" });
     });
   }
 
@@ -513,13 +533,22 @@ export class ChatController {
 
     const freshMentions = this.getMentionMessages(messages);
     if (freshMentions.length === 0) return;
-    if (!this.appActive) return;
 
     if (freshMentions.length === 1) {
-      this.toastFn(formatMentionToast(freshMentions[0]!), { type: "info" });
+      this.notifyFn({
+        title: "Gloomberb chat",
+        body: formatMentionToast(freshMentions[0]!),
+        type: "info",
+        desktop: "when-inactive",
+      });
       return;
     }
-    this.toastFn(`${freshMentions.length} new mentions in #everyone.`, { type: "info" });
+    this.notifyFn({
+      title: "Gloomberb chat",
+      body: `${freshMentions.length} new mentions in #everyone.`,
+      type: "info",
+      desktop: "when-inactive",
+    });
   }
 
   private getUnreadMentionCount(): number {