agentbnb 4.0.4 → 5.1.1

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"]
+}

package/dist/card-RNEWSAQ6.js

@@ -1,88 +0,0 @@
-import {
-  CapabilityCardV2Schema
-} from "./chunk-UB2NPFC7.js";
-
-// src/conductor/card.ts
-import { createHash } from "crypto";
-var CONDUCTOR_OWNER = "agentbnb-conductor";
-var CONDUCTOR_CARD_ID = "00000000-0000-4000-8000-000000000001";
-function ownerToCardId(owner) {
-  const hash = createHash("sha256").update(owner).digest("hex").slice(0, 32);
-  return `${hash.slice(0, 8)}-${hash.slice(8, 12)}-4${hash.slice(13, 16)}-8${hash.slice(17, 20)}-${hash.slice(20, 32)}`;
-}
-function buildConductorCard(owner) {
-  const cardOwner = owner ?? CONDUCTOR_OWNER;
-  const cardId = owner ? ownerToCardId(owner) : CONDUCTOR_CARD_ID;
-  const card = {
-    spec_version: "2.0",
-    id: cardId,
-    owner: cardOwner,
-    agent_name: "AgentBnB Conductor",
-    skills: [
-      {
-        id: "orchestrate",
-        name: "Task Orchestration",
-        description: "Decomposes complex tasks and coordinates multi-agent execution",
-        level: 3,
-        inputs: [
-          {
-            name: "task",
-            type: "text",
-            description: "Natural language task description"
-          }
-        ],
-        outputs: [
-          {
-            name: "result",
-            type: "json",
-            description: "Aggregated execution results"
-          }
-        ],
-        pricing: { credits_per_call: 5 }
-      },
-      {
-        id: "plan",
-        name: "Execution Planning",
-        description: "Returns an execution plan with cost estimate without executing",
-        level: 1,
-        inputs: [
-          {
-            name: "task",
-            type: "text",
-            description: "Natural language task description"
-          }
-        ],
-        outputs: [
-          {
-            name: "plan",
-            type: "json",
-            description: "Execution plan with cost breakdown"
-          }
-        ],
-        pricing: { credits_per_call: 1 }
-      }
-    ],
-    availability: { online: true }
-  };
-  return CapabilityCardV2Schema.parse(card);
-}
-function registerConductorCard(db) {
-  const card = buildConductorCard();
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const existing = db.prepare("SELECT id FROM capability_cards WHERE id = ?").get(card.id);
-  if (existing) {
-    db.prepare(
-      "UPDATE capability_cards SET data = ?, updated_at = ? WHERE id = ?"
-    ).run(JSON.stringify(card), now, card.id);
-  } else {
-    db.prepare(
-      "INSERT INTO capability_cards (id, owner, data, created_at, updated_at) VALUES (?, ?, ?, ?, ?)"
-    ).run(card.id, card.owner, JSON.stringify(card), now, now);
-  }
-  return card;
-}
-export {
-  CONDUCTOR_OWNER,
-  buildConductorCard,
-  registerConductorCard
-};

package/dist/chunk-UB2NPFC7.js

