gloomberb 0.9.9 → 0.10.0

package/src/plugins/builtin/chart-composer/settings.ts

@@ -0,0 +1,397 @@
+import type { ChartResolution, TimeRange } from "../../../components/chart/core/types";
+import type {
+  PaneSettingField,
+  PaneSettingOption,
+  PaneSettingsContext,
+  PaneSettingsDef,
+} from "../../../types/plugin";
+import type {
+  ChartPanelSpec,
+  ChartSeriesSpec,
+  ChartSpec,
+  ChartStudySpec,
+  SeriesStyle,
+} from "../../../time-series/types";
+import { isOhlcSeriesStyle } from "../../../time-series/spec";
+import {
+  applySeriesStyle,
+  buildCustomChartPreset,
+  buildEmptyChartPreset,
+  buildPriceChartPreset,
+  chartSeriesLabel,
+  formatSeriesExpression,
+  getCompatibleSeriesStyles,
+  getSelectedBuiltinStudies,
+  getSelectedPairStudies,
+  setBuiltinStudies,
+  setPairStudies,
+  type BuiltinStudySelection,
+  type PairStudySelection,
+} from "./presets";
+import {
+  CHART_SPEC_SETTING_KEY,
+  parseChartSpecOr,
+} from "./chart-spec";
+
+export const CHART_RANGES: TimeRange[] = ["1D", "1W", "1M", "3M", "6M", "1Y", "5Y", "ALL"];
+export const CHART_RESOLUTIONS: ChartResolution[] = [
+  "auto",
+  "1m",
+  "5m",
+  "15m",
+  "30m",
+  "45m",
+  "1h",
+  "1d",
+  "1wk",
+  "1mo",
+];
+
+export const CHART_STUDY_OPTIONS: Array<PaneSettingOption & { value: BuiltinStudySelection }> = [
+  { value: "volume", label: "Volume", description: "Volume columns in a lower panel." },
+  { value: "sma20", label: "SMA 20", description: "20-bar simple moving average on the primary price series." },
+  { value: "sma50", label: "SMA 50", description: "50-bar simple moving average on the primary price series." },
+  { value: "sma200", label: "SMA 200", description: "200-bar simple moving average on the primary price series." },
+  { value: "ema20", label: "EMA 20", description: "20-bar exponential moving average on the primary price series." },
+  { value: "bollinger20", label: "Bollinger 20", description: "20-bar Bollinger Bands at two standard deviations." },
+  { value: "rsi14", label: "RSI 14", description: "14-bar Relative Strength Index in a lower panel." },
+  { value: "macd", label: "MACD", description: "12/26/9 MACD in a lower panel." },
+];
+
+export const CHART_FORMULA_OPTIONS: Array<PaneSettingOption & { value: PairStudySelection }> = [
+  { value: "ratio", label: "Ratio", description: "First series divided by the second series." },
+  { value: "spread", label: "Spread", description: "First series minus the second series." },
+  { value: "correlation", label: "Correlation 20", description: "20-observation rolling return correlation." },
+];
+
+export const CHART_SETTING_KEYS = {
+  series: "chartSeries",
+  indicators: "chartIndicators",
+  formulas: "chartFormulas",
+  dateWindow: "chartDateWindow",
+  range: "chartRange",
+  resolution: "chartResolution",
+  mode: "chartMode",
+} as const;
+
+function fallbackSpec(symbol: string | null | undefined): ChartSpec {
+  return symbol ? buildPriceChartPreset(symbol) : buildEmptyChartPreset();
+}
+
+function sourceKey(series: ChartSeriesSpec): string {
+  return formatSeriesExpression(series).toLowerCase();
+}
+
+/**
+ * The compact style picker is intentionally scoped to a chart with exactly one
+ * authored series. Multi-series styling belongs in the Series editor where the
+ * target is explicit, even when all but one series are currently hidden.
+ */
+export function getChartInlineStyleTarget(spec: ChartSpec): ChartSeriesSpec | null {
+  return spec.series.length === 1 ? spec.series[0] ?? null : null;
+}
+
+export function getChartInlineStyles(spec: ChartSpec): SeriesStyle[] {
+  const target = getChartInlineStyleTarget(spec);
+  if (!target) return [];
+  const fieldId = target.source.kind === "security" ? target.source.fieldId : "";
+  const anotherOhlcSeriesSharesPanel = spec.series.some((series) => (
+    series.id !== target.id
+    && series.panelId === target.panelId
+    && isOhlcSeriesStyle(series.style)
+  ));
+  return getCompatibleSeriesStyles(fieldId).filter((style) => (
+    !anotherOhlcSeriesSharesPanel || !isOhlcSeriesStyle(style)
+  ));
+}
+
+function managedStudy(study: ChartStudySpec): boolean {
+  return study.id.startsWith("builtin:") || study.id.startsWith("pair:");
+}
+
+function reconcileBasePanels(
+  existing: readonly ChartPanelSpec[],
+  authored: readonly ChartPanelSpec[],
+  series: readonly ChartSeriesSpec[],
+  studies: readonly ChartStudySpec[],
+): ChartPanelSpec[] {
+  const requiredIds = new Set([
+    "main",
+    ...series.map((entry) => entry.panelId),
+    ...studies.map((entry) => entry.panelId),
+  ]);
+  const existingById = new Map(existing.map((panel) => [panel.id, panel] as const));
+  const authoredById = new Map(authored.map((panel) => [panel.id, panel] as const));
+  return [...requiredIds].map((id) => (
+    existingById.get(id)
+    ?? authoredById.get(id)
+    ?? { id }
+  ));
+}
+
+export function replaceChartSeriesFromExpression(
+  spec: ChartSpec,
+  expression: string,
+): ChartSpec {
+  const authored = buildCustomChartPreset(expression);
+  const existingBySource = new Map<string, ChartSeriesSpec[]>();
+  for (const series of spec.series) {
+    const key = sourceKey(series);
+    existingBySource.set(key, [...(existingBySource.get(key) ?? []), series]);
+  }
+
+  const series = authored.series.map((entry) => {
+    const matches = existingBySource.get(sourceKey(entry));
+    return matches?.shift() ?? entry;
+  });
+  const seriesIds = new Set(series.map((entry) => entry.id));
+  const customStudies = spec.studies.filter((study) => (
+    !managedStudy(study)
+    && study.inputSeriesIds.every((seriesId) => seriesIds.has(seriesId))
+  ));
+  const builtinStudies = getSelectedBuiltinStudies(spec);
+  const pairStudies = getSelectedPairStudies(spec);
+  const panels = reconcileBasePanels(spec.panels, authored.panels, series, customStudies);
+  const base: ChartSpec = {
+    ...spec,
+    series,
+    studies: customStudies,
+    panels,
+  };
+  return setPairStudies(setBuiltinStudies(base, builtinStudies), pairStudies);
+}
+
+function formatDateWindow(spec: ChartSpec): string {
+  const window = spec.viewport.dateWindow;
+  return window ? `${window.start} to ${window.end}` : "";
+}
+
+function parseDate(value: string): string {
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(value)) {
+    throw new Error("Use YYYY-MM-DD dates.");
+  }
+  const date = new Date(`${value}T00:00:00.000Z`);
+  if (!Number.isFinite(date.getTime()) || date.toISOString().slice(0, 10) !== value) {
+    throw new Error(`"${value}" is not a valid date.`);
+  }
+  return value;
+}
+
+function parseDateWindow(value: string): { start: string; end: string } | undefined {
+  const trimmed = value.trim();
+  if (!trimmed) return undefined;
+  const match = trimmed.match(
+    /^(\d{4}-\d{2}-\d{2})\s*(?:to|through|\.\.|,|–|—)\s*(\d{4}-\d{2}-\d{2})$/i,
+  );
+  if (!match) {
+    throw new Error("Use YYYY-MM-DD to YYYY-MM-DD, or leave blank for the preset range.");
+  }
+  const start = parseDate(match[1]!);
+  const end = parseDate(match[2]!);
+  if (start > end) throw new Error("The start date must be before the end date.");
+  return { start, end };
+}
+
+function requireString(value: unknown, label: string): string {
+  if (typeof value !== "string") throw new Error(`${label} must be text.`);
+  return value;
+}
+
+function requireSelection<T extends string>(
+  value: unknown,
+  allowed: readonly T[],
+  label: string,
+): T[] {
+  if (!Array.isArray(value) || value.some((entry) => (
+    typeof entry !== "string" || !allowed.includes(entry as T)
+  ))) {
+    throw new Error(`Choose valid ${label.toLowerCase()} options.`);
+  }
+  return value as T[];
+}
+
+function cleanDerivedSettings(
+  settings: Record<string, unknown>,
+  spec: ChartSpec,
+): Record<string, unknown> {
+  const next: Record<string, unknown> = {
+    ...settings,
+    [CHART_SPEC_SETTING_KEY]: spec,
+  };
+  for (const key of Object.values(CHART_SETTING_KEYS)) delete next[key];
+  delete next.chartExpression;
+  return next;
+}
+
+export function applyChartComposerPaneSetting(
+  settings: Record<string, unknown>,
+  field: PaneSettingField,
+  value: unknown,
+  context?: Pick<PaneSettingsContext, "activeTicker">,
+): Record<string, unknown> {
+  const spec = parseChartSpecOr(
+    settings[CHART_SPEC_SETTING_KEY],
+    fallbackSpec(context?.activeTicker),
+  );
+  let nextSpec = spec;
+
+  switch (field.key) {
+    case CHART_SETTING_KEYS.series:
+      nextSpec = replaceChartSeriesFromExpression(spec, requireString(value, "Series"));
+      break;
+    case CHART_SETTING_KEYS.indicators:
+      nextSpec = setBuiltinStudies(
+        spec,
+        requireSelection(
+          value,
+          CHART_STUDY_OPTIONS.map((option) => option.value),
+          "indicator",
+        ),
+      );
+      break;
+    case CHART_SETTING_KEYS.formulas:
+      nextSpec = setPairStudies(
+        spec,
+        requireSelection(
+          value,
+          CHART_FORMULA_OPTIONS.map((option) => option.value),
+          "formula",
+        ),
+      );
+      break;
+    case CHART_SETTING_KEYS.dateWindow: {
+      const dateWindow = parseDateWindow(requireString(value, "Date window"));
+      nextSpec = {
+        ...spec,
+        viewport: {
+          ...spec.viewport,
+          dateWindow,
+          maxPoints: undefined,
+        },
+      };
+      break;
+    }
+    case CHART_SETTING_KEYS.range: {
+      const range = requireString(value, "Range") as TimeRange;
+      if (!CHART_RANGES.includes(range)) throw new Error("Choose a valid chart range.");
+      nextSpec = {
+        ...spec,
+        viewport: {
+          ...spec.viewport,
+          range,
+          dateWindow: undefined,
+          maxPoints: undefined,
+        },
+      };
+      break;
+    }
+    case CHART_SETTING_KEYS.resolution: {
+      const resolution = requireString(value, "Resolution") as ChartResolution;
+      if (!CHART_RESOLUTIONS.includes(resolution)) throw new Error("Choose a valid chart resolution.");
+      nextSpec = { ...spec, viewport: { ...spec.viewport, resolution } };
+      break;
+    }
+    case CHART_SETTING_KEYS.mode: {
+      const target = getChartInlineStyleTarget(spec);
+      const mode = requireString(value, "Mode") as SeriesStyle;
+      if (!target) {
+        throw new Error(spec.series.length === 0
+          ? "Add a series before choosing a chart style."
+          : "Use the Series editor to style a multi-series chart.");
+      }
+      if (!getChartInlineStyles(spec).includes(mode)) {
+        throw new Error(`That chart style is not compatible with ${chartSeriesLabel(target)}.`);
+      }
+      nextSpec = {
+        ...spec,
+        series: spec.series.map((series) => (
+          series.id === target.id ? applySeriesStyle(series, mode) : series
+        )),
+      };
+      break;
+    }
+    default:
+      return { ...settings, [field.key]: value };
+  }
+
+  return cleanDerivedSettings(settings, nextSpec);
+}
+
+export function buildChartComposerPaneSettingsDef(
+  settings: Record<string, unknown>,
+  activeTicker?: string | null,
+): PaneSettingsDef {
+  const spec = parseChartSpecOr(settings[CHART_SPEC_SETTING_KEY], fallbackSpec(activeTicker));
+  const inlineStyleTarget = getChartInlineStyleTarget(spec);
+  const modes = getChartInlineStyles(spec);
+
+  return {
+    title: "Chart Settings",
+    values: {
+      [CHART_SETTING_KEYS.series]: spec.series.map(formatSeriesExpression).join(", "),
+      [CHART_SETTING_KEYS.indicators]: getSelectedBuiltinStudies(spec),
+      [CHART_SETTING_KEYS.formulas]: getSelectedPairStudies(spec),
+      [CHART_SETTING_KEYS.dateWindow]: formatDateWindow(spec),
+      [CHART_SETTING_KEYS.range]: spec.viewport.range,
+      [CHART_SETTING_KEYS.resolution]: spec.viewport.resolution,
+      [CHART_SETTING_KEYS.mode]: inlineStyleTarget?.style ?? "",
+    },
+    fields: [
+      {
+        key: CHART_SETTING_KEYS.series,
+        label: "Series",
+        description: "Edit the chart sources. Press S in the pane for guided search and field suggestions.",
+        type: "text",
+        placeholder: "AAPL:price, MSFT:revenue, FRED:CPIAUCSL",
+      },
+      {
+        key: CHART_SETTING_KEYS.indicators,
+        label: "Indicators",
+        description: "Choose price studies and lower-panel indicators.",
+        type: "multi-select",
+        options: CHART_STUDY_OPTIONS,
+      },
+      {
+        key: CHART_SETTING_KEYS.formulas,
+        label: "Formulas",
+        description: "Compare two chart series with a derived formula.",
+        type: "multi-select",
+        options: CHART_FORMULA_OPTIONS,
+      },
+      {
+        key: CHART_SETTING_KEYS.dateWindow,
+        label: "Date Window",
+        description: "Enter YYYY-MM-DD to YYYY-MM-DD. Leave blank to use the preset range.",
+        type: "text",
+        placeholder: "2025-01-01 to 2026-01-01",
+      },
+      {
+        key: CHART_SETTING_KEYS.range,
+        label: "Range",
+        description: "Set the preset time range and clear any custom date window.",
+        type: "select",
+        options: CHART_RANGES.map((range) => ({ value: range, label: range })),
+      },
+      {
+        key: CHART_SETTING_KEYS.resolution,
+        label: "Resolution",
+        description: "Choose the observation interval, or let the chart select it automatically.",
+        type: "select",
+        options: CHART_RESOLUTIONS.map((resolution) => ({
+          value: resolution,
+          label: resolution.toUpperCase(),
+        })),
+      },
+      ...(inlineStyleTarget
+        ? [{
+          key: CHART_SETTING_KEYS.mode,
+          label: `Style (${chartSeriesLabel(inlineStyleTarget)})`,
+          description: `Choose how ${chartSeriesLabel(inlineStyleTarget)} is drawn.`,
+          type: "select" as const,
+          options: modes.map((mode) => ({ value: mode, label: mode.toUpperCase() })),
+        }]
+        : []),
+    ],
+    applyValue: applyChartComposerPaneSetting,
+  };
+}

