agentbnb 5.1.0 → 5.1.2

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,
+  };
+}

package/skills/deep-stock-analyst/src/api/types.ts

@@ -0,0 +1,238 @@
+/** Alpha Vantage API response types */
+
+export interface AVOverview {
+  Symbol: string;
+  Name: string;
+  Description: string;
+  Sector: string;
+  Industry: string;
+  MarketCapitalization: string;
+  PERatio: string;
+  ForwardPE: string;
+  PEGRatio: string;
+  PriceToSalesRatioTTM: string;
+  PriceToBookRatio: string;
+  EVToEBITDA: string;
+  EVToRevenue: string;
+  GrossProfitTTM: string;
+  RevenueTTM: string;
+  OperatingMarginTTM: string;
+  ProfitMargin: string;
+  ReturnOnEquityTTM: string;
+  ReturnOnAssetsTTM: string;
+  DebtToEquity: string;
+  CurrentRatio: string;
+  QuickRatio: string;
+  OperatingCashflowTTM: string;
+  RevenuePerShareTTM: string;
+  EPS: string;
+  DilutedEPSTTM: string;
+  Beta: string;
+  '52WeekHigh': string;
+  '52WeekLow': string;
+  '50DayMovingAverage': string;
+  '200DayMovingAverage': string;
+  SharesOutstanding: string;
+  DividendYield: string;
+  ExDividendDate: string;
+  AnalystTargetPrice: string;
+  AnalystRatingStrongBuy: string;
+  AnalystRatingBuy: string;
+  AnalystRatingHold: string;
+  AnalystRatingSell: string;
+  AnalystRatingStrongSell: string;
+}
+
+export interface AVQuarterlyReport {
+  fiscalDateEnding: string;
+  reportedCurrency: string;
+  totalRevenue: string;
+  netIncome: string;
+  grossProfit: string;
+  ebit: string;
+  ebitda: string;
+  operatingIncome: string;
+  interestExpense: string;
+  researchAndDevelopment: string;
+  sellingGeneralAndAdministrative: string;
+}
+
+export interface AVAnnualReport {
+  fiscalDateEnding: string;
+  reportedCurrency: string;
+  totalRevenue: string;
+  netIncome: string;
+  grossProfit: string;
+  ebit: string;
+  ebitda: string;
+  operatingIncome: string;
+  interestExpense: string;
+  researchAndDevelopment: string;
+  sellingGeneralAndAdministrative: string;
+}
+
+export interface AVIncomeStatement {
+  symbol: string;
+  annualReports: AVAnnualReport[];
+  quarterlyReports: AVQuarterlyReport[];
+}
+
+export interface AVBalanceSheetReport {
+  fiscalDateEnding: string;
+  reportedCurrency: string;
+  totalAssets: string;
+  totalCurrentAssets: string;
+  totalNonCurrentAssets: string;
+  totalLiabilities: string;
+  totalCurrentLiabilities: string;
+  totalNonCurrentLiabilities: string;
+  totalShareholderEquity: string;
+  longTermDebt: string;
+  shortTermDebt: string;
+  cashAndCashEquivalentsAtCarryingValue: string;
+  currentNetReceivables: string;
+  inventory: string;
+}
+
+export interface AVBalanceSheet {
+  symbol: string;
+  annualReports: AVBalanceSheetReport[];
+  quarterlyReports: AVBalanceSheetReport[];
+}
+
+export interface AVCashFlowReport {
+  fiscalDateEnding: string;
+  reportedCurrency: string;
+  operatingCashflow: string;
+  capitalExpenditures: string;
+  cashflowFromInvestment: string;
+  cashflowFromFinancing: string;
+  netIncome: string;
+  dividendPayout: string;
+  changeInOperatingAssets: string;
+  changeInOperatingLiabilities: string;
+}
+
+export interface AVCashFlow {
+  symbol: string;
+  annualReports: AVCashFlowReport[];
+  quarterlyReports: AVCashFlowReport[];
+}
+
+export interface AVQuarterlyEarning {
+  fiscalDateEnding: string;
+  reportedDate: string;
+  reportedEPS: string;
+  estimatedEPS: string;
+  surprise: string;
+  surprisePercentage: string;
+}
+
+export interface AVEarnings {
+  symbol: string;
+  quarterlyEarnings: AVQuarterlyEarning[];
+  annualEarnings: Array<{ fiscalDateEnding: string; reportedEPS: string }>;
+}
+
+export interface AVDailyPrice {
+  date: string;
+  open: string;
+  high: string;
+  low: string;
+  close: string;
+  adjustedClose: string;
+  volume: string;
+  dividendAmount: string;
+  splitCoefficient: string;
+}
+
+export interface AVDailyTimeSeries {
+  'Meta Data': {
+    '1. Information': string;
+    '2. Symbol': string;
+    '3. Last Refreshed': string;
+    '4. Output Size': string;
+    '5. Time Zone': string;
+  };
+  'Time Series (Daily)': Record<string, {
+    '1. open': string;
+    '2. high': string;
+    '3. low': string;
+    '4. close': string;
+    '5. adjusted close': string;
+    '6. volume': string;
+    '7. dividend amount': string;
+    '8. split coefficient': string;
+  }>;
+}
+
+export interface AVRSIEntry {
+  RSI: string;
+}
+
+export interface AVMACDEntry {
+  MACD: string;
+  MACD_Hist: string;
+  MACD_Signal: string;
+}
+
+export interface AVBBandsEntry {
+  'Real Upper Band': string;
+  'Real Middle Band': string;
+  'Real Lower Band': string;
+}
+
+export interface AVStochEntry {
+  SlowK: string;
+  SlowD: string;
+}
+
+export interface AVADXEntry {
+  ADX: string;
+}
+
+export interface AVIndicatorResponse<T> {
+  'Meta Data': Record<string, string>;
+  'Technical Analysis: RSI'?: Record<string, T>;
+  'Technical Analysis: MACD'?: Record<string, T>;
+  'Technical Analysis: BBANDS'?: Record<string, T>;
+  'Technical Analysis: STOCH'?: Record<string, T>;
+  'Technical Analysis: ADX'?: Record<string, T>;
+}
+
+export interface AVNewsTickerSentiment {
+  ticker: string;
+  relevance_score: string;
+  ticker_sentiment_score: string;
+  ticker_sentiment_label: string;
+}
+
+export interface AVNewsArticle {
+  title: string;
+  url: string;
+  time_published: string;
+  summary: string;
+  overall_sentiment_score: string;
+  overall_sentiment_label: string;
+  ticker_sentiment: AVNewsTickerSentiment[];
+  topics: Array<{ topic: string; relevance_score: string }>;
+}
+
+export interface AVNewsSentiment {
+  feed: AVNewsArticle[];
+}
+
+export interface AllAVData {
+  overview: AVOverview;
+  income: AVIncomeStatement;
+  balance: AVBalanceSheet;
+  cashflow: AVCashFlow;
+  earnings: AVEarnings;
+  daily: AVDailyPrice[];
+  rsi: AVRSIEntry[];
+  macd: AVMACDEntry[];
+  bbands: AVBBandsEntry[];
+  stoch: AVStochEntry[];
+  adx: AVADXEntry[];
+  news: AVNewsSentiment;
+}

