opencandle 0.4.0 → 0.6.0

package/src/market-state/daily-report.ts

@@ -0,0 +1,247 @@
+import { wrapProvider } from "../providers/wrap-provider.js";
+import { getQuote } from "../providers/yahoo-finance.js";
+import { isZeroFilledQuote } from "./resolve.js";
+import type { MarketStateService, ReportRunRecord, ReportTemplateRecord } from "./service.js";
+
+export interface DailyWatchlistReportSummary {
+  watchlistId: number;
+  symbols: string[];
+  quoteCount: number;
+  dataGapCount: number;
+}
+
+export interface DailyWatchlistReport {
+  generatedAt: string;
+  text: string;
+  summary: DailyWatchlistReportSummary;
+  dataGaps: string[];
+}
+
+export function getOrCreateDefaultWatchlistReportTemplate(
+  service: MarketStateService,
+): ReportTemplateRecord {
+  const existing = service
+    .listReportTemplates()
+    .find(
+      (template) =>
+        template.reportType === "watchlist_daily" && targetsDefaultWatchlist(template.configJson),
+    );
+  if (existing) return existing;
+  return service.createReportTemplate({
+    name: "Morning watchlist",
+    reportType: "watchlist_daily",
+    cadence: "daily",
+    timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+    localTime: "08:00",
+    config: { targets: { default_watchlist: true } },
+    enabled: true,
+  });
+}
+
+export async function recordDailyWatchlistReportRun(
+  service: MarketStateService,
+  params: {
+    templateId?: number | null;
+    triggerType: "manual" | "scheduled";
+    scheduledFor?: string | null;
+    ownerId?: string | null;
+  },
+): Promise<{ report: DailyWatchlistReport; run: ReportRunRecord }> {
+  const report = await generateDailyWatchlistReport(service);
+  const run = service.recordReportRun({
+    templateId: params.templateId,
+    startedAt: report.generatedAt,
+    completedAt: new Date().toISOString(),
+    status: "completed",
+    triggerType: params.triggerType,
+    scheduledFor: params.scheduledFor,
+    ownerId: params.ownerId,
+    summary: { ...report.summary, text: report.text },
+    errors: report.dataGaps,
+  });
+  service.recordNotificationEvent({
+    sourceType: "report_run",
+    sourceId: run.id,
+    severity: report.dataGaps.length > 0 ? "warning" : "info",
+    title: "Daily watchlist report generated",
+    body: `Generated ${report.summary.quoteCount} quote(s) with ${report.dataGaps.length} data gap(s).`,
+    payload: report.summary,
+    createdAt: run.completedAt ?? report.generatedAt,
+  });
+  return { report, run };
+}
+
+export async function generateDailyWatchlistReport(
+  service: MarketStateService,
+): Promise<DailyWatchlistReport> {
+  const generatedAt = new Date().toISOString();
+  const watchlist = service.getDefaultWatchlist();
+  const items = service.listWatchlistItems(watchlist.id);
+  const dataGaps: string[] = [];
+
+  const quotes = await Promise.all(
+    items.map(async (item) => {
+      const result = await wrapProvider("yahoo", () => getQuote(item.symbol));
+      if (result.status === "unavailable") {
+        dataGaps.push(`${item.symbol}: ${result.reason}`);
+        return null;
+      }
+      if (result.stale) {
+        dataGaps.push(`${item.symbol}: provider returned stale market data`);
+        return null;
+      }
+      if (isZeroFilledQuote(result.data)) {
+        dataGaps.push(`${item.symbol}: Yahoo returned no valid market data.`);
+        return null;
+      }
+      return { item, quote: result.data };
+    }),
+  );
+
+  const validQuotes = quotes.filter((q) => q != null);
+  const movers = [...validQuotes].sort(
+    (a, b) => Math.abs(b.quote.changePercent) - Math.abs(a.quote.changePercent),
+  );
+  const freshnessLines =
+    validQuotes.length === 0 ? [`  No quote data available.`] : quoteFreshnessLines(validQuotes);
+  const moverLines =
+    movers.length === 0
+      ? [`  No movers available.`]
+      : movers
+          .slice(0, 5)
+          .map(
+            ({ item, quote }) =>
+              `  ${item.symbol}: ${formatSigned(quote.changePercent)}% to $${quote.price.toFixed(2)}`,
+          );
+  const dataGapLines = dataGaps.length === 0 ? [`  None.`] : dataGaps.map((gap) => `  ${gap}`);
+
+  const lines = [
+    `**Daily Watchlist Report**`,
+    `Generated: ${generatedAt}`,
+    `Target watchlist: ${watchlist.name}`,
+    ``,
+    `Quote freshness`,
+    ...freshnessLines,
+    ``,
+    `Major movers`,
+    ...moverLines,
+    ``,
+    `Recent alerts`,
+    `  ${service.listAlertEvents().length} recorded alert event(s).`,
+    ``,
+    `Technical snapshot`,
+    `  Deferred unless quote/history data is available through a later section builder.`,
+    ``,
+    `Data gaps`,
+    ...dataGapLines,
+  ];
+
+  return {
+    generatedAt,
+    text: lines.join("\n"),
+    summary: {
+      watchlistId: watchlist.id,
+      symbols: items.map((item) => item.symbol),
+      quoteCount: validQuotes.length,
+      dataGapCount: dataGaps.length,
+    },
+    dataGaps,
+  };
+}
+
+export function nextDailyReportRunAt(
+  timezone: string,
+  localTime: string,
+  now = new Date(),
+): string {
+  const [hourPart, minutePart] = localTime.split(":");
+  const hour = Number(hourPart);
+  const minute = Number(minutePart);
+  if (
+    !Number.isInteger(hour) ||
+    !Number.isInteger(minute) ||
+    hour < 0 ||
+    hour > 23 ||
+    minute < 0 ||
+    minute > 59
+  ) {
+    throw new Error(`Invalid report local_time: ${localTime}`);
+  }
+
+  const today = zonedDateParts(now, timezone);
+  let candidate = zonedTimeToUtc(today, hour, minute, timezone);
+  if (candidate.getTime() <= now.getTime()) {
+    const tomorrow = new Date(Date.UTC(today.year, today.month - 1, today.day + 1, 12, 0, 0));
+    candidate = zonedTimeToUtc(zonedDateParts(tomorrow, timezone), hour, minute, timezone);
+  }
+  return candidate.toISOString();
+}
+
+export function targetsDefaultWatchlist(config: unknown): boolean {
+  if (typeof config !== "object" || config === null) return false;
+  const targets = (config as { targets?: unknown }).targets;
+  if (typeof targets !== "object" || targets === null) return false;
+  return (targets as { default_watchlist?: unknown }).default_watchlist === true;
+}
+
+function quoteFreshnessLines(
+  quotes: Array<{ item: { symbol: string }; quote: { timestamp: number; price: number } }>,
+): string[] {
+  return quotes.map(
+    ({ item, quote }) =>
+      `  ${item.symbol}: $${quote.price.toFixed(2)} as of ${new Date(quote.timestamp).toISOString()}`,
+  );
+}
+
+function formatSigned(value: number): string {
+  return `${value >= 0 ? "+" : ""}${value.toFixed(2)}`;
+}
+
+function zonedDateParts(
+  date: Date,
+  timezone: string,
+): { year: number; month: number; day: number } {
+  const parts = new Intl.DateTimeFormat("en-CA", {
+    timeZone: timezone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+  }).formatToParts(date);
+  return {
+    year: numberPart(parts, "year"),
+    month: numberPart(parts, "month"),
+    day: numberPart(parts, "day"),
+  };
+}
+
+function zonedTimeToUtc(
+  date: { year: number; month: number; day: number },
+  hour: number,
+  minute: number,
+  timezone: string,
+): Date {
+  const naiveUtc = new Date(Date.UTC(date.year, date.month - 1, date.day, hour, minute, 0));
+  const offsetMs = timeZoneOffsetMs(naiveUtc, timezone);
+  return new Date(naiveUtc.getTime() - offsetMs);
+}
+
+function timeZoneOffsetMs(date: Date, timezone: string): number {
+  const parts = new Intl.DateTimeFormat("en-US", {
+    timeZone: timezone,
+    timeZoneName: "shortOffset",
+    hour: "2-digit",
+  }).formatToParts(date);
+  const value = parts.find((part) => part.type === "timeZoneName")?.value ?? "GMT";
+  const match = /^GMT(?<sign>[+-])(?<hours>\d{1,2})(?::(?<minutes>\d{2}))?$/.exec(value);
+  if (!match?.groups) return 0;
+  const sign = match.groups.sign === "-" ? -1 : 1;
+  const hours = Number(match.groups.hours);
+  const minutes = Number(match.groups.minutes ?? "0");
+  return sign * ((hours * 60 + minutes) * 60_000);
+}
+
+function numberPart(parts: Intl.DateTimeFormatPart[], type: Intl.DateTimeFormatPartTypes): number {
+  const value = parts.find((part) => part.type === type)?.value;
+  if (value == null) throw new Error(`Missing ${type} in formatted date`);
+  return Number(value);
+}

