Build an LLM-Powered Stock Analyzer

// src/finance/analyzer.ts — LLM-powered stock analysis with multi-source data fusion
import { pool } from "../db";
import { Redis } from "ioredis";
import { randomBytes } from "node:crypto";

const redis = new Redis(process.env.REDIS_URL!);

interface StockAnalysis {
  id: string;
  ticker: string;
  date: string;
  priceData: PriceData;
  financials: FinancialData;
  newsAnalysis: NewsAnalysis;
  technicalSignals: TechnicalSignal[];
  aiInsight: AIInsight;
  riskScore: number;
  overallSignal: "strong_buy" | "buy" | "hold" | "sell" | "strong_sell";
}

interface PriceData {
  current: number;
  open: number;
  high: number;
  low: number;
  volume: number;
  change: number;
  changePercent: number;
  fiftyDayMA: number;
  twoHundredDayMA: number;
  rsi: number;
}

interface FinancialData {
  marketCap: number;
  peRatio: number;
  forwardPE: number;
  pegRatio: number;
  debtToEquity: number;
  freeCashFlow: number;
  revenueGrowth: number;
  earningsGrowth: number;
  profitMargin: number;
  dividendYield: number;
}

interface NewsAnalysis {
  articleCount: number;
  sentimentAvg: number;
  keyTopics: string[];
  criticalEvents: Array<{ title: string; impact: "positive" | "negative" | "neutral"; significance: number }>;
}

interface TechnicalSignal {
  indicator: string;
  value: number;
  signal: "bullish" | "bearish" | "neutral";
  strength: number;
}

interface AIInsight {
  summary: string;
  bullCase: string;
  bearCase: string;
  catalysts: string[];
  risks: string[];
  priceTarget: { low: number; mid: number; high: number };
  timeframe: string;
  confidence: number;
}

// Run full analysis for a ticker
export async function analyzeStock(ticker: string): Promise<StockAnalysis> {
  const id = `sa-${randomBytes(6).toString("hex")}`;

  // Fetch data in parallel
  const [priceData, financials, news] = await Promise.all([
    fetchPriceData(ticker),
    fetchFinancials(ticker),
    fetchNewsAnalysis(ticker),
  ]);

  // Technical analysis
  const technicalSignals = calculateTechnicals(priceData);

  // AI insight generation (in production: calls LLM API)
  const aiInsight = await generateAIInsight(ticker, priceData, financials, news, technicalSignals);

  // Risk scoring (0-100, higher = riskier)
  const riskScore = calculateRisk(financials, priceData, news);

  // Overall signal
  const overallSignal = deriveSignal(technicalSignals, aiInsight, riskScore);

  const analysis: StockAnalysis = {
    id, ticker, date: new Date().toISOString(),
    priceData, financials, newsAnalysis: news,
    technicalSignals, aiInsight, riskScore, overallSignal,
  };

  await pool.query(
    `INSERT INTO stock_analyses (id, ticker, analysis, signal, risk_score, created_at)
     VALUES ($1, $2, $3, $4, $5, NOW())`,
    [id, ticker, JSON.stringify(analysis), overallSignal, riskScore]
  );

  await redis.setex(`stock:analysis:${ticker}`, 3600, JSON.stringify(analysis));
  return analysis;
}

function calculateTechnicals(price: PriceData): TechnicalSignal[] {
  const signals: TechnicalSignal[] = [];

  // RSI
  signals.push({
    indicator: "RSI",
    value: price.rsi,
    signal: price.rsi > 70 ? "bearish" : price.rsi < 30 ? "bullish" : "neutral",
    strength: Math.abs(price.rsi - 50) / 50,
  });

  // Moving average crossover
  const maCross = price.fiftyDayMA > price.twoHundredDayMA;
  signals.push({
    indicator: "MA_Cross",
    value: price.fiftyDayMA / price.twoHundredDayMA,
    signal: maCross ? "bullish" : "bearish",
    strength: Math.abs(price.fiftyDayMA - price.twoHundredDayMA) / price.twoHundredDayMA,
  });

  // Price vs 200-day MA
  const priceVsMA = (price.current - price.twoHundredDayMA) / price.twoHundredDayMA;
  signals.push({
    indicator: "Price_vs_200MA",
    value: priceVsMA,
    signal: priceVsMA > 0.1 ? "bullish" : priceVsMA < -0.1 ? "bearish" : "neutral",
    strength: Math.min(Math.abs(priceVsMA), 1),
  });

  // Volume analysis
  signals.push({
    indicator: "Volume",
    value: price.volume,
    signal: price.volume > 1.5 ? "bullish" : "neutral",
    strength: Math.min(price.volume / 2, 1),
  });

  return signals;
}