package/src/plugins/builtin/chart-composer/shortcuts.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, test } from "bun:test";
+import type { KeyEventLike } from "../../../react/input";
+import { resolveChartComposerShortcut } from "./shortcuts";
+
+function keyEvent(
+  name: string,
+  overrides: Partial<KeyEventLike> = {},
+): KeyEventLike {
+  return {
+    key: name,
+    name,
+    sequence: name,
+    ctrl: false,
+    shift: false,
+    alt: false,
+    meta: false,
+    preventDefault() {},
+    stopPropagation() {},
+    ...overrides,
+  };
+}
+
+describe("resolveChartComposerShortcut", () => {
+  test("leaves shell and editable shortcuts untouched", () => {
+    expect(resolveChartComposerShortcut(keyEvent("w", { ctrl: true }), 8)).toBeNull();
+    expect(resolveChartComposerShortcut(keyEvent("w", { meta: true }), 8)).toBeNull();
+    expect(resolveChartComposerShortcut(keyEvent("m", { ctrl: true, shift: true }), 8)).toBeNull();
+    expect(resolveChartComposerShortcut(keyEvent("r", { ctrl: true, shift: true }), 8)).toBeNull();
+    expect(resolveChartComposerShortcut(keyEvent("w", { targetEditable: true }), 8)).toBeNull();
+    expect(resolveChartComposerShortcut(keyEvent("w", { defaultPrevented: true }), 8)).toBeNull();
+    expect(resolveChartComposerShortcut(keyEvent("w", { propagationStopped: true }), 8)).toBeNull();
+  });
+
+  test("matches only exact chart shortcuts", () => {
+    expect(resolveChartComposerShortcut(keyEvent("s"), 8)).toBe("series");
+    expect(resolveChartComposerShortcut(keyEvent("w"), 8)).toBe("dates");
+    expect(resolveChartComposerShortcut(keyEvent("m"), 8)).toBe("mode");
+    expect(resolveChartComposerShortcut(keyEvent("r"), 8)).toBe("resolution");
+    expect(resolveChartComposerShortcut(keyEvent("r", { shift: true }), 8)).toBe("reload");
+    expect(resolveChartComposerShortcut(keyEvent("3"), 8)).toEqual({ type: "range", index: 2 });
+    expect(resolveChartComposerShortcut(keyEvent("9"), 8)).toBeNull();
+    expect(resolveChartComposerShortcut(keyEvent("3", { alt: true }), 8)).toBeNull();
+  });
+});