package/src/market-state/local-automation-service.ts

@@ -0,0 +1,162 @@
+import type Database from "better-sqlite3";
+import {
+  type AlertRunnerProviders,
+  type AlertRunnerResult,
+  defaultAlertRunnerProviders,
+  runAlertChecks,
+} from "./alert-runner.js";
+import { nextDailyReportRunAt, recordDailyWatchlistReportRun } from "./daily-report.js";
+import { deliverPendingNotifications } from "./notification-delivery.js";
+import {
+  type AutomationRunnerLeaseResult,
+  MarketStateService,
+  type ReportRunRecord,
+} from "./service.js";
+
+type DailyReportRunRecorder = typeof recordDailyWatchlistReportRun;
+type NotificationDeliverer = typeof deliverPendingNotifications;
+
+export interface LocalAutomationHeartbeatResult {
+  lease: AutomationRunnerLeaseResult;
+  alertCheck: AlertRunnerResult | null;
+  reportRuns: ReportRunRecord[];
+}
+
+export async function runLocalAutomationHeartbeat(
+  db: Database.Database,
+  params: {
+    ownerId: string;
+    ownerKind: "writer" | "monitor";
+    now?: string;
+    ttlSeconds?: number;
+    checkAlerts?: boolean;
+    checkReports?: boolean;
+    providers?: AlertRunnerProviders;
+    recordDailyReportRun?: DailyReportRunRecorder;
+    deliverNotifications?: NotificationDeliverer;
+    releaseLeaseOnComplete?: boolean;
+  },
+): Promise<LocalAutomationHeartbeatResult> {
+  const service = new MarketStateService(db);
+  const now = params.now ?? new Date().toISOString();
+  let acquiredLease = false;
+  try {
+    service.markStaleAutomationRunsLost({ now, graceSeconds: 300 });
+    const hadActiveLease = service.getAutomationRunnerLease(now) != null;
+    const lease = service.acquireAutomationRunnerLease({
+      ownerId: params.ownerId,
+      ownerKind: params.ownerKind,
+      now,
+      ttlSeconds: params.ttlSeconds ?? 90,
+    });
+    acquiredLease = lease.acquired;
+
+    if (!lease.acquired) {
+      return { lease, alertCheck: null, reportRuns: [] };
+    }
+
+    const reportRuns =
+      params.checkReports === false
+        ? []
+        : await runDueReports(service, {
+            ownerId: params.ownerId,
+            now,
+            recordDailyReportRun: params.recordDailyReportRun ?? recordDailyWatchlistReportRun,
+          });
+    if (params.checkAlerts === false || !hasDueAlertRules(service, now)) {
+      await (params.deliverNotifications ?? deliverPendingNotifications)(service, { now });
+      return { lease, alertCheck: null, reportRuns };
+    }
+
+    const alertCheck = await runAlertChecks(service, {
+      ownerId: params.ownerId,
+      triggerType: hadActiveLease ? "heartbeat" : "resume",
+      now,
+      providers: params.providers ?? defaultAlertRunnerProviders,
+    });
+    await (params.deliverNotifications ?? deliverPendingNotifications)(service, { now });
+    return {
+      lease,
+      alertCheck,
+      reportRuns,
+    };
+  } finally {
+    if (params.releaseLeaseOnComplete && acquiredLease) {
+      service.releaseAutomationRunnerLease(params.ownerId);
+    }
+  }
+}
+
+function hasDueAlertRules(service: MarketStateService, now: string): boolean {
+  const nowMs = new Date(now).getTime();
+  return service.listAlertRules().some((rule) => {
+    if (!rule.enabled || rule.status !== "active") return false;
+    if (rule.nextCheckAt == null) return true;
+    return new Date(rule.nextCheckAt).getTime() <= nowMs;
+  });
+}
+
+async function runDueReports(
+  service: MarketStateService,
+  params: { ownerId: string; now: string; recordDailyReportRun: DailyReportRunRecorder },
+): Promise<ReportRunRecord[]> {
+  const nowMs = new Date(params.now).getTime();
+  const dueTemplates = service
+    .listReportTemplates()
+    .filter(
+      (template) =>
+        template.enabled &&
+        template.reportType === "watchlist_daily" &&
+        template.nextRunAt != null &&
+        new Date(template.nextRunAt).getTime() <= nowMs,
+    );
+  const runs: ReportRunRecord[] = [];
+  for (const template of dueTemplates) {
+    const scheduledFor = template.nextRunAt;
+    if (scheduledFor == null) continue;
+    const nextRunAt = nextDailyReportRunAt(
+      template.timezone,
+      template.localTime,
+      new Date(params.now),
+    );
+    const claimed = service.claimDueReportTemplateRun(template.id, {
+      scheduledFor,
+      nextRunAt,
+      claimedAt: params.now,
+    });
+    if (claimed == null) continue;
+    try {
+      const { run } = await params.recordDailyReportRun(service, {
+        templateId: template.id,
+        triggerType: "scheduled",
+        scheduledFor,
+        ownerId: params.ownerId,
+      });
+      runs.push(run);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const failedRun = service.recordReportRun({
+        templateId: template.id,
+        startedAt: params.now,
+        completedAt: new Date().toISOString(),
+        status: "failed",
+        triggerType: "scheduled",
+        scheduledFor,
+        ownerId: params.ownerId,
+        errors: [message],
+      });
+      service.recordNotificationEvent({
+        sourceType: "report_run",
+        sourceId: failedRun.id,
+        severity: "error",
+        title: "Daily watchlist report failed",
+        body: message,
+        payload: { template_id: template.id, scheduled_for: scheduledFor },
+        createdAt: failedRun.completedAt ?? params.now,
+      });
+      service.updateReportTemplate(template.id, { nextRunAt: scheduledFor });
+      runs.push(failedRun);
+    }
+  }
+  return runs;
+}

