agentbnb 5.1.0 → 5.1.1

package/skills/deep-stock-analyst/src/analysis/technicals.ts

@@ -0,0 +1,318 @@
+import type {
+  AVDailyPrice,
+  AVRSIEntry,
+  AVMACDEntry,
+  AVBBandsEntry,
+  AVStochEntry,
+  AVADXEntry,
+} from '../api/types.js';
+import { calcSMA, calcAvgVolume, formatNumber, mapRange, weightedAvg, sp } from './utils.js';
+
+export interface TechnicalSignal {
+  type: 'bullish' | 'bearish' | 'neutral';
+  name: string;
+  strength: number; // 1–5
+  description: string;
+  detected_at: string;
+}
+
+export interface TechnicalScore {
+  trend_score: number;
+  momentum_score: number;
+  volatility_score: number;
+  strength_score: number;
+  composite: number;
+  regime: 'strong_uptrend' | 'uptrend' | 'consolidation' | 'downtrend' | 'strong_downtrend';
+  signals: TechnicalSignal[];
+  raw: {
+    rsi: number;
+    macdHist: number;
+    adx: number;
+    bbPosition: number;
+    bandWidth: number;
+    price: number;
+    sma20: number;
+    sma50: number;
+    sma200: number;
+  };
+}
+
+function calcSMAAlignment(
+  price: number,
+  sma20: number,
+  sma50: number,
+  sma100: number,
+  sma200: number,
+): number {
+  let score = 0;
+  // Perfect bull: price > SMA20 > SMA50 > SMA100 > SMA200 = 100
+  if (price > sma20) score += 25;
+  if (sma20 > sma50) score += 25;
+  if (sma50 > sma100) score += 25;
+  if (sma100 > sma200) score += 25;
+  return score;
+}
+
+function detectRSIDivergence(
+  daily: AVDailyPrice[],
+  rsi: AVRSIEntry[],
+  lookback: number,
+): TechnicalSignal | null {
+  if (daily.length < lookback || rsi.length < lookback) return null;
+
+  // Check last `lookback` bars for price making new high but RSI declining (bearish divergence)
+  // or price making new low but RSI rising (bullish divergence)
+  const prices = daily.slice(0, lookback).map((d) => sp(d.close));
+  const rsiVals = rsi.slice(0, lookback).map((r) => sp(r.RSI));
+
+  const priceMin = Math.min(...prices);
+  const priceMax = Math.max(...prices);
+  const rsiMin = Math.min(...rsiVals);
+  const rsiMax = Math.max(...rsiVals);
+
+  const latestPrice = prices[0] ?? 0;
+  const latestRSI = rsiVals[0] ?? 50;
+
+  // Bullish divergence: price near low but RSI well above its low
+  if (
+    latestPrice <= priceMin * 1.02 &&
+    latestRSI >= rsiMin * 1.15 &&
+    latestRSI < 50
+  ) {
+    return {
+      type: 'bullish',
+      name: 'RSI Bullish Divergence',
+      strength: 4,
+      description: `Price near ${lookback}-day low but RSI (${latestRSI.toFixed(1)}) is diverging upward`,
+      detected_at: daily[0]?.date ?? '',
+    };
+  }
+
+  // Bearish divergence: price near high but RSI well below its high
+  if (
+    latestPrice >= priceMax * 0.98 &&
+    latestRSI <= rsiMax * 0.85 &&
+    latestRSI > 50
+  ) {
+    return {
+      type: 'bearish',
+      name: 'RSI Bearish Divergence',
+      strength: 4,
+      description: `Price near ${lookback}-day high but RSI (${latestRSI.toFixed(1)}) is diverging downward`,
+      detected_at: daily[0]?.date ?? '',
+    };
+  }
+
+  return null;
+}
+
+function crossedAbove(
+  daily: AVDailyPrice[],
+  fastPeriod: number,
+  slowPeriod: number,
+  withinDays: number,
+): boolean {
+  for (let i = 0; i < withinDays; i++) {
+    const slice = daily.slice(i);
+    const fastNow = calcSMA(slice, fastPeriod);
+    const slowNow = calcSMA(slice, slowPeriod);
+    const fastPrev = calcSMA(daily.slice(i + 1), fastPeriod);
+    const slowPrev = calcSMA(daily.slice(i + 1), slowPeriod);
+    if (fastNow > slowNow && fastPrev <= slowPrev) return true;
+  }
+  return false;
+}
+
+function crossedBelow(
+  daily: AVDailyPrice[],
+  fastPeriod: number,
+  slowPeriod: number,
+  withinDays: number,
+): boolean {
+  for (let i = 0; i < withinDays; i++) {
+    const slice = daily.slice(i);
+    const fastNow = calcSMA(slice, fastPeriod);
+    const slowNow = calcSMA(slice, slowPeriod);
+    const fastPrev = calcSMA(daily.slice(i + 1), fastPeriod);
+    const slowPrev = calcSMA(daily.slice(i + 1), slowPeriod);
+    if (fastNow < slowNow && fastPrev >= slowPrev) return true;
+  }
+  return false;
+}
+
+function determineRegime(
+  composite: number,
+  trendScore: number,
+  strengthScore: number,
+): TechnicalScore['regime'] {
+  if (composite > 80 && strengthScore > 70) return 'strong_uptrend';
+  if (composite > 60) return 'uptrend';
+  if (composite > 40) return 'consolidation';
+  if (composite > 20 && strengthScore > 70) return 'strong_downtrend';
+  return 'downtrend';
+}
+
+export function analyzeTechnicals(
+  daily: AVDailyPrice[],
+  rsi: AVRSIEntry[],
+  macd: AVMACDEntry[],
+  bbands: AVBBandsEntry[],
+  stoch: AVStochEntry[],
+  adx: AVADXEntry[],
+): TechnicalScore {
+  if (daily.length === 0) {
+    return {
+      trend_score: 50, momentum_score: 50, volatility_score: 50, strength_score: 50,
+      composite: 50, regime: 'consolidation', signals: [],
+      raw: { rsi: 50, macdHist: 0, adx: 20, bbPosition: 0.5, bandWidth: 0.05, price: 0, sma20: 0, sma50: 0, sma200: 0 },
+    };
+  }
+
+  const price = sp(daily[0]?.close);
+
+  // === Trend Score: SMA alignment ===
+  const sma20 = calcSMA(daily, 20);
+  const sma50 = calcSMA(daily, 50);
+  const sma100 = calcSMA(daily, 100);
+  const sma200 = calcSMA(daily, 200);
+  const trend_score = calcSMAAlignment(price, sma20, sma50, sma100, sma200);
+
+  // === Momentum Score: RSI + MACD ===
+  const latestRSI = sp(rsi[0]?.RSI ?? '50');
+  const macdHist = sp(macd[0]?.MACD_Hist ?? '0');
+
+  // RSI: oversold (<30) = bullish setup; overbought (>70) = bearish
+  const rsi_component =
+    latestRSI < 30 ? 80
+      : latestRSI > 70 ? 30
+        : mapRange(latestRSI, 30, 70, 40, 70);
+
+  // MACD histogram positive and growing = bullish momentum
+  const macd_component =
+    macdHist > 0
+      ? mapRange(macdHist, 0, 2, 50, 90)
+      : mapRange(macdHist, -2, 0, 10, 50);
+
+  const momentum_score = rsi_component * 0.5 + macd_component * 0.5;
+
+  // === Volatility Score: Bollinger position ===
+  const upperBand = sp(bbands[0]?.['Real Upper Band'] ?? '0');
+  const lowerBand = sp(bbands[0]?.['Real Lower Band'] ?? '0');
+  const middleBand = sp(bbands[0]?.['Real Middle Band'] ?? '0');
+  const bandRange = upperBand - lowerBand;
+  const bandWidth = middleBand > 0 ? bandRange / middleBand : 0;
+  const bbPosition = bandRange > 0 ? (price - lowerBand) / bandRange : 0.5;
+  const volatility_score = bbPosition * 100;
+
+  // === Strength Score: ADX ===
+  const latestADX = sp(adx[0]?.ADX ?? '20');
+  const strength_score = mapRange(latestADX, 10, 50, 0, 100);
+
+  // === Signal Detection ===
+  const signals: TechnicalSignal[] = [];
+  const today = daily[0]?.date ?? '';
+
+  // Golden Cross / Death Cross (SMA50 vs SMA200)
+  if (crossedAbove(daily, 50, 200, 5)) {
+    signals.push({
+      type: 'bullish', name: 'Golden Cross', strength: 5,
+      description: 'SMA50 crossed above SMA200 within last 5 trading days',
+      detected_at: today,
+    });
+  }
+  if (crossedBelow(daily, 50, 200, 5)) {
+    signals.push({
+      type: 'bearish', name: 'Death Cross', strength: 5,
+      description: 'SMA50 crossed below SMA200 within last 5 trading days',
+      detected_at: today,
+    });
+  }
+
+  // RSI Divergence
+  const rsiDiv = detectRSIDivergence(daily, rsi, 20);
+  if (rsiDiv) signals.push(rsiDiv);
+
+  // MACD Bullish Crossover (hist went positive)
+  const prevMacdHist = sp(macd[1]?.MACD_Hist ?? '0');
+  if (macdHist > 0 && prevMacdHist < 0) {
+    signals.push({
+      type: 'bullish', name: 'MACD Bullish Crossover', strength: 3,
+      description: 'MACD crossed above signal line',
+      detected_at: today,
+    });
+  }
+  if (macdHist < 0 && prevMacdHist > 0) {
+    signals.push({
+      type: 'bearish', name: 'MACD Bearish Crossover', strength: 3,
+      description: 'MACD crossed below signal line',
+      detected_at: today,
+    });
+  }
+
+  // Bollinger Squeeze (very narrow band → major move incoming)
+  if (bandWidth < 0.05) {
+    signals.push({
+      type: 'neutral', name: 'Bollinger Squeeze', strength: 4,
+      description: `Band width at ${(bandWidth * 100).toFixed(1)}% — extremely compressed. Major move incoming.`,
+      detected_at: today,
+    });
+  }
+
+  // Stochastic oversold reversal
+  const stochK = sp(stoch[0]?.SlowK ?? '50');
+  const stochD = sp(stoch[0]?.SlowD ?? '50');
+  const prevStochK = sp(stoch[1]?.SlowK ?? '50');
+  if (stochK < 20 && stochK > stochD && prevStochK <= stochD) {
+    signals.push({
+      type: 'bullish', name: 'Stochastic Oversold Reversal', strength: 3,
+      description: `Stoch K(${stochK.toFixed(1)}) crossing above D(${stochD.toFixed(1)}) in oversold territory`,
+      detected_at: today,
+    });
+  }
+
+  // Volume Spike (2x 20-day average)
+  const avgVol20 = calcAvgVolume(daily, 20);
+  const todayVol = sp(daily[0]?.volume ?? '0');
+  if (avgVol20 > 0 && todayVol > avgVol20 * 2) {
+    signals.push({
+      type: 'neutral', name: 'Volume Spike', strength: 4,
+      description: `Volume ${formatNumber(todayVol)} is ${(todayVol / avgVol20).toFixed(1)}x the 20-day average`,
+      detected_at: today,
+    });
+  }
+
+  // Price above/below 200 SMA
+  if (sma200 > 0) {
+    if (price > sma200 * 1.10) {
+      signals.push({
+        type: 'bullish', name: 'Strong Uptrend', strength: 2,
+        description: `Price is ${(((price / sma200) - 1) * 100).toFixed(1)}% above 200-day SMA`,
+        detected_at: today,
+      });
+    } else if (price < sma200 * 0.90) {
+      signals.push({
+        type: 'bearish', name: 'Strong Downtrend', strength: 2,
+        description: `Price is ${(((sma200 / price) - 1) * 100).toFixed(1)}% below 200-day SMA`,
+        detected_at: today,
+      });
+    }
+  }
+
+  const composite = weightedAvg([
+    [trend_score, 0.30],
+    [momentum_score, 0.30],
+    [volatility_score, 0.15],
+    [strength_score, 0.25],
+  ]);
+
+  return {
+    trend_score,
+    momentum_score,
+    volatility_score,
+    strength_score,
+    composite,
+    regime: determineRegime(composite, trend_score, strength_score),
+    signals,
+    raw: { rsi: latestRSI, macdHist, adx: latestADX, bbPosition, bandWidth, price, sma20, sma50, sma200 },
+  };
+}