package/src/plugins/builtin/chart-composer/shortcuts.ts

@@ -0,0 +1,35 @@
+import type { KeyEventLike } from "../../../react/input";
+import { isPlainKey } from "../../../utils/keyboard";
+
+export type ChartComposerShortcut =
+  | "series"
+  | "dates"
+  | "mode"
+  | "resolution"
+  | "reload"
+  | { type: "range"; index: number };
+
+export function resolveChartComposerShortcut(
+  event: KeyEventLike,
+  rangeCount: number,
+): ChartComposerShortcut | null {
+  if (event.defaultPrevented || event.propagationStopped || event.targetEditable) return null;
+
+  const exactShiftReload = event.name === "r"
+    && event.shift
+    && !event.ctrl
+    && !event.meta
+    && !event.super
+    && !event.alt;
+  if (exactShiftReload) return "reload";
+  if (isPlainKey(event, "s")) return "series";
+  if (isPlainKey(event, "w")) return "dates";
+  if (isPlainKey(event, "m")) return "mode";
+  if (isPlainKey(event, "r")) return "resolution";
+  if (!isPlainKey(event, event.name ?? "")) return null;
+
+  const rangeIndex = Number(event.name) - 1;
+  return Number.isInteger(rangeIndex) && rangeIndex >= 0 && rangeIndex < rangeCount
+    ? { type: "range", index: rangeIndex }
+    : null;
+}

