Build an AI Stock Screener

npm install --save-dev prisma@7 tsx typescript @types/node @types/pg
npm install @prisma/client@7 @prisma/adapter-pg pg dotenv @anthropic-ai/sdk
# also set "type": "module" in package.json
echo 'DATABASE_URL="postgresql://user:password@127.0.0.1:5432/screener"' > .env

// prisma.config.ts
import "dotenv/config";
import { defineConfig, env } from "prisma/config";
export default defineConfig({
  schema: "prisma/schema.prisma",
  datasource: { url: env("DATABASE_URL") },
});

// prisma/schema.prisma
generator client {
  provider = "prisma-client"
  output   = "../src/generated/prisma"
}
datasource db {
  provider = "postgresql"
}
model Stock {
  id             String          @id @default(cuid())
  ticker         String          @unique
  name           String
  marketCap      Float?
  peRatio        Float?          // trailing: price / diluted EPS
  revenueGrowth  Float?          // latest 10-K vs prior 10-K, %
  eps            Float?
  lastPrice      Float?
  rsi14          Float?
  sma50          Float?
  sma200         Float?
  aiSummary      String?
  updatedAt      DateTime        @updatedAt
  watchlistItems WatchlistItem[]
  priceAlerts    PriceAlert[]
}
model WatchlistItem {
  id      String   @id @default(cuid())
  userId  String
  stockId String
  addedAt DateTime @default(now())
  stock   Stock    @relation(fields: [stockId], references: [id])
  @@unique([userId, stockId])
}
model PriceAlert {
  id          String  @id @default(cuid())
  userId      String
  stockId     String
  targetPrice Float
  direction   String  // "above" | "below"
  triggered   Boolean @default(false)
  stock       Stock   @relation(fields: [stockId], references: [id])
}

npx prisma migrate dev --name init && npx prisma generate

// lib/edgar.ts — SEC EDGAR is free; it asks for a descriptive User-Agent with a contact address
const UA = process.env.SEC_USER_AGENT ?? 'ScreenerApp you@example.com';
const get = async (url: string) => {
  const res = await fetch(url, { headers: { 'User-Agent': UA } });
  if (!res.ok) throw new Error(`${url} -> ${res.status}`);
  return res.json();
};
let tickerMap: Record<string, { cik_str: number; title: string }> | undefined;
export async function lookupCompany(ticker: string) {
  tickerMap ??= Object.fromEntries(
    Object.values(await get('https://www.sec.gov/files/company_tickers.json')).map((c: any) => [c.ticker, c]),
  );
  const c = tickerMap![ticker.toUpperCase()];
  if (!c) throw new Error(`${ticker} not in SEC ticker list`);
  return { cik: String(c.cik_str).padStart(10, '0'), name: c.title as string };
}
type Fact = { start?: string; end: string; val: number; form: string };
// Annual values from 10-K filings (≈ one-year duration), newest first, one per period end
function annual(facts: any, concepts: string[], unit: string): Fact[] {
  for (const c of concepts) {
    const rows: Fact[] | undefined = facts['us-gaap']?.[c]?.units?.[unit];
    if (!rows) continue;
    const days = (f: Fact) => (+new Date(f.end) - +new Date(f.start!)) / 864e5;
    const byEnd = new Map<string, Fact>();
    for (const f of rows) if (f.form === '10-K' && f.start && days(f) > 350 && days(f) < 380) byEnd.set(f.end, f);
    const out = [...byEnd.values()].sort((a, b) => b.end.localeCompare(a.end));
    if (out.length) return out;
  }
  return [];
}
export async function fetchFundamentals(ticker: string) {
  const { cik, name } = await lookupCompany(ticker);
  const { facts } = await get(`https://data.sec.gov/api/xbrl/companyfacts/CIK${cik}.json`);
  const rev = annual(facts, ['RevenueFromContractWithCustomerExcludingAssessedTax', 'Revenues', 'SalesRevenueNet'], 'USD');
  const eps = annual(facts, ['EarningsPerShareDiluted'], 'USD/shares');
  const shares: Fact[] = facts.dei?.EntityCommonStockSharesOutstanding?.units?.shares ?? [];
  return {
    name,
    revenueGrowth: rev.length >= 2 ? ((rev[0].val - rev[1].val) / Math.abs(rev[1].val)) * 100 : null,
    eps: eps[0]?.val ?? null,
    sharesOutstanding: shares.at(-1)?.val ?? null, // approximate: a company can report several share classes
  };
}

// lib/market-data.ts
import { prisma } from './prisma';
import { fetchFundamentals } from './edgar';
// Yahoo's chart endpoint is unofficial and may change or rate-limit; swap in Alpaca/Polygon for production
export async function fetchCloses(ticker: string): Promise<number[]> {
  const url = `https://query1.finance.yahoo.com/v8/finance/chart/${encodeURIComponent(ticker)}?interval=1d&range=2y`;
  const res = await fetch(url, { headers: { 'User-Agent': 'Mozilla/5.0' } });
  if (!res.ok) throw new Error(`Yahoo ${ticker}: ${res.status}`);
  const data = await res.json();
  const closes: (number | null)[] = data.chart?.result?.[0]?.indicators?.quote?.[0]?.close ?? [];
  return closes.filter((c): c is number => c !== null);
}
export async function updateStockData(ticker: string) {
  const [prices, f] = await Promise.all([fetchCloses(ticker), fetchFundamentals(ticker)]);
  const lastPrice = prices.at(-1) ?? null;
  const data = {
    name: f.name,
    lastPrice,
    eps: f.eps,
    revenueGrowth: f.revenueGrowth,
    peRatio: lastPrice && f.eps && f.eps > 0 ? lastPrice / f.eps : null,
    marketCap: lastPrice && f.sharesOutstanding ? lastPrice * f.sharesOutstanding : null,
  };
  await prisma.stock.upsert({ where: { ticker }, update: data, create: { ticker, ...data } });
  return { ticker, lastPrice, prices };
}

