agentbnb 5.1.0 → 5.1.1

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

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

@@ -0,0 +1,228 @@
+/**
+ * Orchestrator: ties together all 5 analysis modules + thesis.
+ * All heavy computation happens here (no LLM until thesis step).
+ */
+
+import { fetchAllData } from './api/alpha-vantage.js';
+import { calculateValuation } from './analysis/valuation.js';
+import { analyzeTechnicals } from './analysis/technicals.js';
+import { analyzeFinancialHealth } from './analysis/financial-health.js';
+import { analyzeSentiment } from './analysis/sentiment.js';
+import { generateCompositeSignal } from './analysis/signal.js';
+import { generateThesis } from './llm/thesis.js';
+import type { InvestmentStyle } from './analysis/signal.js';
+
+export interface AnalysisOptions {
+  ticker: string;
+  depth?: 'quick' | 'standard' | 'deep';
+  style?: InvestmentStyle;
+  apiKey: string;
+}
+
+export interface AnalysisResult {
+  ticker: string;
+  analyzed_at: string;
+  depth: string;
+  style: string;
+
+  // Top-level verdict
+  signal: string;
+  confidence: number;
+  composite_score: number;
+
+  // Module results
+  valuation: {
+    verdict: string;
+    composite: number;
+    pe_score: number;
+    peg_score: number;
+    fcf_yield_score: number;
+    ev_ebitda_score: number;
+    ps_score: number;
+    raw: Record<string, number>;
+  };
+  technicals: {
+    regime: string;
+    composite: number;
+    trend_score: number;
+    momentum_score: number;
+    volatility_score: number;
+    strength_score: number;
+    signals: Array<{ type: string; name: string; strength: number; description: string }>;
+    raw: Record<string, number>;
+  };
+  financials: {
+    composite: number;
+    profitability_score: number;
+    growth_score: number;
+    leverage_score: number;
+    efficiency_score: number;
+    red_flags: string[];
+    green_flags: string[];
+    raw: Record<string, number>;
+  };
+  sentiment: {
+    composite: number;
+    news_sentiment: number;
+    news_volume: number;
+    bullish_ratio: number;
+    key_headlines: string[];
+    topic_breakdown: Record<string, number>;
+  };
+
+  // LLM thesis
+  thesis: {
+    bull_case: string;
+    bear_case: string;
+    catalysts: string[];
+    risks: string[];
+    time_horizon: string;
+    entry_strategy: string;
+  };
+
+  // Price levels
+  support_levels: number[];
+  resistance_levels: number[];
+  key_factors: string[];
+  risk_factors: string[];
+  data_completeness: number;
+
+  // Company metadata
+  company: {
+    name: string;
+    sector: string;
+    industry: string;
+    market_cap: string;
+    price: number;
+    analyst_target: number;
+  };
+}
+
+export async function runAnalysis(options: AnalysisOptions): Promise<AnalysisResult> {
+  const { ticker, depth = 'standard', style = 'hybrid', apiKey } = options;
+
+  // Step 1: Fetch all API data (12 calls, serialized)
+  const data = await fetchAllData(ticker, apiKey);
+
+  // Step 2: Compute all modules (pure math, no LLM)
+  const valuation = calculateValuation(data.overview);
+  const technicals = analyzeTechnicals(
+    data.daily, data.rsi, data.macd, data.bbands, data.stoch, data.adx,
+  );
+  const financials = analyzeFinancialHealth(
+    data.overview, data.income, data.balance, data.cashflow, data.earnings,
+  );
+  const sentiment = analyzeSentiment(data.news, ticker);
+  const composite = generateCompositeSignal(
+    valuation, technicals, financials, sentiment, data.daily, style,
+  );
+
+  // Step 3: LLM thesis (~200ms, Gemini Flash)
+  const thesis = await generateThesis(
+    ticker, data.overview, composite, valuation, technicals, financials, sentiment,
+  );
+
+  // Step 4: Assemble result
+  const price = parseFloat(data.daily[0]?.adjustedClose ?? data.daily[0]?.close ?? '0');
+  const analystTarget = parseFloat(data.overview.AnalystTargetPrice ?? '0');
+  const marketCap = parseFloat(data.overview.MarketCapitalization ?? '0');
+  const mcStr =
+    marketCap >= 1e12 ? `$${(marketCap / 1e12).toFixed(2)}T`
+      : marketCap >= 1e9 ? `$${(marketCap / 1e9).toFixed(2)}B`
+        : marketCap >= 1e6 ? `$${(marketCap / 1e6).toFixed(2)}M`
+          : `$${marketCap.toFixed(0)}`;
+
+  return {
+    ticker: ticker.toUpperCase(),
+    analyzed_at: new Date().toISOString(),
+    depth,
+    style,
+
+    signal: composite.signal,
+    confidence: composite.confidence,
+    composite_score: composite.composite_score,
+
+    valuation: {
+      verdict: valuation.verdict,
+      composite: parseFloat(valuation.composite.toFixed(1)),
+      pe_score: parseFloat(valuation.pe_score.toFixed(1)),
+      peg_score: parseFloat(valuation.peg_score.toFixed(1)),
+      fcf_yield_score: parseFloat(valuation.fcf_yield_score.toFixed(1)),
+      ev_ebitda_score: parseFloat(valuation.ev_ebitda_score.toFixed(1)),
+      ps_score: parseFloat(valuation.ps_score.toFixed(1)),
+      raw: {
+        pe: valuation.raw.pe,
+        peg: valuation.raw.peg,
+        ps: valuation.raw.ps,
+        fcf_yield_pct: parseFloat(valuation.raw.fcfYieldPct.toFixed(2)),
+      },
+    },
+
+    technicals: {
+      regime: technicals.regime,
+      composite: parseFloat(technicals.composite.toFixed(1)),
+      trend_score: parseFloat(technicals.trend_score.toFixed(1)),
+      momentum_score: parseFloat(technicals.momentum_score.toFixed(1)),
+      volatility_score: parseFloat(technicals.volatility_score.toFixed(1)),
+      strength_score: parseFloat(technicals.strength_score.toFixed(1)),
+      signals: technicals.signals,
+      raw: {
+        rsi: parseFloat(technicals.raw.rsi.toFixed(1)),
+        macd_hist: parseFloat(technicals.raw.macdHist.toFixed(4)),
+        adx: parseFloat(technicals.raw.adx.toFixed(1)),
+        bb_position: parseFloat(technicals.raw.bbPosition.toFixed(2)),
+        price,
+        sma20: parseFloat(technicals.raw.sma20.toFixed(2)),
+        sma50: parseFloat(technicals.raw.sma50.toFixed(2)),
+        sma200: parseFloat(technicals.raw.sma200.toFixed(2)),
+      },
+    },
+
+    financials: {
+      composite: parseFloat(financials.composite.toFixed(1)),
+      profitability_score: parseFloat(financials.profitability_score.toFixed(1)),
+      growth_score: parseFloat(financials.growth_score.toFixed(1)),
+      leverage_score: parseFloat(financials.leverage_score.toFixed(1)),
+      efficiency_score: parseFloat(financials.efficiency_score.toFixed(1)),
+      red_flags: financials.red_flags,
+      green_flags: financials.green_flags,
+      raw: {
+        gross_margin_pct: parseFloat(financials.raw.grossMarginPct.toFixed(1)),
+        operating_margin_pct: parseFloat(financials.raw.operatingMarginPct.toFixed(1)),
+        net_margin_pct: parseFloat(financials.raw.netMarginPct.toFixed(1)),
+        roe: parseFloat(financials.raw.roe.toFixed(1)),
+        debt_to_equity: parseFloat(financials.raw.debtToEquity.toFixed(2)),
+        current_ratio: parseFloat(financials.raw.currentRatio.toFixed(2)),
+        revenue_growth_pct: parseFloat(financials.raw.revenueGrowthPct.toFixed(1)),
+        earnings_growth_pct: parseFloat(financials.raw.earningsGrowthPct.toFixed(1)),
+        consecutive_beats: financials.raw.consecutiveBeats,
+      },
+    },
+
+    sentiment: {
+      composite: parseFloat(sentiment.composite.toFixed(1)),
+      news_sentiment: parseFloat(sentiment.news_sentiment.toFixed(3)),
+      news_volume: sentiment.news_volume,
+      bullish_ratio: parseFloat(sentiment.bullish_ratio.toFixed(2)),
+      key_headlines: sentiment.key_headlines,
+      topic_breakdown: sentiment.topic_breakdown,
+    },
+
+    thesis,
+
+    support_levels: composite.support_levels,
+    resistance_levels: composite.resistance_levels,
+    key_factors: composite.key_factors,
+    risk_factors: composite.risk_factors,
+    data_completeness: composite.data_completeness,
+
+    company: {
+      name: data.overview.Name ?? ticker,
+      sector: data.overview.Sector ?? 'N/A',
+      industry: data.overview.Industry ?? 'N/A',
+      market_cap: mcStr,
+      price,
+      analyst_target: analystTarget,
+    },
+  };
+}

package/skills/deep-stock-analyst/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "declaration": true,
+    "sourceMap": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noUncheckedIndexedAccess": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts"]
+}