package/skills/deep-stock-analyst/src/index.ts

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+/**
+ * CLI entry point for deep-stock-analyst.
+ * Usage: node dist/index.js --ticker IBM --depth standard --style hybrid
+ * Output: JSON to stdout (genesis-bot reads this)
+ *
+ * Exit codes:
+ *   0 = success, JSON on stdout
+ *   1 = invalid args or API error
+ *   2 = rate limit / daily limit reached
+ */
+
+import { runAnalysis } from './orchestrator.js';
+import type { InvestmentStyle } from './analysis/signal.js';
+
+function parseArgs(): { ticker: string; depth: string; style: InvestmentStyle } | null {
+  const args = process.argv.slice(2);
+  const get = (flag: string): string | undefined => {
+    const i = args.indexOf(flag);
+    return i >= 0 ? args[i + 1] : undefined;
+  };
+
+  const ticker = get('--ticker');
+  const depth = get('--depth') ?? 'standard';
+  const style = (get('--style') ?? 'hybrid') as InvestmentStyle;
+
+  if (!ticker) {
+    console.error('Usage: node dist/index.js --ticker <TICKER> [--depth quick|standard|deep] [--style growth|value|momentum|hybrid]');
+    return null;
+  }
+
+  const validDepths = ['quick', 'standard', 'deep'];
+  const validStyles = ['growth', 'value', 'momentum', 'hybrid'];
+
+  if (!validDepths.includes(depth)) {
+    console.error(`Invalid depth: ${depth}. Must be one of: ${validDepths.join(', ')}`);
+    return null;
+  }
+  if (!validStyles.includes(style)) {
+    console.error(`Invalid style: ${style}. Must be one of: ${validStyles.join(', ')}`);
+    return null;
+  }
+
+  return { ticker, depth, style };
+}
+
+async function main(): Promise<void> {
+  const args = parseArgs();
+  if (!args) {
+    process.exit(1);
+  }
+
+  const apiKey = process.env['ALPHA_VANTAGE_API_KEY'];
+  if (!apiKey) {
+    console.error('Missing ALPHA_VANTAGE_API_KEY environment variable');
+    process.exit(1);
+  }
+
+  try {
+    const result = await runAnalysis({
+      ticker: args.ticker,
+      depth: args.depth as 'quick' | 'standard' | 'deep',
+      style: args.style,
+      apiKey,
+    });
+
+    // Output clean JSON to stdout (genesis-bot reads this)
+    process.stdout.write(JSON.stringify(result, null, 2));
+    process.stdout.write('\n');
+    process.exit(0);
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : String(err);
+
+    if (msg.includes('rate limit')) {
+      console.error(`[rate-limit] ${msg}`);
+      process.exit(2);
+    }
+
+    console.error(`[error] ${msg}`);
+    process.exit(1);
+  }
+}
+
+main();

package/skills/deep-stock-analyst/src/llm/thesis.ts