package/src/market-state/notification-delivery.ts

@@ -0,0 +1,158 @@
+import type { MarketStateService } from "./service.js";
+
+export interface NotificationDeliveryOptions {
+  webhookUrl?: string | null;
+  fetchImpl?: typeof fetch;
+  now?: string;
+  timeoutMs?: number;
+  maxAttempts?: number;
+}
+
+export interface NotificationDeliveryResult {
+  attempted: number;
+  succeeded: number;
+  failed: number;
+}
+
+export async function deliverPendingNotifications(
+  service: MarketStateService,
+  options: NotificationDeliveryOptions = {},
+): Promise<NotificationDeliveryResult> {
+  const webhookUrl = options.webhookUrl ?? process.env.OPENCANDLE_NOTIFICATION_WEBHOOK_URL ?? null;
+  if (!webhookUrl) return { attempted: 0, succeeded: 0, failed: 0 };
+
+  const now = options.now ?? new Date().toISOString();
+  const timeoutMs = options.timeoutMs ?? 10_000;
+  const maxAttempts = options.maxAttempts ?? 5;
+  const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+  let attempted = 0;
+  let succeeded = 0;
+  let failed = 0;
+
+  const attempts = service.listNotificationDeliveryAttempts();
+  const deliveredWebhookIds = new Set(
+    attempts
+      .filter((attempt) => attempt.channel === "webhook" && attempt.status === "success")
+      .map((attempt) => attempt.notificationEventId),
+  );
+  const lastWebhookAttemptAt = new Map<number, string>();
+  for (const attempt of attempts) {
+    if (attempt.channel !== "webhook" || attempt.status === "success") continue;
+    const current = lastWebhookAttemptAt.get(attempt.notificationEventId);
+    if (current == null || attempt.attemptedAt > current) {
+      lastWebhookAttemptAt.set(attempt.notificationEventId, attempt.attemptedAt);
+    }
+  }
+
+  const pendingNotifications = service
+    .listNotificationEvents()
+    .filter((notification) => !deliveredWebhookIds.has(notification.id))
+    .sort((left, right) => {
+      const leftAttempt = lastWebhookAttemptAt.get(left.id);
+      const rightAttempt = lastWebhookAttemptAt.get(right.id);
+      if (leftAttempt == null && rightAttempt != null) return -1;
+      if (leftAttempt != null && rightAttempt == null) return 1;
+      if (leftAttempt != null && rightAttempt != null && leftAttempt !== rightAttempt) {
+        return leftAttempt.localeCompare(rightAttempt);
+      }
+      if (left.createdAt !== right.createdAt) return left.createdAt.localeCompare(right.createdAt);
+      return left.id - right.id;
+    });
+
+  if (!isAllowedWebhookUrl(webhookUrl)) {
+    const rejectedHost = webhookUrlHost(webhookUrl);
+    console.warn(`Rejected notification webhook URL host: ${rejectedHost}`);
+    const rejectedNotifications = pendingNotifications.slice(0, maxAttempts);
+    const error = `Rejected notification webhook URL host: ${rejectedHost}`;
+    for (const notification of rejectedNotifications) {
+      service.recordNotificationDeliveryAttempt({
+        notificationEventId: notification.id,
+        channel: "webhook",
+        status: "failed",
+        attemptedAt: now,
+        completedAt: now,
+        error,
+      });
+    }
+    const rejected = rejectedNotifications.length;
+    return { attempted: rejected, succeeded: 0, failed: rejected };
+  }
+
+  for (const notification of pendingNotifications) {
+    if (attempted >= maxAttempts) break;
+    attempted++;
+    const controller = new AbortController();
+    const timeout = setTimeout(
+      () => controller.abort(new Error(`Webhook delivery timed out after ${timeoutMs}ms`)),
+      timeoutMs,
+    );
+    try {
+      const response = await fetchImpl(webhookUrl, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        signal: controller.signal,
+        body: JSON.stringify({
+          id: notification.id,
+          source_type: notification.sourceType,
+          source_id: notification.sourceId,
+          severity: notification.severity,
+          title: notification.title,
+          body: notification.body,
+          payload: notification.payloadJson,
+          status: notification.status,
+          created_at: notification.createdAt,
+        }),
+      });
+      if (!response.ok) throw new Error(`HTTP ${response.status}`);
+      clearTimeout(timeout);
+      service.recordNotificationDeliveryAttempt({
+        notificationEventId: notification.id,
+        channel: "webhook",
+        status: "success",
+        attemptedAt: now,
+        completedAt: now,
+        response: { status: response.status },
+      });
+      succeeded++;
+    } catch (error) {
+      clearTimeout(timeout);
+      const message = controller.signal.aborted
+        ? `Webhook delivery timed out after ${timeoutMs}ms`
+        : error instanceof Error
+          ? error.message
+          : String(error);
+      service.recordNotificationDeliveryAttempt({
+        notificationEventId: notification.id,
+        channel: "webhook",
+        status: "failed",
+        attemptedAt: now,
+        completedAt: now,
+        error: message,
+      });
+      failed++;
+    }
+  }
+
+  return { attempted, succeeded, failed };
+}
+
+function isAllowedWebhookUrl(raw: string): boolean {
+  let url: URL;
+  try {
+    url = new URL(raw);
+  } catch {
+    return false;
+  }
+  if (url.protocol !== "https:" && url.protocol !== "http:") return false;
+  const host = url.hostname;
+  if (host === "169.254.169.254" || host.startsWith("169.254.")) return false;
+  return true;
+}
+
+function webhookUrlHost(raw: string): string {
+  try {
+    return new URL(raw).hostname || "(empty)";
+  } catch {
+    return "(invalid URL)";
+  }
+}

