gloomberb 0.7.1 → 0.7.3

package/src/utils/api-client.ts

@@ -48,7 +48,7 @@ export interface ChatMessage {
   replyToId: string | null;
   createdAt: string;
   user: { id: string; username: string; displayName: string };
-  replyTo?: { content: string; user: { username: string } } | null;
+  replyTo?: { content: string; user: { id?: string; username: string } } | null;
   clientStatus?: "sending" | "failed";
   clientError?: string | null;
 }
@@ -59,6 +59,29 @@ export interface ChatChannel {
   created_at: string;
 }
 
+export interface ChatChannelState {
+  channelId: string;
+  notificationsEnabled: boolean;
+  lastReadMessageId: string | null;
+  unreadCount: number;
+}
+
+export interface ChatNotification {
+  id: string;
+  type: "reply" | "mention" | "channel";
+  channelId: string;
+  messageId: string;
+  createdAt: string;
+  message: ChatMessage;
+}
+
+export interface ChatStateResponse {
+  channels: ChatChannel[];
+  onlineCount: number;
+  channelStates: ChatChannelState[];
+  notifications: ChatNotification[];
+}
+
 export interface AuthUser {
   id: string;
   name: string;
@@ -352,6 +375,21 @@ function normalizeChatMessages(messages: ChatMessage[]): ChatMessage[] {
   return messages.map((message) => normalizeChatMessage(message));
 }
 
+function normalizeChatNotification(notification: ChatNotification): ChatNotification {
+  return {
+    ...notification,
+    createdAt: normalizeTimestamp(notification.createdAt),
+    message: normalizeChatMessage(notification.message),
+  };
+}
+
+function normalizeChatState(response: ChatStateResponse): ChatStateResponse {
+  return {
+    ...response,
+    notifications: response.notifications.map(normalizeChatNotification),
+  };
+}
+
 function normalizeTweet(tweet: CloudTweetPayload): CloudTweetPayload {
   return {
     ...tweet,
@@ -370,6 +408,8 @@ function normalizeTweetSearchResponse(response: CloudTweetSearchResponse): Cloud
 }
 
 type ChannelListener = (message: ChatMessage) => void;
+type ChatNotificationListener = (notification: ChatNotification) => void;
+type ChatPresenceListener = (onlineCount: number) => void;
 type QuoteListener = (target: QuoteStreamTarget, quote: CloudQuotePayload) => void;
 type SessionCookieName = (typeof SESSION_COOKIE_NAMES)[number];
 
@@ -408,6 +448,8 @@ class GloomApiClient {
   private reconnectDelayMs = 1000;
 
   private readonly channelListeners = new Map<string, Set<ChannelListener>>();
+  private readonly chatNotificationListeners = new Set<ChatNotificationListener>();
+  private readonly chatPresenceListeners = new Set<ChatPresenceListener>();
   private readonly quoteListeners = new Map<string, Set<QuoteListener>>();
   private readonly quoteTargets = new Map<string, QuoteStreamTarget>();
   private readonly pendingQuoteSubscribes = new Map<string, QuoteStreamTarget>();
@@ -650,7 +692,12 @@ class GloomApiClient {
     if (this.ws?.readyState !== WebSocket.OPEN) return;
     if (payload && typeof payload === "object" && "type" in (payload as Record<string, unknown>)) {
       const type = (payload as Record<string, unknown>).type;
-      if (type === "market.subscribe" || type === "market.unsubscribe" || type === "chat.subscribe") {
+      if (
+        type === "market.subscribe"
+        || type === "market.unsubscribe"
+        || type === "chat.subscribe"
+        || type === "chat.unsubscribe"
+      ) {
         cloudApiLog.info("send websocket message", payload);
       }
     }
@@ -773,6 +820,21 @@ class GloomApiClient {
       return;
     }
 
+    if (parsed?.type === "chat.notification" && parsed.data) {
+      const notification = normalizeChatNotification(parsed.data as ChatNotification);
+      for (const listener of this.chatNotificationListeners) {
+        listener(notification);
+      }
+      return;
+    }
+
+    if (parsed?.type === "chat.presence" && typeof parsed.onlineCount === "number") {
+      for (const listener of this.chatPresenceListeners) {
+        listener(parsed.onlineCount);
+      }
+      return;
+    }
+
     if (parsed?.type === "market.quote" && parsed.quote && typeof parsed.symbol === "string") {
       const key = marketKey(parsed.symbol, parsed.exchange);
       const target = this.quoteTargets.get(key) ?? {
@@ -853,6 +915,32 @@ class GloomApiClient {
     return this.request<ChatChannel[]>("/chat/channels");
   }
 
+  async getChatPresence(): Promise<{ onlineCount: number }> {
+    return this.request<{ onlineCount: number }>("/chat/presence");
+  }
+
+  async getChatState(): Promise<ChatStateResponse> {
+    const state = await this.request<ChatStateResponse>("/chat/state");
+    return normalizeChatState(state);
+  }
+
+  async updateChatChannelState(
+    channelId: string,
+    body: { notificationsEnabled?: boolean; readThroughMessageId?: string },
+  ): Promise<ChatChannelState> {
+    return this.request<ChatChannelState>(`/chat/channels/${channelId}/state`, {
+      method: "PATCH",
+      body: JSON.stringify(body),
+    });
+  }
+
+  async markChatNotificationsDelivered(notificationIds: string[]): Promise<{ delivered: number }> {
+    return this.request<{ delivered: number }>("/chat/notifications/delivered", {
+      method: "POST",
+      body: JSON.stringify({ notificationIds }),
+    });
+  }
+
   async getMessages(
     channelId: string,
     opts?: { after?: string; before?: string; limit?: number },
@@ -866,10 +954,10 @@ class GloomApiClient {
     return normalizeChatMessages(messages);
   }
 
-  async sendMessage(channelId: string, content: string, replyToId?: string): Promise<ChatMessage> {
+  async sendMessage(channelId: string, content: string, replyToId?: string, clientMessageId?: string): Promise<ChatMessage> {
     const message = await this.request<ChatMessage>(`/chat/channels/${channelId}/messages`, {
       method: "POST",
-      body: JSON.stringify({ content, replyToId }),
+      body: JSON.stringify({ content, replyToId, clientMessageId }),
     });
     return normalizeChatMessage(message);
   }
@@ -878,7 +966,7 @@ class GloomApiClient {
     channelId: string,
     onMessage: (msg: ChatMessage) => void,
     onError?: (err: string) => void,
-  ): { send: (content: string, replyToId?: string) => Promise<ChatMessage>; close: () => void } {
+  ): { send: (content: string, replyToId?: string, clientMessageId?: string) => Promise<ChatMessage>; close: () => void } {
     if (!channelId) {
       return {
         send: async () => {
@@ -898,9 +986,9 @@ class GloomApiClient {
     }
 
     return {
-      send: async (content: string, replyToId?: string) => {
+      send: async (content: string, replyToId?: string, clientMessageId?: string) => {
         try {
-          const message = await this.sendMessage(channelId, content, replyToId);
+          const message = await this.sendMessage(channelId, content, replyToId, clientMessageId);
           onMessage(message);
           return message;
         } catch (error) {
@@ -914,6 +1002,7 @@ class GloomApiClient {
         current.delete(onMessage);
         if (current.size === 0) {
           this.channelListeners.delete(channelId);
+          this.sendSocketMessage({ type: "chat.unsubscribe", channelId });
         }
         if (!this.shouldKeepSocketOpen()) {
           this.teardownSocket();
@@ -922,6 +1011,20 @@ class GloomApiClient {
     };
   }
 
+  subscribeChatNotifications(listener: ChatNotificationListener): () => void {
+    this.chatNotificationListeners.add(listener);
+    return () => {
+      this.chatNotificationListeners.delete(listener);
+    };
+  }
+
+  subscribeChatPresence(listener: ChatPresenceListener): () => void {
+    this.chatPresenceListeners.add(listener);
+    return () => {
+      this.chatPresenceListeners.delete(listener);
+    };
+  }
+
   subscribeQuotes(
     targets: QuoteStreamTarget[],
     onQuote: (target: QuoteStreamTarget, quote: CloudQuotePayload) => void,
@@ -997,6 +1100,8 @@ class GloomApiClient {
       channelTargets: this.channelListeners.size,
     });
     this.channelListeners.clear();
+    this.chatNotificationListeners.clear();
+    this.chatPresenceListeners.clear();
     this.quoteListeners.clear();
     this.quoteTargets.clear();
     this.pendingQuoteSubscribes.clear();

package/src/utils/fuzzy-search.ts

@@ -5,7 +5,18 @@ export function fuzzyMatch(query: string, target: string): { match: boolean; sco
   const t = target.toLowerCase();
 
   if (q.length === 0) return { match: true, score: 0 };
-  if (t.startsWith(q)) return { match: true, score: 1000 - q.length }; // exact prefix match
+  if (t === q) return { match: true, score: 2500 - q.length };
+
+  const tokens = t.split(/\s+/).filter(Boolean);
+  const exactTokenIndex = tokens.findIndex((token) => token === q);
+  if (exactTokenIndex >= 0) return { match: true, score: 2200 - q.length - exactTokenIndex };
+
+  const prefixTokenIndex = tokens.findIndex((token) => token.startsWith(q));
+  if (prefixTokenIndex >= 0) {
+    const token = tokens[prefixTokenIndex]!;
+    return { match: true, score: 1000 - q.length - prefixTokenIndex - (token.length - q.length) };
+  }
+
   if (t.includes(q)) return { match: true, score: 500 - q.length }; // substring match
 
   let qi = 0;

package/src/utils/keyboard.ts

@@ -0,0 +1,31 @@
+export interface KeyboardModifierEventLike {
+  ctrl?: boolean;
+  meta?: boolean;
+  super?: boolean;
+  alt?: boolean;
+  option?: boolean;
+  shift?: boolean;
+  name?: string;
+}
+
+export function hasKeyboardModifier(event: KeyboardModifierEventLike): boolean {
+  return !!(
+    event.ctrl
+    || event.meta
+    || event.super
+    || event.alt
+    || event.option
+    || event.shift
+  );
+}
+
+export function isPlainKeyboardEvent(event: KeyboardModifierEventLike): boolean {
+  return !hasKeyboardModifier(event);
+}
+
+export function isPlainKey(
+  event: KeyboardModifierEventLike,
+  ...names: string[]
+): boolean {
+  return isPlainKeyboardEvent(event) && names.includes(event.name ?? "");
+}

package/src/utils/ticker-search.test.ts

@@ -82,7 +82,7 @@ describe("ticker-search utilities", () => {
       ]),
     });
 
-    expect(results.map((item) => item.id)).toEqual(["goto:AAPL", "search:APP"]);
+    expect(results.map((item) => item.id)).toEqual(["goto:AAPL", "search:APP:NASDAQ:TEST"]);
     expect(findExactTickerSearchMatch(results, "AAPL")?.id).toBe("goto:AAPL");
   });
 
@@ -97,7 +97,7 @@ describe("ticker-search utilities", () => {
       ]),
     });
 
-    expect(results.map((item) => item.id)).toEqual(["goto:AAPL", "search:APLE"]);
+    expect(results.map((item) => item.id)).toEqual(["goto:AAPL", "search:APLE:NASDAQ:TEST"]);
     expect(results[0]).toMatchObject({
       id: "goto:AAPL",
       detail: "Apple Inc",

package/src/utils/ticker-search.ts

@@ -140,7 +140,7 @@ export function createProviderTickerSearchCandidates(
     const symbol = getSearchResultSymbol(result);
     const saved = localTickers.has(symbol);
     return [{
-      id: `search:${result.symbol}`,
+      id: buildProviderCandidateId(result, symbol),
       label: symbol,
       symbol,
       detail: [result.name, result.brokerLabel, result.type].filter(Boolean).join(" | "),
@@ -357,6 +357,7 @@ export function rankTickerSearchItems<T extends Pick<TickerSearchRankableItem, "
         item,
         index,
         normalizedSymbol: normalizeSearchText(item.symbol || item.label),
+        symbolMatchRank: scoreSymbolMatchRank(intent, item),
         textScore,
         score: textScore + priorityScore + (textScore > 0 && saved ? 900 : 0),
       };
@@ -375,6 +376,7 @@ export function rankTickerSearchItems<T extends Pick<TickerSearchRankableItem, "
       return !matchedLocalSymbols.has(normalizedSymbol);
     })
     .sort((a, b) => {
+      if (b.symbolMatchRank !== a.symbolMatchRank) return b.symbolMatchRank - a.symbolMatchRank;
       if (b.score !== a.score) return b.score - a.score;
       const aSaved = isSavedSearchItem(a.item);
       const bSaved = isSavedSearchItem(b.item);
@@ -463,6 +465,16 @@ function buildProviderSearchResultKey(result: InstrumentSearchResult): string {
   ].join("|");
 }
 
+function buildProviderCandidateId(result: InstrumentSearchResult, symbol: string): string {
+  return [
+    "search",
+    normalizeTickerSymbol(symbol),
+    normalizeSearchText(result.exchange || result.primaryExchange || result.type || ""),
+    normalizeSearchText(result.currency || ""),
+    normalizeSearchText(result.providerId || ""),
+  ].filter(Boolean).join(":");
+}
+
 function getProviderHintRichness(result: InstrumentSearchResult): number {
   let score = 0;
   if (result.name) score += Math.min(120, result.name.length);
@@ -728,6 +740,41 @@ function scoreSearchAlias(intent: SearchQueryIntent, alias: string): number {
   return score;
 }
 
+function scoreSymbolMatchRank(
+  intent: SearchQueryIntent,
+  item: Pick<TickerSearchRankableItem, "label"> & Partial<TickerSearchRankableItem>,
+): number {
+  if (!intent.normalizedQuery && !intent.compactQuery) return 0;
+  const displaySymbol = normalizeSearchText(item.symbol || item.label);
+  const compactDisplaySymbol = compactSearchText(item.symbol || item.label);
+
+  if (
+    displaySymbol === intent.normalizedQuery
+    || (intent.compactQuery && compactDisplaySymbol === intent.compactQuery)
+  ) {
+    return 3;
+  }
+
+  const aliases = getItemSearchAliases(item);
+  if (aliases.some((alias) => {
+    const normalizedAlias = normalizeSearchText(alias);
+    const compactAlias = compactSearchText(alias);
+    return normalizedAlias === intent.normalizedQuery
+      || (intent.compactQuery && compactAlias === intent.compactQuery);
+  })) {
+    return 2;
+  }
+
+  if (
+    displaySymbol.startsWith(intent.normalizedQuery)
+    || (intent.compactQuery && compactDisplaySymbol.startsWith(intent.compactQuery))
+  ) {
+    return 1;
+  }
+
+  return 0;
+}
+
 function scoreAssetPreference(intent: SearchQueryIntent, instrumentClass?: TickerSearchInstrumentClass): number {
   const itemClass = instrumentClass || "other";
   if (!intent.assetPreference) {

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = "0.7.1";
+export const VERSION = "0.7.3";