@@ -1,165 +0,0 @@
-// src/types/index.ts
-import { z } from "zod";
-var IOSchemaSchema = z.object({
-  name: z.string(),
-  type: z.enum(["text", "json", "file", "audio", "image", "video", "stream"]),
-  description: z.string().optional(),
-  required: z.boolean().default(true),
-  schema: z.record(z.unknown()).optional()
-  // JSON Schema
-});
-var PoweredBySchema = z.object({
-  provider: z.string().min(1),
-  model: z.string().optional(),
-  tier: z.string().optional()
-});
-var CapabilityCardSchema = z.object({
-  spec_version: z.literal("1.0").default("1.0"),
-  id: z.string().uuid(),
-  owner: z.string().min(1),
-  name: z.string().min(1).max(100),
-  description: z.string().max(500),
-  level: z.union([z.literal(1), z.literal(2), z.literal(3)]),
-  inputs: z.array(IOSchemaSchema),
-  outputs: z.array(IOSchemaSchema),
-  pricing: z.object({
-    credits_per_call: z.number().nonnegative(),
-    credits_per_minute: z.number().nonnegative().optional(),
-    /** Number of free monthly calls. Shown as a "N free/mo" badge in the Hub. */
-    free_tier: z.number().nonnegative().optional()
-  }),
-  availability: z.object({
-    online: z.boolean(),
-    schedule: z.string().optional()
-    // cron expression
-  }),
-  powered_by: z.array(PoweredBySchema).optional(),
-  /**
-   * Private per-card metadata. Stripped from all API and CLI responses —
-   * never transmitted beyond the local store.
-   */
-  _internal: z.record(z.unknown()).optional(),
-  /** Public gateway URL where this agent accepts requests. Populated on remote publish. */
-  gateway_url: z.string().url().optional(),
-  metadata: z.object({
-    apis_used: z.array(z.string()).optional(),
-    avg_latency_ms: z.number().nonnegative().optional(),
-    success_rate: z.number().min(0).max(1).optional(),
-    tags: z.array(z.string()).optional()
-  }).optional(),
-  created_at: z.string().datetime().optional(),
-  updated_at: z.string().datetime().optional()
-});
-var SkillSchema = z.object({
-  /** Stable skill identifier, e.g. 'tts-elevenlabs'. Used for gateway routing and idle tracking. */
-  id: z.string().min(1),
-  name: z.string().min(1).max(100),
-  description: z.string().max(500),
-  level: z.union([z.literal(1), z.literal(2), z.literal(3)]),
-  /** Optional grouping category, e.g. 'tts' | 'video_gen' | 'code_review'. */
-  category: z.string().optional(),
-  inputs: z.array(IOSchemaSchema),
-  outputs: z.array(IOSchemaSchema),
-  pricing: z.object({
-    credits_per_call: z.number().nonnegative(),
-    credits_per_minute: z.number().nonnegative().optional(),
-    free_tier: z.number().nonnegative().optional()
-  }),
-  /** Per-skill online flag — overrides card-level availability for this skill. */
-  availability: z.object({ online: z.boolean() }).optional(),
-  powered_by: z.array(PoweredBySchema).optional(),
-  metadata: z.object({
-    apis_used: z.array(z.string()).optional(),
-    avg_latency_ms: z.number().nonnegative().optional(),
-    success_rate: z.number().min(0).max(1).optional(),
-    tags: z.array(z.string()).optional(),
-    capacity: z.object({
-      calls_per_hour: z.number().positive().default(60)
-    }).optional()
-  }).optional(),
-  /**
-   * Private per-skill metadata. Stripped from all API and CLI responses —
-   * never transmitted beyond the local store.
-   */
-  _internal: z.record(z.unknown()).optional()
-});
-var SuitabilitySchema = z.object({
-  /** Use cases this agent/skill is optimised for. */
-  ideal_for: z.array(z.string()).optional(),
-  /** Scenarios this agent/skill cannot reliably handle. */
-  not_suitable_for: z.array(z.string()).optional(),
-  /** Domains explicitly excluded (used for routing exclusions in later phases). */
-  excluded_domains: z.array(z.string()).optional(),
-  /** Conditions that increase failure risk, shown as warnings in the Hub. */
-  risk_conditions: z.array(z.string()).optional(),
-  /** Recommended alternative when this agent is unsuitable. */
-  fallback_recommendation: z.string().optional()
-});
-var LearningSchema = z.object({
-  /** Known limitations that may affect reliability (self-declared). */
-  known_limitations: z.array(z.string()).optional(),
-  /** Common failure patterns observed by the provider. */
-  common_failure_patterns: z.array(z.string()).optional(),
-  /** Version-tagged improvements the provider has shipped. */
-  recent_improvements: z.array(z.object({
-    version: z.string(),
-    summary: z.string(),
-    timestamp: z.string()
-  })).optional(),
-  /** Structured critiques from external sources (phase 2+). */
-  critiques: z.array(z.object({
-    type: z.literal("structured"),
-    summary: z.string(),
-    source_tier: z.string(),
-    timestamp: z.string()
-  })).optional()
-});
-var CapabilityCardV2Schema = z.object({
-  spec_version: z.literal("2.0"),
-  id: z.string().uuid(),
-  owner: z.string().min(1),
-  /** Agent display name — was 'name' in v1.0. */
-  agent_name: z.string().min(1).max(100),
-  /** Short one-liner shown in Hub v2 Identity Header. */
-  short_description: z.string().max(200).optional(),
-  /** At least one skill is required. */
-  skills: z.array(SkillSchema).min(1),
-  availability: z.object({
-    online: z.boolean(),
-    schedule: z.string().optional()
-  }),
-  /** Optional deployment environment metadata. */
-  environment: z.object({
-    runtime: z.string(),
-    region: z.string().optional()
-  }).optional(),
-  /** Suitability metadata for Hub v2 profile and future routing warnings. */
-  suitability: SuitabilitySchema.optional(),
-  /** Learning signals — self-declared limitations, improvements, critiques. */
-  learning: LearningSchema.optional(),
-  /**
-   * Private per-card metadata. Stripped from all API and CLI responses —
-   * never transmitted beyond the local store.
-   */
-  _internal: z.record(z.unknown()).optional(),
-  /** Public gateway URL where this agent accepts requests. Populated on remote publish. */
-  gateway_url: z.string().url().optional(),
-  created_at: z.string().datetime().optional(),
-  updated_at: z.string().datetime().optional()
-});
-var AnyCardSchema = z.discriminatedUnion("spec_version", [
-  CapabilityCardSchema,
-  CapabilityCardV2Schema
-]);
-var AgentBnBError = class extends Error {
-  constructor(message, code) {
-    super(message);
-    this.code = code;
-    this.name = "AgentBnBError";
-  }
-};
-
-export {
-  CapabilityCardV2Schema,
-  AgentBnBError
-};

package/dist/execute-QH6F54D7.js

@@ -1,10 +0,0 @@
-import {
-  executeCapabilityRequest
-} from "./chunk-5QGXARLJ.js";
-import "./chunk-T7NS2J2B.js";
-import "./chunk-DNWT5FZQ.js";
-import "./chunk-5KFI5X7B.js";
-import "./chunk-WGZ5AGOX.js";
-export {
-  executeCapabilityRequest
-};