horizon-code 0.2.0 → 0.3.1

package/src/platform/exchanges.ts

@@ -0,0 +1,154 @@
+// Exchange credential profiles — defines what keys each exchange needs
+// Keys are stored encrypted via /env system
+
+import { listEncryptedEnvNames, getDecryptedEnv, setEncryptedEnv, removeEncryptedEnv } from "./config.ts";
+
+export interface ExchangeProfile {
+  id: string;
+  name: string;
+  category: "prediction" | "stock" | "crypto";
+  description: string;
+  keys: { env: string; label: string; hint: string; required: boolean }[];
+  testUrl?: string;
+}
+
+export const EXCHANGE_PROFILES: ExchangeProfile[] = [
+  {
+    id: "polymarket",
+    name: "Polymarket",
+    category: "prediction",
+    description: "Prediction market on Polygon. Requires a funded wallet private key.",
+    keys: [
+      { env: "POLYMARKET_PRIVATE_KEY", label: "Private Key", hint: "Ethereum private key (0x...)", required: true },
+      { env: "CLOB_API_KEY", label: "CLOB API Key", hint: "From Polymarket developer portal (optional)", required: false },
+      { env: "CLOB_SECRET", label: "CLOB Secret", hint: "CLOB API secret", required: false },
+      { env: "CLOB_PASSPHRASE", label: "CLOB Passphrase", hint: "CLOB API passphrase", required: false },
+    ],
+  },
+  {
+    id: "kalshi",
+    name: "Kalshi",
+    category: "prediction",
+    description: "Regulated US prediction market. API key from kalshi.com/settings.",
+    keys: [
+      { env: "KALSHI_API_KEY", label: "API Key", hint: "From Kalshi account settings", required: true },
+      { env: "KALSHI_API_SECRET", label: "API Secret", hint: "Secret paired with API key", required: false },
+    ],
+  },
+  {
+    id: "limitless",
+    name: "Limitless",
+    category: "prediction",
+    description: "Emerging prediction market platform.",
+    keys: [
+      { env: "LIMITLESS_API_KEY", label: "API Key", hint: "From Limitless developer portal", required: true },
+    ],
+  },
+  {
+    id: "alpaca",
+    name: "Alpaca",
+    category: "stock",
+    description: "Commission-free stock/ETF trading. Paper + live. alpaca.markets",
+    keys: [
+      { env: "ALPACA_API_KEY", label: "API Key", hint: "From Alpaca dashboard (paper or live)", required: true },
+      { env: "ALPACA_SECRET_KEY", label: "Secret Key", hint: "Secret paired with API key", required: true },
+      { env: "ALPACA_PAPER", label: "Paper Mode", hint: "Set to 'true' for paper trading (default: true)", required: false },
+    ],
+  },
+  {
+    id: "robinhood",
+    name: "Robinhood",
+    category: "stock",
+    description: "Stock/options/crypto trading. Uses OAuth token.",
+    keys: [
+      { env: "ROBINHOOD_TOKEN", label: "Access Token", hint: "OAuth token from Robinhood API", required: true },
+    ],
+  },
+  {
+    id: "polygon",
+    name: "Polygon.io",
+    category: "stock",
+    description: "Real-time & historical market data for stocks, options, crypto. polygon.io",
+    keys: [
+      { env: "POLYGON_API_KEY", label: "API Key", hint: "From polygon.io dashboard (free tier available)", required: true },
+    ],
+  },
+  {
+    id: "fmp",
+    name: "Financial Modeling Prep",
+    category: "stock",
+    description: "Fundamental data, financials, earnings. financialmodelingprep.com",
+    keys: [
+      { env: "FMP_API_KEY", label: "API Key", hint: "From FMP dashboard", required: true },
+    ],
+  },
+];
+
+export type ConnectionStatus = "connected" | "partial" | "disconnected";
+
+export interface ExchangeStatus {
+  profile: ExchangeProfile;
+  status: ConnectionStatus;
+  keysSet: string[];
+  keysMissing: string[];
+}
+
+/** Check which exchanges have credentials configured */
+export function getExchangeStatuses(): ExchangeStatus[] {
+  const envNames = new Set(listEncryptedEnvNames());
+  // Also check process.env for keys set externally
+  const allKeys = new Set([...envNames, ...Object.keys(process.env).filter(k =>
+    EXCHANGE_PROFILES.some(p => p.keys.some(key => key.env === k && process.env[k]))
+  )]);
+
+  return EXCHANGE_PROFILES.map(profile => {
+    const keysSet = profile.keys.filter(k => allKeys.has(k.env)).map(k => k.env);
+    const keysMissing = profile.keys.filter(k => k.required && !allKeys.has(k.env)).map(k => k.env);
+    const requiredKeys = profile.keys.filter(k => k.required);
+    const requiredSet = requiredKeys.filter(k => allKeys.has(k.env));
+
+    let status: ConnectionStatus;
+    if (requiredSet.length === requiredKeys.length) {
+      status = "connected";
+    } else if (keysSet.length > 0) {
+      status = "partial";
+    } else {
+      status = "disconnected";
+    }
+
+    return { profile, status, keysSet, keysMissing };
+  });
+}
+
+/** Get status for a specific exchange */
+export function getExchangeStatus(exchangeId: string): ExchangeStatus | null {
+  return getExchangeStatuses().find(s => s.profile.id === exchangeId) ?? null;
+}
+
+/** Set a credential for an exchange */
+export function setExchangeKey(envName: string, value: string): boolean {
+  try {
+    setEncryptedEnv(envName, value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** Remove a credential */
+export function removeExchangeKey(envName: string): boolean {
+  try {
+    removeEncryptedEnv(envName);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** Get a decrypted credential (for passing to subprocesses) */
+export function getExchangeKey(envName: string): string | null {
+  // Check encrypted env first, then process.env
+  const decrypted = getDecryptedEnv(envName);
+  if (decrypted) return decrypted;
+  return process.env[envName] ?? null;
+}

package/src/platform/supabase.ts

@@ -114,18 +114,33 @@ export async function restoreSession(): Promise<boolean> {
       }
     }
 
+    // Try setSession first (works if access token still valid)
     const { data, error } = await sb.auth.setSession({
       access_token: accessToken,
       refresh_token: refreshToken,
     });
 
     if (!error && data.session) {
-      // Session restored — auto-refresh will keep it alive
       if (config.api_key) platform.setApiKey(config.api_key);
       return true;
     }
 
-    // Tokens fully expired — user needs to /login again
+    // Access token expired — try refreshing with just the refresh token
+    const { data: refreshData, error: refreshError } = await sb.auth.refreshSession({
+      refresh_token: refreshToken,
+    });
+
+    if (!refreshError && refreshData.session) {
+      // Save the new tokens
+      saveSessionTokens(config, refreshData.session.access_token, refreshData.session.refresh_token);
+      config.user_email = refreshData.session.user.email ?? config.user_email;
+      config.user_id = refreshData.session.user.id;
+      saveConfig(config);
+      if (config.api_key) platform.setApiKey(config.api_key);
+      return true;
+    }
+
+    // Both failed — refresh token fully expired
     delete config.supabase_session;
     saveConfig(config);
   }

package/src/research/apis.ts

@@ -229,26 +229,304 @@ export async function polymarketTrades(slug: string): Promise<any> {
   };
 }
 
+// ── Polymarket DATA API — wallet/trade deep analysis ──
+
+/** Get recent trades for a market (up to 500) */
+export async function getMarketTrades(conditionId: string, limit = 200): Promise<any[]> {
+  const data = await get(`${DATA_API}/trades?market=${conditionId}&limit=${Math.min(limit, 500)}`).catch(() => []);
+  return data ?? [];
+}
+
+/** Get trades for a specific wallet (up to 500) */
+export async function getWalletTrades(address: string, limit = 200, conditionId?: string): Promise<any[]> {
+  let url = `${DATA_API}/trades?maker_address=${address}&limit=${Math.min(limit, 500)}`;
+  if (conditionId) url += `&market=${conditionId}`;
+  const data = await get(url).catch(() => []);
+  return data ?? [];
+}
+
+/** Get open positions for a wallet */
+export async function getWalletPositions(address: string, limit = 100): Promise<any[]> {
+  const data = await get(`${DATA_API}/positions?user=${address}&limit=${Math.min(limit, 500)}&sort_by=TOKENS`).catch(() => []);
+  return data ?? [];
+}
+
+/** Get wallet profile from Gamma API */
+export async function getWalletProfile(address: string): Promise<any> {
+  const data = await get(`${GAMMA}/users?address=${address}`).catch(() => null);
+  const user = Array.isArray(data) ? data[0] : data;
+  return user ? {
+    address, name: user.pseudonym ?? user.name ?? "Anonymous",
+    bio: user.bio ?? "", profileImage: user.profile_image,
+    xUsername: user.x_username, createdAt: user.created_at,
+  } : { address, name: "Anonymous" };
+}
+
+/** Resolve market slug → conditionId */
+export async function resolveConditionId(slug: string): Promise<{ conditionId: string; title: string; market: any }> {
+  const events = await get(`${GAMMA}/events?slug=${slug}`);
+  const market = events?.[0]?.markets?.[0];
+  if (!market) throw new Error(`Market not found: ${slug}`);
+  return { conditionId: market.conditionId, title: events[0].title, market };
+}
+
 // ── Kalshi ──
+// API v2 returns prices as dollar strings: "yes_bid_dollars": "0.09"
+// Volumes as float strings: "volume_fp": "55642.00"
+
+/** Parse Kalshi dollar string to number (e.g. "0.09" → 0.09, null → null) */
+function kPrice(v: any): number | null {
+  if (v == null || v === "" || v === "0.0000") return null;
+  const n = typeof v === "string" ? parseFloat(v) : v;
+  return isNaN(n) ? null : +n.toFixed(4);
+}
+
+/** Parse Kalshi integer/float volume string */
+function kVol(v: any): number {
+  if (v == null || v === "") return 0;
+  const n = typeof v === "string" ? parseFloat(v) : v;
+  return isNaN(n) ? 0 : Math.round(n);
+}
+
+/** Parse a Kalshi market from the API response */
+function parseKalshiMarket(m: any): any {
+  const yesBid = kPrice(m.yes_bid_dollars ?? m.yes_bid);
+  const yesAsk = kPrice(m.yes_ask_dollars ?? m.yes_ask);
+  const lastPrice = kPrice(m.last_price_dollars ?? m.last_price);
+  return {
+    ticker: m.ticker,
+    name: m.title ?? m.yes_sub_title ?? m.subtitle ?? m.ticker,
+    title: m.title ?? m.yes_sub_title ?? m.subtitle ?? m.ticker,
+    yesBid, yesAsk, lastPrice,
+    noBid: kPrice(m.no_bid_dollars ?? m.no_bid),
+    noAsk: kPrice(m.no_ask_dollars ?? m.no_ask),
+    volume: kVol(m.volume_fp ?? m.volume),
+    volume24h: kVol(m.volume_24h_fp ?? m.volume_24h),
+    openInterest: kVol(m.open_interest_fp ?? m.open_interest),
+    spread: yesBid != null && yesAsk != null ? +((yesAsk - yesBid)).toFixed(4) : null,
+    closeTime: m.close_time, expirationTime: m.expiration_time,
+    status: m.status,
+  };
+}
+
+let _kalshiCache: { data: any[]; ts: number } = { data: [], ts: 0 };
+const KALSHI_CACHE_TTL = 60_000;
+
+/** Fetch events from Kalshi — uses cursor pagination to get more results */
+async function fetchKalshiEvents(limit = 200): Promise<any[]> {
+  if (_kalshiCache.data.length > 0 && Date.now() - _kalshiCache.ts < KALSHI_CACHE_TTL) {
+    return _kalshiCache.data;
+  }
+
+  const all: any[] = [];
+  let cursor = "";
+  const batchSize = 100;
+
+  // Fetch up to `limit` events across pages
+  while (all.length < limit) {
+    const params = new URLSearchParams({
+      status: "open", with_nested_markets: "true",
+      limit: String(Math.min(batchSize, limit - all.length)),
+    });
+    if (cursor) params.set("cursor", cursor);
+
+    const data = await get(`${KALSHI}/events?${params}`).catch(() => ({ events: [], cursor: "" }));
+    const events = data?.events ?? [];
+    if (events.length === 0) break;
+
+    all.push(...events);
+    cursor = data?.cursor ?? "";
+    if (!cursor) break;
+  }
+
+  _kalshiCache = { data: all, ts: Date.now() };
+  return all;
+}
+
+/** Build searchable text from a Kalshi event (including nested market titles) */
+function kalshiSearchText(e: any): string {
+  const parts = [e.title, e.sub_title, e.category, e.series_ticker, e.event_ticker];
+  // Include nested market titles for better search
+  for (const m of (e.markets ?? [])) {
+    parts.push(m.title, m.subtitle, m.yes_sub_title, m.no_sub_title, m.ticker);
+  }
+  return parts.filter(Boolean).join(" ").toLowerCase();
+}
+
+// Common series tickers for keyword-to-series mapping
+const KALSHI_SERIES_MAP: Record<string, string> = {
+  bitcoin: "KXBTC", btc: "KXBTC", crypto: "KXBTC",
+  ethereum: "KXETH", eth: "KXETH",
+  nasdaq: "KXNASDAQ", spy: "KXSPY", sp500: "KXSPY", "s&p": "KXSPY",
+  fed: "KXFED", "interest rate": "KXFED", fomc: "KXFED",
+  cpi: "KXCPI", inflation: "KXCPI",
+  gdp: "KXGDP", unemployment: "KXUNEMP", jobs: "KXUNEMP",
+  oil: "KXOIL", gold: "KXGOLD",
+};
 
 export async function kalshiEvents(opts: { query?: string; limit?: number } = {}): Promise<any[]> {
-  const params = new URLSearchParams({
-    status: "open", with_nested_markets: "true",
-    limit: String(Math.min(opts.limit ?? 10, 20)),
+  const limit = Math.min(opts.limit ?? 10, 20);
+  const query = (opts.query ?? "").toLowerCase().trim();
+
+  if (!query) {
+    const allEvents = await fetchKalshiEvents();
+    return allEvents.slice(0, limit).map(formatKalshiEvent);
+  }
+
+  // 1. Try series_ticker mapping first (crypto, fed, etc.)
+  const seriesTicker = KALSHI_SERIES_MAP[query] ??
+    Object.entries(KALSHI_SERIES_MAP).find(([k]) => query.includes(k))?.[1];
+
+  if (seriesTicker) {
+    try {
+      const params = new URLSearchParams({
+        status: "open", with_nested_markets: "true",
+        series_ticker: seriesTicker, limit: String(limit),
+      });
+      const data = await get(`${KALSHI}/events?${params}`);
+      const events = data?.events ?? [];
+      if (events.length > 0) return events.slice(0, limit).map(formatKalshiEvent);
+    } catch {}
+  }
+
+  // 2. Search cached events (title + market titles)
+  const allEvents = await fetchKalshiEvents();
+  const words = query.split(/\s+/).filter(w => w.length > 1);
+
+  let events = allEvents.filter((e: any) => {
+    const text = kalshiSearchText(e);
+    return words.every(w => text.includes(w));
+  });
+
+  // Fallback: any word match
+  if (events.length === 0 && words.length > 1) {
+    events = allEvents.filter((e: any) => {
+      const text = kalshiSearchText(e);
+      return words.some(w => text.includes(w));
+    });
+  }
+
+  // 3. If still empty, try series_ticker as-is (user might pass a ticker directly)
+  if (events.length === 0) {
+    try {
+      const params = new URLSearchParams({
+        status: "open", with_nested_markets: "true",
+        series_ticker: query.toUpperCase(), limit: String(limit),
+      });
+      const data = await get(`${KALSHI}/events?${params}`);
+      events = data?.events ?? [];
+    } catch {}
+  }
+
+  // Sort by relevance
+  events.sort((a: any, b: any) => {
+    const aTitle = (a.title ?? "").toLowerCase();
+    const bTitle = (b.title ?? "").toLowerCase();
+    const aInTitle = words.some(w => aTitle.includes(w)) ? 1 : 0;
+    const bInTitle = words.some(w => bTitle.includes(w)) ? 1 : 0;
+    if (aInTitle !== bInTitle) return bInTitle - aInTitle;
+    const aVol = (a.markets ?? []).reduce((s: number, m: any) => s + kVol(m.volume_fp ?? m.volume), 0);
+    const bVol = (b.markets ?? []).reduce((s: number, m: any) => s + kVol(m.volume_fp ?? m.volume), 0);
+    return bVol - aVol;
   });
-  if (opts.query) params.set("series_ticker", opts.query);
 
-  const data = await get(`${KALSHI}/events?${params}`);
-  return (data?.events ?? []).map((e: any) => ({
+  return events.slice(0, limit).map(formatKalshiEvent);
+}
+
+function formatKalshiEvent(e: any): any {
+  return {
     ticker: e.event_ticker, title: e.title,
     category: e.category, subtitle: e.sub_title,
-    url: `https://kalshi.com/markets/${e.event_ticker?.toLowerCase()}`,
-    markets: (e.markets ?? []).map((m: any) => ({
-      name: m.title ?? m.subtitle, yesBid: m.yes_bid, yesAsk: m.yes_ask,
-      lastPrice: m.last_price, volume: m.volume,
-      openInterest: m.open_interest, closeTime: m.close_time,
-    })),
-  }));
+    url: `https://kalshi.com/markets/${(e.event_ticker ?? "").toLowerCase()}`,
+    markets: (e.markets ?? []).slice(0, 5).map(parseKalshiMarket),
+  };
+}
+
+export async function kalshiEventDetail(ticker: string): Promise<any> {
+  const data = await get(`${KALSHI}/events/${ticker}?with_nested_markets=true`);
+  const event = data?.event ?? data;
+  if (!event) throw new Error(`Kalshi event not found: ${ticker}`);
+
+  return {
+    ticker: event.event_ticker, title: event.title,
+    category: event.category, subtitle: event.sub_title,
+    description: (event.strike_description ?? event.sub_title ?? "").slice(0, 500),
+    url: `https://kalshi.com/markets/${(event.event_ticker ?? "").toLowerCase()}`,
+    markets: (event.markets ?? []).map(parseKalshiMarket),
+  };
+}
+
+export async function kalshiOrderBook(ticker: string): Promise<any> {
+  const book = await get(`${KALSHI}/markets/${ticker}/orderbook`);
+  const ob = book?.orderbook ?? {};
+  // yes array: [[price_cents, size], ...] — bids for YES outcome
+  // no array: [[price_cents, size], ...] — asks (complement pricing)
+  const bids = (ob.yes ?? []).map((l: any) => {
+    const price = Array.isArray(l) ? l[0] / 100 : (l.price ?? 0) / 100;
+    const size = Array.isArray(l) ? l[1] : l.size ?? 0;
+    return { price: +price.toFixed(4), size };
+  });
+  const asks = (ob.no ?? []).map((l: any) => {
+    const price = Array.isArray(l) ? 1 - l[0] / 100 : 1 - (l.price ?? 0) / 100;
+    const size = Array.isArray(l) ? l[1] : l.size ?? 0;
+    return { price: +price.toFixed(4), size };
+  });
+  bids.sort((a: any, b: any) => b.price - a.price);
+  asks.sort((a: any, b: any) => a.price - b.price);
+
+  return {
+    ticker, title: ticker,
+    url: `https://kalshi.com/markets/${ticker.toLowerCase()}`,
+    bestBid: bids[0]?.price ?? null,
+    bestAsk: asks[0]?.price ?? null,
+    spread: bids[0] && asks[0] ? +(asks[0].price - bids[0].price).toFixed(4) : null,
+    bids: bids.slice(0, 15),
+    asks: asks.slice(0, 15),
+  };
+}
+
+export async function kalshiPriceHistory(ticker: string, period = "1w"): Promise<any> {
+  const intervalMap: Record<string, number> = { "1h": 1, "6h": 1, "1d": 60, "1w": 60, "1m": 1440, "max": 1440 };
+  const periodInterval = intervalMap[period] ?? 60;
+
+  const data = await get(`${KALSHI}/markets/${ticker}/candlesticks?period_interval=${periodInterval}`).catch(() => ({ candlesticks: [] }));
+  const candles = data?.candlesticks ?? [];
+
+  // Prices can be dollar strings or cent integers — normalize to decimal
+  const normalize = (v: any): number => {
+    if (v == null) return 0;
+    const n = typeof v === "string" ? parseFloat(v) : v;
+    // If > 1, it's cents (old format); if <= 1, it's dollars (new format)
+    return n > 1 ? n / 100 : n;
+  };
+
+  const prices = candles.map((c: any) => {
+    const bid = normalize(c.yes_bid_dollars ?? c.yes_bid ?? c.yes_price);
+    const ask = normalize(c.yes_ask_dollars ?? c.yes_ask);
+    return ask > 0 ? (bid + ask) / 2 : bid;
+  }).filter((p: number) => p > 0);
+
+  const timestamps = candles.map((c: any) => {
+    const ts = c.end_period_ts ?? c.ts;
+    return typeof ts === "string" ? new Date(ts).getTime() / 1000 : ts;
+  });
+
+  return {
+    ticker, title: ticker,
+    url: `https://kalshi.com/markets/${ticker.toLowerCase()}`,
+    interval: period,
+    dataPoints: prices.length,
+    current: prices.length > 0 ? +prices[prices.length - 1].toFixed(4) : null,
+    high: prices.length > 0 ? +Math.max(...prices).toFixed(4) : null,
+    low: prices.length > 0 ? +Math.min(...prices).toFixed(4) : null,
+    change: prices.length > 1 ? +((prices[prices.length - 1] - prices[0]) / (prices[0] || 1)).toFixed(4) : null,
+    priceHistory: candles.map((c: any, i: number) => ({
+      t: timestamps[i], p: prices[i] ?? 0,
+      volume: kVol(c.volume_fp ?? c.volume),
+      open: normalize(c.open_dollars ?? c.open),
+      close: normalize(c.close_dollars ?? c.close),
+    })).filter((p: any) => p.p > 0),
+  };
 }
 
 // ── Exa (web search + sentiment) — via server proxy ──

package/src/research/stock-apis.ts

@@ -0,0 +1,117 @@
+// Yahoo Finance API — free, no auth required
+// Uses v8 chart API (still public) + search API
+// Quote data extracted from chart metadata (v7 quote endpoint now requires crumb auth)
+
+const YF_CHART = "https://query1.finance.yahoo.com/v8/finance/chart";
+const YF_SEARCH = "https://query2.finance.yahoo.com/v1/finance/search";
+
+async function yfGet(url: string): Promise<any> {
+  const res = await fetch(url, {
+    headers: {
+      "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36",
+      "Accept": "application/json",
+    },
+    signal: AbortSignal.timeout(10000),
+  });
+  if (!res.ok) throw new Error(`Yahoo Finance ${res.status}`);
+  return res.json();
+}
+
+/** Get real-time quote for one or more symbols — uses chart endpoint meta */
+export async function yahooQuote(symbols: string[]): Promise<any[]> {
+  const results = await Promise.all(
+    symbols.map(async (sym) => {
+      try {
+        const data = await yfGet(`${YF_CHART}/${sym.toUpperCase()}?range=5d&interval=1d&includePrePost=false`);
+        const result = data?.chart?.result?.[0];
+        if (!result) return null;
+        const meta = result.meta ?? {};
+        const closes: number[] = (result.indicators?.quote?.[0]?.close ?? []).filter((p: any) => p != null);
+        const volumes: number[] = (result.indicators?.quote?.[0]?.volume ?? []).filter((v: any) => v != null);
+        const prevClose = meta.chartPreviousClose ?? meta.previousClose ?? (closes.length > 1 ? closes[closes.length - 2] : 0);
+        const price = meta.regularMarketPrice ?? (closes.length > 0 ? closes[closes.length - 1] : 0);
+        const change = prevClose > 0 ? price - prevClose : 0;
+        const changePct = prevClose > 0 ? (change / prevClose) * 100 : 0;
+
+        return {
+          symbol: meta.symbol ?? sym.toUpperCase(),
+          name: meta.shortName ?? meta.longName ?? sym.toUpperCase(),
+          price: +price.toFixed(2),
+          change: +change.toFixed(2),
+          changePct: +changePct.toFixed(2),
+          previousClose: +prevClose.toFixed(2),
+          open: meta.regularMarketOpen ?? 0,
+          dayHigh: meta.regularMarketDayHigh ?? meta.dayHigh ?? 0,
+          dayLow: meta.regularMarketDayLow ?? meta.dayLow ?? 0,
+          volume: meta.regularMarketVolume ?? (volumes.length > 0 ? volumes[volumes.length - 1] : 0),
+          avgVolume: meta.averageDailyVolume3Month ?? 0,
+          marketCap: meta.marketCap ?? 0,
+          peRatio: meta.trailingPE ?? null,
+          forwardPE: meta.forwardPE ?? null,
+          dividendYield: meta.dividendYield ?? null,
+          fiftyTwoWeekHigh: meta.fiftyTwoWeekHigh ?? null,
+          fiftyTwoWeekLow: meta.fiftyTwoWeekLow ?? null,
+          fiftyDayAvg: meta.fiftyDayAverage ?? null,
+          twoHundredDayAvg: meta.twoHundredDayAverage ?? null,
+          beta: meta.beta ?? null,
+          exchange: meta.exchangeName ?? meta.exchange ?? "",
+          quoteType: meta.instrumentType ?? "",
+          currency: meta.currency ?? "USD",
+          marketState: meta.marketState ?? "CLOSED",
+        };
+      } catch {
+        return { symbol: sym.toUpperCase(), name: sym.toUpperCase(), price: 0, error: "Failed to fetch" };
+      }
+    })
+  );
+  return results.filter(Boolean) as any[];
+}
+
+/** Get price history (OHLCV) for a symbol */
+export async function yahooChart(symbol: string, range = "1mo", interval = "1d"): Promise<any> {
+  const data = await yfGet(`${YF_CHART}/${symbol.toUpperCase()}?range=${range}&interval=${interval}&includePrePost=false`);
+  const result = data?.chart?.result?.[0];
+  if (!result) throw new Error(`No chart data for ${symbol}`);
+
+  const timestamps = result.timestamp ?? [];
+  const quote = result.indicators?.quote?.[0] ?? {};
+  const closes: number[] = quote.close ?? [];
+  const opens: number[] = quote.open ?? [];
+  const highs: number[] = quote.high ?? [];
+  const lows: number[] = quote.low ?? [];
+  const volumes: number[] = quote.volume ?? [];
+
+  const meta = result.meta ?? {};
+  const prices = closes.filter((p: any) => p !== null && p !== undefined);
+
+  return {
+    symbol: meta.symbol ?? symbol.toUpperCase(),
+    name: meta.shortName ?? meta.longName ?? symbol,
+    currency: meta.currency ?? "USD",
+    exchange: meta.exchangeName ?? "",
+    range, interval,
+    dataPoints: prices.length,
+    current: prices.length > 0 ? +prices[prices.length - 1].toFixed(2) : null,
+    high: prices.length > 0 ? +Math.max(...prices).toFixed(2) : null,
+    low: prices.length > 0 ? +Math.min(...prices).toFixed(2) : null,
+    change: prices.length > 1 ? +((prices[prices.length - 1] - prices[0]) / prices[0]).toFixed(4) : null,
+    priceHistory: timestamps.map((t: number, i: number) => ({
+      t, p: closes[i], o: opens[i], h: highs[i], l: lows[i], v: volumes[i],
+    })).filter((p: any) => p.p !== null && p.p !== undefined),
+  };
+}
+
+/** Search for tickers */
+export async function yahooSearch(query: string, limit = 8): Promise<any[]> {
+  const data = await yfGet(`${YF_SEARCH}?q=${encodeURIComponent(query)}&quotesCount=${limit}&newsCount=0`);
+  const quotes = data?.quotes ?? [];
+
+  return quotes.map((q: any) => ({
+    symbol: q.symbol,
+    name: q.shortname ?? q.longname ?? q.symbol,
+    type: q.quoteType ?? "",
+    exchange: q.exchange ?? "",
+    sector: q.sector ?? "",
+    industry: q.industry ?? "",
+  }));
+}