@@ -0,0 +1,101 @@
+/**
+ * Thesis generation via Gemini Flash.
+ * Uses genesis-bot's existing GOOGLE_API_KEY.
+ * Input: pre-computed CompositeSignal + raw data → structured thesis JSON.
+ * LLM interprets numbers — does NOT recalculate anything.
+ */
+
+import { GoogleGenerativeAI } from '@google/generative-ai';
+import type { ValuationScore } from '../analysis/valuation.js';
+import type { TechnicalScore } from '../analysis/technicals.js';
+import type { FinancialHealth } from '../analysis/financial-health.js';
+import type { SentimentScore } from '../analysis/sentiment.js';
+import type { CompositeSignal } from '../analysis/signal.js';
+import type { AVOverview } from '../api/types.js';
+
+export interface InvestmentThesis {
+  bull_case: string;
+  bear_case: string;
+  catalysts: string[];
+  risks: string[];
+  time_horizon: 'short_term' | 'medium_term' | 'long_term';
+  entry_strategy: string;
+}
+
+const FALLBACK_THESIS: InvestmentThesis = {
+  bull_case: 'Quantitative metrics indicate favorable risk/reward. See scores for details.',
+  bear_case: 'Monitor red flags and technical weakness signals before committing capital.',
+  catalysts: ['Earnings surprise', 'Sector rotation', 'Macro tailwinds'],
+  risks: ['Market volatility', 'Rate sensitivity', 'Execution risk'],
+  time_horizon: 'medium_term',
+  entry_strategy: 'Consider scaling in near support levels identified in technical analysis.',
+};
+
+export async function generateThesis(
+  ticker: string,
+  overview: AVOverview,
+  composite: CompositeSignal,
+  valuation: ValuationScore,
+  technicals: TechnicalScore,
+  financials: FinancialHealth,
+  sentiment: SentimentScore,
+): Promise<InvestmentThesis> {
+  const apiKey = process.env['GOOGLE_API_KEY'];
+  if (!apiKey) {
+    console.error('[thesis] GOOGLE_API_KEY not set — returning fallback thesis');
+    return FALLBACK_THESIS;
+  }
+
+  const prompt = `You are a senior equity analyst. Based on the pre-computed analysis below, write a concise investment thesis. CRITICAL: Do NOT recalculate any numbers. All numbers have been verified. Your job is to INTERPRET, not COMPUTE.
+
+Ticker: ${ticker}
+Company: ${overview.Name ?? ticker}
+Sector: ${overview.Sector ?? 'N/A'}
+Industry: ${overview.Industry ?? 'N/A'}
+
+Signal: ${composite.signal} (confidence: ${(composite.confidence * 100).toFixed(0)}%)
+Composite Score: ${composite.composite_score}/100
+
+Valuation: ${valuation.verdict} (score: ${valuation.composite.toFixed(0)}/100)
+- P/E: ${overview.PERatio}, PEG: ${overview.PEGRatio}
+- FCF Yield score: ${valuation.fcf_yield_score.toFixed(0)}/100
+
+Technical Regime: ${technicals.regime}
+- Trend: ${technicals.trend_score.toFixed(0)}/100, Momentum: ${technicals.momentum_score.toFixed(0)}/100
+- Active Signals: ${JSON.stringify(technicals.signals.map((s) => s.name))}
+
+Financial Health: ${financials.composite.toFixed(0)}/100
+- Growth score: ${financials.growth_score.toFixed(0)}/100, Revenue growth: ${financials.raw.revenueGrowthPct.toFixed(1)}% YoY
+- Red Flags: ${JSON.stringify(financials.red_flags)}
+- Green Flags: ${JSON.stringify(financials.green_flags)}
+
+Sentiment: ${sentiment.composite.toFixed(0)}/100 (${sentiment.news_volume} articles, ${(sentiment.bullish_ratio * 100).toFixed(0)}% bullish)
+
+Support: ${composite.support_levels.join(', ')}
+Resistance: ${composite.resistance_levels.join(', ')}
+
+Respond ONLY with valid JSON (no markdown fences):
+{
+  "bull_case": "3-4 sentences with specific numbers only from the data above",
+  "bear_case": "3-4 sentences with specific numbers only from the data above",
+  "catalysts": ["upcoming event or condition 1", "event 2", "event 3"],
+  "risks": ["risk 1", "risk 2", "risk 3"],
+  "time_horizon": "short_term | medium_term | long_term",
+  "entry_strategy": "Specific entry approach given support/resistance levels above"
+}`;
+
+  try {
+    const genAI = new GoogleGenerativeAI(apiKey);
+    const model = genAI.getGenerativeModel({ model: 'gemini-2.0-flash' });
+    const result = await model.generateContent(prompt);
+    const text = result.response.text().trim();
+
+    // Strip markdown fences if present
+    const clean = text.replace(/^```(?:json)?\n?/, '').replace(/\n?```$/, '').trim();
+    const parsed = JSON.parse(clean) as InvestmentThesis;
+    return parsed;
+  } catch (err) {
+    console.error('[thesis] Gemini call failed:', err);
+    return FALLBACK_THESIS;
+  }
+}