package/src/plugins/builtin/chart-composer/use-series-catalog.ts

@@ -0,0 +1,103 @@
+import { useEffect, useMemo, useState } from "react";
+import { searchTickerCandidates } from "../../../tickers/search";
+import { useOptionalAppSelector } from "../../../state/app/context";
+import type { TickerRecord } from "../../../types/ticker";
+import { getSharedRegistry } from "../../registry";
+import {
+  analyzeSeriesSearchQuery,
+  buildSeriesCatalogSuggestions,
+  type SeriesCatalogInstrument,
+  type SeriesCatalogSuggestion,
+} from "./series-catalog";
+
+const EMPTY_TICKERS: ReadonlyMap<string, TickerRecord> = new Map();
+
+export interface SeriesCatalogSearchResult {
+  suggestions: SeriesCatalogSuggestion[];
+  instruments: SeriesCatalogInstrument[];
+  loading: boolean;
+}
+
+/** Shared smart-series search used by both inline quick-add and the full editor. */
+export function useSeriesCatalogSuggestions({
+  query,
+  defaultInstrument,
+  enabled,
+}: {
+  query: string;
+  defaultInstrument: SeriesCatalogInstrument;
+  enabled: boolean;
+}): SeriesCatalogSearchResult {
+  const tickers = useOptionalAppSelector((state) => state.tickers, EMPTY_TICKERS);
+  const analysis = useMemo(() => analyzeSeriesSearchQuery(query), [query]);
+  const [search, setSearch] = useState<{
+    query: string;
+    instruments: SeriesCatalogInstrument[];
+    loading: boolean;
+  }>({ query: "", instruments: [], loading: false });
+
+  useEffect(() => {
+    const instrumentQuery = analysis.instrumentQuery.trim();
+    if (!enabled || !instrumentQuery || analysis.directInstrument) {
+      setSearch({ query: "", instruments: [], loading: false });
+      return;
+    }
+
+    const registry = getSharedRegistry();
+    if (!registry) {
+      setSearch({ query: instrumentQuery, instruments: [], loading: false });
+      return;
+    }
+
+    let cancelled = false;
+    setSearch({ query: instrumentQuery, instruments: [], loading: true });
+    const timer = setTimeout(() => {
+      void searchTickerCandidates({
+        query: instrumentQuery,
+        tickers,
+        dataProvider: registry.marketData,
+        totalLimit: 4,
+        localLimit: 3,
+        includeOptionContracts: false,
+      }).then((candidates) => {
+        if (cancelled) return;
+        setSearch({
+          query: instrumentQuery,
+          instruments: candidates.map((candidate) => ({
+            symbol: candidate.symbol,
+            ...(candidate.ticker?.metadata.exchange
+              ? { exchange: candidate.ticker.metadata.exchange }
+              : candidate.result?.primaryExchange || candidate.result?.exchange
+                ? { exchange: candidate.result?.primaryExchange || candidate.result?.exchange }
+                : {}),
+            ...(candidate.ticker?.metadata.name || candidate.result?.name
+              ? { name: candidate.ticker?.metadata.name || candidate.result?.name }
+              : {}),
+          })),
+          loading: false,
+        });
+      }).catch(() => {
+        if (!cancelled) setSearch({ query: instrumentQuery, instruments: [], loading: false });
+      });
+    }, 80);
+
+    return () => {
+      cancelled = true;
+      clearTimeout(timer);
+    };
+  }, [analysis.directInstrument, analysis.instrumentQuery, enabled, tickers]);
+
+  const instruments = search.query === analysis.instrumentQuery
+    ? search.instruments
+    : [];
+  const suggestions = useMemo(
+    () => buildSeriesCatalogSuggestions(query, defaultInstrument, instruments),
+    [defaultInstrument, instruments, query],
+  );
+
+  return {
+    suggestions,
+    instruments,
+    loading: search.loading && search.query === analysis.instrumentQuery,
+  };
+}