function calculateRisk(financials: FinancialData, price: PriceData, news: NewsAnalysis): number {
  let risk = 50;
  if (financials.debtToEquity > 2) risk += 15;
  if (financials.peRatio > 40) risk += 10;
  if (financials.freeCashFlow < 0) risk += 20;
  if (price.rsi > 80) risk += 10;
  if (news.sentimentAvg < -0.3) risk += 15;
  if (news.criticalEvents.some((e) => e.impact === "negative" && e.significance > 0.7)) risk += 10;
  return Math.min(100, Math.max(0, risk));
}

function deriveSignal(technicals: TechnicalSignal[], insight: AIInsight, risk: number): StockAnalysis["overallSignal"] {
  const bullish = technicals.filter((t) => t.signal === "bullish").length;
  const bearish = technicals.filter((t) => t.signal === "bearish").length;
  const techScore = (bullish - bearish) / technicals.length;

  const combined = techScore * 0.3 + (insight.confidence - 0.5) * 0.4 + (1 - risk / 100) * 0.3;

  if (combined > 0.4) return "strong_buy";
  if (combined > 0.15) return "buy";
  if (combined < -0.4) return "strong_sell";
  if (combined < -0.15) return "sell";
  return "hold";
}

async function generateAIInsight(ticker: string, price: PriceData, financials: FinancialData, news: NewsAnalysis, technicals: TechnicalSignal[]): Promise<AIInsight> {
  // In production: calls LLM with all data for analysis
  return {
    summary: `${ticker} shows mixed signals with ${financials.revenueGrowth > 0 ? 'positive' : 'negative'} revenue growth and ${technicals.filter(t => t.signal === 'bullish').length > 2 ? 'bullish' : 'bearish'} technicals.`,
    bullCase: `Revenue growth of ${(financials.revenueGrowth * 100).toFixed(1)}% with improving margins could drive the stock higher.`,
    bearCase: `Elevated P/E of ${financials.peRatio.toFixed(1)} and ${financials.debtToEquity > 1 ? 'high' : 'moderate'} debt levels pose downside risk.`,
    catalysts: ["Earnings beat", "Product launch", "Market expansion"],
    risks: ["Competition", "Regulatory changes", "Economic slowdown"],
    priceTarget: { low: price.current * 0.85, mid: price.current * 1.1, high: price.current * 1.3 },
    timeframe: "6 months",
    confidence: 0.65,
  };
}

async function fetchPriceData(ticker: string): Promise<PriceData> {
  // In production: calls market data API
  return { current: 150, open: 148, high: 152, low: 147, volume: 1200000, change: 2, changePercent: 1.35, fiftyDayMA: 145, twoHundredDayMA: 140, rsi: 55 };
}

async function fetchFinancials(ticker: string): Promise<FinancialData> {
  return { marketCap: 5e9, peRatio: 25, forwardPE: 20, pegRatio: 1.2, debtToEquity: 0.8, freeCashFlow: 200e6, revenueGrowth: 0.15, earningsGrowth: 0.2, profitMargin: 0.12, dividendYield: 0.02 };
}

async function fetchNewsAnalysis(ticker: string): Promise<NewsAnalysis> {
  return { articleCount: 15, sentimentAvg: 0.2, keyTopics: ["earnings", "expansion"], criticalEvents: [] };
}

// Batch analysis for watchlist
export async function analyzeWatchlist(tickers: string[]): Promise<StockAnalysis[]> {
  return Promise.all(tickers.map((t) => analyzeStock(t)));
}