// lib/prisma.ts
import 'dotenv/config';
import { PrismaPg } from '@prisma/adapter-pg';
import { PrismaClient } from '../src/generated/prisma/client';
export const prisma = new PrismaClient({
  adapter: new PrismaPg({ connectionString: process.env.DATABASE_URL }),
});

// lib/technicals.ts
import { prisma } from './prisma';
const sma = (p: number[], n: number) => p.slice(-n).reduce((a, b) => a + b, 0) / Math.min(n, p.length);
// RSI with Wilder's smoothing
function rsi(p: number[], n = 14): number {
  let gain = 0, loss = 0;
  for (let i = 1; i <= n; i++) {
    const d = p[i] - p[i - 1];
    if (d > 0) gain += d; else loss -= d;
  }
  gain /= n; loss /= n;
  for (let i = n + 1; i < p.length; i++) {
    const d = p[i] - p[i - 1];
    gain = (gain * (n - 1) + Math.max(d, 0)) / n;
    loss = (loss * (n - 1) + Math.max(-d, 0)) / n;
  }
  return loss === 0 ? 100 : 100 - 100 / (1 + gain / loss);
}
export async function computeAndStoreTechnicals(ticker: string, prices: number[]) {
  if (prices.length < 200) return; // SMA200 needs 200 closes
  await prisma.stock.update({
    where: { ticker },
    data: { rsi14: rsi(prices), sma50: sma(prices, 50), sma200: sma(prices, 200) },
  });
}

// lib/screener.ts
import { prisma } from './prisma';
export interface ScreenerFilters {
  maxPE?: number; minMarketCapM?: number; maxMarketCapM?: number; // market cap in millions
  minRevenueGrowth?: number; minRSI?: number; maxRSI?: number;
}
export function runScreener(f: ScreenerFilters) {
  const range = (min?: number, max?: number) =>
    min === undefined && max === undefined ? undefined : { gte: min, lte: max };
  return prisma.stock.findMany({
    where: {
      peRatio: f.maxPE === undefined ? undefined : { gt: 0, lte: f.maxPE },
      marketCap: range(f.minMarketCapM && f.minMarketCapM * 1e6, f.maxMarketCapM && f.maxMarketCapM * 1e6),
      revenueGrowth: range(f.minRevenueGrowth),
      rsi14: range(f.minRSI, f.maxRSI),
    },
    orderBy: { revenueGrowth: 'desc' },
    take: 20,
  });
}

// lib/ai-analysis.ts
import Anthropic from '@anthropic-ai/sdk';
import { prisma } from './prisma';
const anthropic = new Anthropic(); // reads ANTHROPIC_API_KEY
export async function analyzeStock(ticker: string) {
  const s = await prisma.stock.findUnique({ where: { ticker } });
  if (!s) throw new Error(`Stock ${ticker} not found`);
  const response = await anthropic.messages.create({
    model: 'claude-sonnet-5-5',
    max_tokens: 600,
    messages: [{
      role: 'user',
      content: `Analyze this stock for a growth-focused retail investor in 3-4 sentences. Use only these figures (trailing P/E, market cap in USD, revenue growth % from the latest 10-K, diluted EPS, RSI14, price vs SMA200); do not invent facts.
${JSON.stringify({ ticker, pe: s.peRatio, marketCap: s.marketCap, revenueGrowthPct: s.revenueGrowth, eps: s.eps, rsi14: s.rsi14, aboveSma200: s.lastPrice && s.sma200 ? s.lastPrice > s.sma200 : null})}
Reply with only JSON: {"summary": "...", "bullCase": "...", "bearCase": "...", "verdict": "buy|hold|watch|avoid"}`,
    }],
  });
  const block = response.content[0];
  const text = block?.type === 'text' ? block.text : '';
  const match = text.match(/\{[\s\S]*\}/);
  const analysis = match ? JSON.parse(match[0]) : { summary: text };
  await prisma.stock.update({ where: { ticker }, data: { aiSummary: analysis.summary } });
  return analysis;
}

// lib/price-alerts.ts
import { prisma } from './prisma';
export async function checkPriceAlerts() {
  const alerts = await prisma.priceAlert.findMany({ where: { triggered: false }, include: { stock: true } });
  const fired = alerts.filter(({ stock: { lastPrice: p }, direction, targetPrice }) =>
    p !== null && (direction === 'above' ? p >= targetPrice : p <= targetPrice));
  for (const a of fired) await prisma.priceAlert.update({ where: { id: a.id }, data: { triggered: true } });
  return fired.map((a) => ({ ticker: a.stock.ticker, price: a.stock.lastPrice, target: a.targetPrice }));
}