package/skills/deep-stock-analyst/src/analysis/utils.ts

@@ -0,0 +1,137 @@
+/** Shared math utilities — all pure functions, no LLM. */
+
+export interface ScoreThresholds {
+  excellent: number;
+  good: number;
+  fair: number;
+  poor: number;
+}
+
+/**
+ * Score a metric where lower is better (e.g. P/E ratio, debt/equity).
+ * Returns 0–100, where 100 = excellent (very cheap / low risk).
+ */
+export function scoreMetric(value: number, t: ScoreThresholds): number {
+  if (isNaN(value) || !isFinite(value)) return 50;
+  if (value <= t.excellent) return 100;
+  if (value <= t.good) return mapRange(value, t.excellent, t.good, 100, 75);
+  if (value <= t.fair) return mapRange(value, t.good, t.fair, 75, 50);
+  if (value <= t.poor) return mapRange(value, t.fair, t.poor, 50, 25);
+  return Math.max(0, 25 - ((value - t.poor) / t.poor) * 25);
+}
+
+/**
+ * Score a metric where higher is better (e.g. gross margin, ROE, FCF yield).
+ * Returns 0–100, where 100 = excellent (high margin / high return).
+ */
+export function scoreMetricInverse(value: number, t: ScoreThresholds): number {
+  if (isNaN(value) || !isFinite(value)) return 50;
+  if (value >= t.excellent) return 100;
+  if (value >= t.good) return mapRange(value, t.good, t.excellent, 75, 100);
+  if (value >= t.fair) return mapRange(value, t.fair, t.good, 50, 75);
+  if (value >= t.poor) return mapRange(value, t.poor, t.fair, 25, 50);
+  return Math.max(0, ((value - t.poor) / t.poor) * 25);
+}
+
+/** Weighted average: [[value, weight], ...] → number */
+export function weightedAvg(pairs: [number, number][]): number {
+  let totalWeight = 0;
+  let totalValue = 0;
+  for (const [val, w] of pairs) {
+    if (!isNaN(val) && isFinite(val)) {
+      totalValue += val * w;
+      totalWeight += w;
+    }
+  }
+  return totalWeight > 0 ? totalValue / totalWeight : 50;
+}
+
+/** Linear interpolation: map x from [inMin,inMax] to [outMin,outMax] */
+export function mapRange(
+  x: number,
+  inMin: number,
+  inMax: number,
+  outMin: number,
+  outMax: number,
+): number {
+  if (inMax === inMin) return (outMin + outMax) / 2;
+  const clamped = Math.max(inMin, Math.min(inMax, x));
+  return outMin + ((clamped - inMin) / (inMax - inMin)) * (outMax - outMin);
+}
+
+/** Simple Moving Average over the last `period` closing prices */
+export function calcSMA(prices: { close: string }[], period: number): number {
+  const slice = prices.slice(0, period);
+  if (slice.length === 0) return 0;
+  const sum = slice.reduce((acc, p) => acc + parseFloat(p.close), 0);
+  return sum / slice.length;
+}
+
+/** Average volume over `period` days */
+export function calcAvgVolume(prices: { volume: string }[], period: number): number {
+  const slice = prices.slice(0, period);
+  if (slice.length === 0) return 0;
+  const sum = slice.reduce((acc, p) => acc + parseFloat(p.volume), 0);
+  return sum / slice.length;
+}
+
+/** Format large numbers: 1234567 → "1.23M" */
+export function formatNumber(n: number): string {
+  if (n >= 1e9) return `${(n / 1e9).toFixed(2)}B`;
+  if (n >= 1e6) return `${(n / 1e6).toFixed(2)}M`;
+  if (n >= 1e3) return `${(n / 1e3).toFixed(1)}K`;
+  return n.toFixed(0);
+}
+
+/** Safe parse: returns NaN-safe float */
+export function sp(v: unknown): number {
+  const n = parseFloat(String(v ?? 'NaN'));
+  return isFinite(n) ? n : 0;
+}
+
+/** YoY growth rate from quarterly reports (Q0 vs Q4) */
+export function calcYoYGrowth(
+  reports: Array<Record<string, string>>,
+  field: string,
+): number {
+  const current = sp(reports[0]?.[field]);
+  const prior = sp(reports[4]?.[field]);
+  if (prior === 0) return 0;
+  return ((current - prior) / Math.abs(prior)) * 100;
+}
+
+/** Score growth rate: 0–100 */
+export function scoreGrowth(pct: number): number {
+  if (pct >= 30) return 100;
+  if (pct >= 15) return mapRange(pct, 15, 30, 70, 100);
+  if (pct >= 5) return mapRange(pct, 5, 15, 50, 70);
+  if (pct >= 0) return mapRange(pct, 0, 5, 40, 50);
+  if (pct >= -10) return mapRange(pct, -10, 0, 20, 40);
+  return Math.max(0, 20 + pct * 2);
+}
+
+/** Score earnings surprise percentage: 0–100 */
+export function scoreSurprise(pct: number): number {
+  if (pct >= 10) return 100;
+  if (pct >= 5) return 80;
+  if (pct >= 0) return 60;
+  if (pct >= -5) return 40;
+  return 20;
+}
+
+/** Count consecutive earnings beats from quarterly earnings array */
+export function countConsecutiveBeats(
+  earnings: Array<{ surprisePercentage: string }>,
+): number {
+  let count = 0;
+  for (const e of earnings) {
+    if (sp(e.surprisePercentage) > 0) count++;
+    else break;
+  }
+  return count;
+}
+
+/** Clamp to [0, 100] */
+export function clamp100(n: number): number {
+  return Math.max(0, Math.min(100, n));
+}