package/src/plugins/builtin/chat/channel-labels.ts

@@ -1,4 +1,5 @@
 import type { ChatChannel } from "../../../api-client";
+import { t } from "../../../i18n";
 import { normalizeChannelId } from "./controller/state";
 
 function normalizeMentionUsername(username: string | null | undefined): string | null {
@@ -25,7 +26,7 @@ function formatDirectChannelLabel(channel: ChatChannel, fallbackId: string) {
       : channelName;
   }
 
-  return fallbackId.startsWith("dm:") ? "DM" : fallbackId;
+  return fallbackId.startsWith("dm:") ? t("DM") : fallbackId;
 }
 
 export function formatChannelLabel(channel: ChatChannel | undefined, fallbackId: string) {
@@ -34,7 +35,7 @@ export function formatChannelLabel(channel: ChatChannel | undefined, fallbackId:
     return formatDirectChannelLabel(channel, fallbackId);
   }
   if (channel.kind === "group") {
-    return channel.name?.trim() || "Group";
+    return channel.name?.trim() || t("Group");
   }
   return channel.name?.trim() || fallbackId;
 }
@@ -47,7 +48,7 @@ export function formatChatPaneTitle(channel: ChatChannel | undefined, fallbackId
   if (channel?.kind === "group") {
     return formatChannelLabel(channel, normalizedFallbackId);
   }
-  if (!channel && normalizedFallbackId.startsWith("dm:")) return "DM";
-  if (!channel && (normalizedFallbackId.startsWith("grp:") || normalizedFallbackId.startsWith("group:"))) return "Group";
+  if (!channel && normalizedFallbackId.startsWith("dm:")) return t("DM");
+  if (!channel && (normalizedFallbackId.startsWith("grp:") || normalizedFallbackId.startsWith("group:"))) return t("Group");
   return `#${formatChannelLabel(channel, normalizedFallbackId)}`;
 }