package/src/market-state/resolve-for-mutation.ts

@@ -0,0 +1,24 @@
+import { resolveYahooInstrument, searchYahooInstruments } from "./resolve.js";
+
+export type MutationInstrumentResolution =
+  | { status: "resolved"; instrument: Awaited<ReturnType<typeof resolveYahooInstrument>> }
+  | {
+      status: "needs_selection";
+      query: string;
+      candidates: Awaited<ReturnType<typeof searchYahooInstruments>>;
+    };
+
+export async function resolveInstrumentForMutation(
+  symbol: string,
+): Promise<MutationInstrumentResolution> {
+  try {
+    return { status: "resolved", instrument: await resolveYahooInstrument(symbol) };
+  } catch (error) {
+    const query = symbol.trim();
+    const candidates = await searchYahooInstruments(query);
+    if (candidates.length > 0) {
+      return { status: "needs_selection", query, candidates };
+    }
+    throw error;
+  }
+}

package/src/market-state/resolve.ts

@@ -0,0 +1,112 @@
+import { cache, TTL } from "../infra/cache.js";
+import { httpGet } from "../infra/http-client.js";
+import { rateLimiter } from "../infra/rate-limiter.js";
+import { wrapProvider } from "../providers/wrap-provider.js";
+import { getQuote } from "../providers/yahoo-finance.js";
+import type { StockQuote } from "../types/market.js";
+import type { InstrumentInput } from "./service.js";
+
+export interface InstrumentCandidate {
+  symbol: string;
+  name: string | null;
+  quoteType: string;
+  assetType: string;
+  exchange: string | null;
+  provider: "yahoo";
+  score: number | null;
+}
+
+interface YahooSearchResponse {
+  quotes?: Array<{
+    symbol?: string;
+    shortname?: string;
+    longname?: string;
+    quoteType?: string;
+    exchange?: string;
+    score?: number;
+  }>;
+}
+
+export async function searchYahooInstruments(query: string): Promise<InstrumentCandidate[]> {
+  const trimmed = query.trim();
+  if (!trimmed) return [];
+
+  const cacheKey = `yahoo:instrument-search:${trimmed.toLowerCase()}`;
+  const cached = cache.get<InstrumentCandidate[]>(cacheKey);
+  if (cached) return cached;
+
+  const url = `https://query1.finance.yahoo.com/v1/finance/search?q=${encodeURIComponent(trimmed)}&quotesCount=10&newsCount=0`;
+  await rateLimiter.acquire("yahoo");
+  const data = await httpGet<YahooSearchResponse>(url, {
+    headers: { "User-Agent": "OpenCandle/1.0" },
+  });
+
+  const candidates = (data.quotes ?? []).flatMap((quote) => {
+    if (!quote.symbol) return [];
+    const quoteType = quote.quoteType ?? "UNKNOWN";
+    return [
+      {
+        symbol: quote.symbol.toUpperCase(),
+        name: quote.longname ?? quote.shortname ?? null,
+        quoteType,
+        assetType: assetTypeFromQuoteType(quoteType, quote.symbol),
+        exchange: quote.exchange ?? null,
+        provider: "yahoo" as const,
+        score: quote.score ?? null,
+      },
+    ];
+  });
+  cache.set(cacheKey, candidates, TTL.WEB_SEARCH);
+  return candidates;
+}
+
+export async function resolveYahooInstrument(symbol: string): Promise<InstrumentInput> {
+  const normalized = symbol.trim().toUpperCase();
+  if (!normalized) {
+    throw new Error("symbol is required.");
+  }
+
+  const result = await wrapProvider("yahoo", () => getQuote(normalized));
+  if (result.status === "unavailable") {
+    throw new Error(`Could not resolve ${normalized}: ${result.reason}`);
+  }
+
+  const quote = result.data;
+  if (isZeroFilledQuote(quote)) {
+    throw new Error(`Could not resolve ${normalized}: Yahoo returned no valid market data.`);
+  }
+
+  return {
+    symbol: quote.symbol?.toUpperCase() ?? normalized,
+    assetType: inferAssetType(quote.symbol ?? normalized),
+    currency: quote.currency?.trim().toUpperCase() || null,
+    provider: "yahoo",
+    providerMetadata: {
+      price: quote.price,
+      volume: quote.volume,
+      week52High: quote.week52High,
+      week52Low: quote.week52Low,
+      timestamp: quote.timestamp,
+    },
+  };
+}
+
+export function isZeroFilledQuote(quote: StockQuote): boolean {
+  return quote.price === 0 && quote.volume === 0 && quote.week52High === 0 && quote.week52Low === 0;
+}
+
+function inferAssetType(symbol: string): string {
+  if (symbol.endsWith("-USD")) return "crypto";
+  if (symbol.startsWith("^")) return "index";
+  return "equity";
+}
+
+function assetTypeFromQuoteType(quoteType: string, symbol: string): string {
+  const normalized = quoteType.toLowerCase();
+  if (normalized.includes("etf")) return "etf";
+  if (normalized.includes("mutualfund")) return "fund";
+  if (normalized.includes("crypto")) return "crypto";
+  if (normalized.includes("index")) return "index";
+  if (normalized.includes("equity")) return "equity";
+  return inferAssetType(symbol.toUpperCase());
+}