package/skills/deep-stock-analyst/src/analysis/valuation.ts

@@ -0,0 +1,95 @@
+import type { AVOverview } from '../api/types.js';
+import { scoreMetric, scoreMetricInverse, weightedAvg, sp } from './utils.js';
+
+export interface ValuationScore {
+  pe_score: number;
+  ps_score: number;
+  peg_score: number;
+  fcf_yield_score: number;
+  ev_ebitda_score: number;
+  composite: number;
+  verdict: 'undervalued' | 'fair' | 'overvalued' | 'expensive';
+  raw: {
+    pe: number;
+    forwardPE: number;
+    peg: number;
+    ps: number;
+    evEbitda: number;
+    fcfYieldPct: number;
+  };
+}
+
+export function calculateValuation(overview: AVOverview): ValuationScore {
+  const pe = sp(overview.PERatio);
+  const forwardPE = sp(overview.ForwardPE);
+  const peg = sp(overview.PEGRatio);
+  const ps = sp(overview.PriceToSalesRatioTTM);
+  const evEbitda = sp(overview.EVToEBITDA);
+  const marketCap = sp(overview.MarketCapitalization);
+  const ocf = sp(overview.OperatingCashflowTTM);
+
+  // FCF Yield = Operating Cash Flow / Market Cap (as percentage)
+  const fcfYieldPct = marketCap > 0 ? (ocf / marketCap) * 100 : 0;
+
+  // Score each metric: 100 = very cheap, 0 = very expensive
+  // Thresholds calibrated to S&P 500 historical medians
+  const pe_score = scoreMetric(pe > 0 ? pe : forwardPE, {
+    excellent: 12,
+    good: 18,
+    fair: 25,
+    poor: 40,
+  });
+
+  const peg_score = scoreMetric(peg, {
+    excellent: 0.5,
+    good: 1.0,
+    fair: 1.5,
+    poor: 2.5,
+  });
+
+  const fcf_yield_score = scoreMetricInverse(fcfYieldPct, {
+    excellent: 8,
+    good: 5,
+    fair: 3,
+    poor: 1,
+  });
+
+  const ev_ebitda_score = scoreMetric(evEbitda, {
+    excellent: 8,
+    good: 12,
+    fair: 18,
+    poor: 30,
+  });
+
+  const ps_score = scoreMetric(ps, {
+    excellent: 1,
+    good: 3,
+    fair: 6,
+    poor: 12,
+  });
+
+  const composite = weightedAvg([
+    [pe_score, 0.25],
+    [peg_score, 0.20],
+    [fcf_yield_score, 0.25],
+    [ev_ebitda_score, 0.15],
+    [ps_score, 0.15],
+  ]);
+
+  const verdict: ValuationScore['verdict'] =
+    composite > 70 ? 'undervalued'
+      : composite > 50 ? 'fair'
+        : composite > 30 ? 'overvalued'
+          : 'expensive';
+
+  return {
+    pe_score,
+    ps_score,
+    peg_score,
+    fcf_yield_score,
+    ev_ebitda_score,
+    composite,
+    verdict,
+    raw: { pe, forwardPE, peg, ps, evEbitda, fcfYieldPct },
+  };
+}