package/src/plugins/builtin/chat/channels.ts

@@ -1,6 +1,7 @@
 import type { CommandResultDef, GloomPluginContext } from "../../../types/plugin";
 import type { ChatChannel, ChatChannelState } from "../../../api-client";
 import type { AppConfig } from "../../../types/config";
+import { t } from "../../../i18n";
 import { chatController } from "./controller";
 import { formatChannelLabel } from "./channel-labels";
 
@@ -45,14 +46,14 @@ function conversationDetail(channel: ChatChannel): string {
   if (channel.kind === "direct") {
     const displayName = channel.dmUser?.displayName?.trim();
     const username = channel.dmUser?.username?.trim();
-    return [displayName && username ? displayName : null, "Direct message"].filter(Boolean).join(" - ");
+    return [displayName && username ? displayName : null, t("Direct message")].filter(Boolean).join(" - ");
   }
   const members = (channel.members ?? [])
     .map((member) => member.username ? `@${member.username}` : member.displayName)
     .filter(Boolean)
     .slice(0, 4);
   const suffix = (channel.members?.length ?? 0) > members.length ? ` +${(channel.members?.length ?? 0) - members.length}` : "";
-  return members.length > 0 ? `Group chat - ${members.join(", ")}${suffix}` : "Group chat";
+  return members.length > 0 ? `${t("Group chat")} - ${members.join(", ")}${suffix}` : t("Group chat");
 }
 
 export function parseDmUsernames(value: string): string[] {
@@ -107,10 +108,10 @@ export function buildDmCommandResults(ctx: GloomPluginContext, arg: string): Com
       label,
       detail: valid
         ? usernames.length === 1
-          ? "Start or open direct message"
-          : "Start group chat"
-        : "Use @username, or multiple usernames for a group chat",
-      category: "Chat",
+          ? t("Start or open direct message")
+          : t("Start group chat")
+        : t("Use @username, or multiple usernames for a group chat"),
+      category: t("Chat"),
       right: "DM",
       disabled: !valid,
       execute: () => openDmTargetFromCommand(ctx, usernames),
@@ -122,9 +123,9 @@ export function buildDmCommandResults(ctx: GloomPluginContext, arg: string): Com
   if (conversations.length === 0) {
     return [{
       id: "empty",
-      label: "No DMs yet",
-      detail: "Type DM @username to start one",
-      category: "Chat",
+      label: t("No DMs yet"),
+      detail: t("Type DM @username to start one"),
+      category: t("Chat"),
       right: "DM",
       disabled: true,
       execute: () => {},
@@ -135,8 +136,8 @@ export function buildDmCommandResults(ctx: GloomPluginContext, arg: string): Com
     id: `channel:${channel.id}`,
     label: formatChannelLabel(channel, channel.id),
     detail: conversationDetail(channel),
-    category: "Conversations",
-    right: channel.kind === "group" ? "Group" : "DM",
+    category: t("Conversations"),
+    right: channel.kind === "group" ? t("Group") : t("DM"),
     keywords: [
       channel.name,
       channel.dmUser?.username ?? "",