package/skills/deep-stock-analyst/src/api/alpha-vantage.ts

@@ -0,0 +1,133 @@
+/**
+ * Alpha Vantage API client.
+ * Free key: 25 req/day, 5 req/min → serialize calls with 200ms gap.
+ * Standard analysis = 12 calls.
+ */
+
+import type {
+  AllAVData,
+  AVDailyPrice,
+  AVRSIEntry,
+  AVMACDEntry,
+  AVBBandsEntry,
+  AVStochEntry,
+  AVADXEntry,
+  AVOverview,
+  AVIncomeStatement,
+  AVBalanceSheet,
+  AVCashFlow,
+  AVEarnings,
+  AVNewsSentiment,
+} from './types.js';
+
+const BASE_URL = 'https://www.alphavantage.co/query';
+const RATE_DELAY_MS = 200; // 5 req/min on free key → be conservative
+
+async function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function avFetch(params: Record<string, string>, apiKey: string): Promise<unknown> {
+  const url = new URL(BASE_URL);
+  url.searchParams.set('apikey', apiKey);
+  for (const [k, v] of Object.entries(params)) {
+    url.searchParams.set(k, v);
+  }
+
+  const res = await fetch(url.toString());
+  if (!res.ok) {
+    throw new Error(`Alpha Vantage HTTP ${res.status}: ${url.searchParams.get('function')}`);
+  }
+  const data = await res.json() as Record<string, unknown>;
+
+  // AV returns error messages as JSON object with "Information" or "Note" keys
+  if (typeof data['Information'] === 'string' && data['Information'].includes('rate limit')) {
+    throw new Error(`Alpha Vantage rate limit hit: ${data['Information']}`);
+  }
+  if (typeof data['Note'] === 'string') {
+    throw new Error(`Alpha Vantage note (likely rate limited): ${data['Note']}`);
+  }
+
+  return data;
+}
+
+/** Parse TIME_SERIES_DAILY_ADJUSTED into flat array sorted newest-first */
+function parseDailySeries(raw: unknown): AVDailyPrice[] {
+  const data = raw as Record<string, unknown>;
+  const series = data['Time Series (Daily)'] as Record<string, Record<string, string>> | undefined;
+  if (!series) return [];
+
+  return Object.entries(series)
+    .map(([date, v]) => ({
+      date,
+      open: v['1. open'] ?? '0',
+      high: v['2. high'] ?? '0',
+      low: v['3. low'] ?? '0',
+      close: v['4. close'] ?? '0',
+      adjustedClose: v['5. adjusted close'] ?? '0',
+      volume: v['6. volume'] ?? '0',
+      dividendAmount: v['7. dividend amount'] ?? '0',
+      splitCoefficient: v['8. split coefficient'] ?? '1',
+    }))
+    .sort((a, b) => b.date.localeCompare(a.date)); // newest first
+}
+
+/** Parse a technical indicator response into flat array sorted newest-first */
+function parseIndicator<T>(raw: unknown, key: string): T[] {
+  const data = raw as Record<string, unknown>;
+  const series = data[key] as Record<string, T> | undefined;
+  if (!series) return [];
+  return Object.entries(series)
+    .sort(([a], [b]) => b.localeCompare(a)) // newest first
+    .map(([, v]) => v);
+}
+
+/**
+ * Fetch all 12 Alpha Vantage endpoints for a standard analysis.
+ * Calls are serialized with a short delay to avoid rate limits.
+ */
+export async function fetchAllData(ticker: string, apiKey: string): Promise<AllAVData> {
+  const t = ticker.toUpperCase();
+  const results: unknown[] = [];
+
+  const calls: Array<Record<string, string>> = [
+    { function: 'OVERVIEW', symbol: t },
+    { function: 'INCOME_STATEMENT', symbol: t },
+    { function: 'BALANCE_SHEET', symbol: t },
+    { function: 'CASH_FLOW', symbol: t },
+    { function: 'EARNINGS', symbol: t },
+    { function: 'TIME_SERIES_DAILY_ADJUSTED', symbol: t, outputsize: 'full' },
+    { function: 'RSI', symbol: t, interval: 'daily', time_period: '14', series_type: 'close' },
+    { function: 'MACD', symbol: t, interval: 'daily', series_type: 'close' },
+    { function: 'BBANDS', symbol: t, interval: 'daily', time_period: '20', series_type: 'close' },
+    { function: 'STOCH', symbol: t, interval: 'daily' },
+    { function: 'ADX', symbol: t, interval: 'daily', time_period: '14' },
+    { function: 'NEWS_SENTIMENT', tickers: t, limit: '50', sort: 'LATEST' },
+  ];
+
+  for (let i = 0; i < calls.length; i++) {
+    const call = calls[i];
+    if (i > 0) await sleep(RATE_DELAY_MS);
+    results.push(await avFetch(call!, apiKey));
+  }
+
+  const [
+    overview, income, balance, cashflow, earnings,
+    dailyRaw, rsiRaw, macdRaw, bbandsRaw, stochRaw, adxRaw, newsRaw,
+  ] = results;
+
+  return {
+    overview: overview as AVOverview,
+    income: income as AVIncomeStatement,
+    balance: balance as AVBalanceSheet,
+    cashflow: cashflow as AVCashFlow,
+    earnings: earnings as AVEarnings,
+    daily: parseDailySeries(dailyRaw),
+    rsi: parseIndicator<AVRSIEntry>(rsiRaw, 'Technical Analysis: RSI'),
+    macd: parseIndicator<AVMACDEntry>(macdRaw, 'Technical Analysis: MACD'),
+    bbands: parseIndicator<AVBBandsEntry>(bbandsRaw, 'Technical Analysis: BBANDS'),
+    stoch: parseIndicator<AVStochEntry>(stochRaw, 'Technical Analysis: STOCH'),
+    adx: parseIndicator<AVADXEntry>(adxRaw, 'Technical Analysis: ADX'),
+    news: newsRaw as AVNewsSentiment,
+  };
+}