agentbnb 5.1.0 → 5.1.1

package/dist/cli/index.js

@@ -1552,7 +1552,7 @@ program.command("serve").description("Start the AgentBnB gateway server").option
     process.exit(1);
   }
   const { ProcessGuard } = await import("../process-guard-CC7CNRQJ.js");
-  const { ServiceCoordinator } = await import("../service-coordinator-5R4LQW6L.js");
+  const { ServiceCoordinator } = await import("../service-coordinator-UTKI4FRI.js");
   const port = opts.port ? parseInt(opts.port, 10) : config.gateway_port;
   const registryPort = parseInt(opts.registryPort, 10);
   if (!Number.isFinite(port) || !Number.isFinite(registryPort)) {

package/dist/index.js

@@ -1929,10 +1929,13 @@ var CommandExecutor = class {
     const timeout = cmdConfig.timeout_ms ?? 3e4;
     const cwd = cmdConfig.working_dir ?? process.cwd();
     let stdout;
+    const env = { ...process.env };
+    delete env["CLAUDECODE"];
     try {
-      const result = await execFileAsync2("/bin/sh", ["-c", interpolatedCommand], {
+      const result = await execFileAsync2("/bin/sh", ["-c", `${interpolatedCommand} < /dev/null`], {
         timeout,
         cwd,
+        env,
         maxBuffer: 10 * 1024 * 1024
         // 10 MB
       });

package/dist/{service-coordinator-5R4LQW6L.js → service-coordinator-UTKI4FRI.js}

@@ -777,10 +777,13 @@ var CommandExecutor = class {
     const timeout = cmdConfig.timeout_ms ?? 3e4;
     const cwd = cmdConfig.working_dir ?? process.cwd();
     let stdout;
+    const env = { ...process.env };
+    delete env["CLAUDECODE"];
     try {
-      const result = await execFileAsync2("/bin/sh", ["-c", interpolatedCommand], {
+      const result = await execFileAsync2("/bin/sh", ["-c", `${interpolatedCommand} < /dev/null`], {
         timeout,
         cwd,
+        env,
         maxBuffer: 10 * 1024 * 1024
         // 10 MB
       });
@@ -3234,8 +3237,10 @@ function createRegistryServer(opts) {
   const __filename = fileURLToPath(import.meta.url);
   const __dirname = dirname(__filename);
   const hubDistCandidates = [
+    join(__dirname, "../hub/dist"),
+    // When in dist/ (tsup chunk, e.g. dist/server-XYZ.js)
     join(__dirname, "../../hub/dist"),
-    // When running from dist/registry/server.js
+    // When in dist/registry/ or dist/cli/
     join(__dirname, "../../../hub/dist")
     // Fallback for alternative layouts
   ];

package/dist/skills/agentbnb/bootstrap.js

@@ -934,10 +934,13 @@ var CommandExecutor = class {
     const timeout = cmdConfig.timeout_ms ?? 3e4;
     const cwd = cmdConfig.working_dir ?? process.cwd();
     let stdout;
+    const env = { ...process.env };
+    delete env["CLAUDECODE"];
     try {
-      const result = await execFileAsync2("/bin/sh", ["-c", interpolatedCommand], {
+      const result = await execFileAsync2("/bin/sh", ["-c", `${interpolatedCommand} < /dev/null`], {
         timeout,
         cwd,
+        env,
         maxBuffer: 10 * 1024 * 1024
         // 10 MB
       });
@@ -4035,8 +4038,10 @@ function createRegistryServer(opts) {
   const __filename = fileURLToPath(import.meta.url);
   const __dirname = dirname2(__filename);
   const hubDistCandidates = [
+    join3(__dirname, "../hub/dist"),
+    // When in dist/ (tsup chunk, e.g. dist/server-XYZ.js)
     join3(__dirname, "../../hub/dist"),
-    // When running from dist/registry/server.js
+    // When in dist/registry/ or dist/cli/
     join3(__dirname, "../../../hub/dist")
     // Fallback for alternative layouts
   ];

package/package.json

@@ -3,7 +3,7 @@
   "workspaces": [
     "packages/*"
   ],
-  "version": "5.1.0",
+  "version": "5.1.1",
   "description": "P2P Agent Capability Sharing Protocol — Airbnb for AI agent pipelines",
   "type": "module",
   "main": "dist/index.js",

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

@@ -0,0 +1,24 @@
+{
+  "name": "@agentbnb/skill-deep-stock-analyst",
+  "version": "1.0.0",
+  "description": "Deep quantitative stock analysis: 12-endpoint Alpha Vantage pipeline + 5 analysis modules + Gemini thesis",
+  "type": "module",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "test": "node --experimental-vm-modules node_modules/.bin/jest --testPathPattern=tests/",
+    "dev": "tsx src/index.ts"
+  },
+  "dependencies": {
+    "@google/generative-ai": "^0.21.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.5.0",
+    "tsx": "^4.19.0"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}

package/skills/deep-stock-analyst/src/analysis/financial-health.ts

@@ -0,0 +1,167 @@
+import type {
+  AVOverview,
+  AVIncomeStatement,
+  AVBalanceSheet,
+  AVCashFlow,
+  AVEarnings,
+} from '../api/types.js';
+import {
+  scoreMetric,
+  scoreMetricInverse,
+  weightedAvg,
+  calcYoYGrowth,
+  scoreGrowth,
+  scoreSurprise,
+  countConsecutiveBeats,
+  sp,
+} from './utils.js';
+
+export interface FinancialHealth {
+  profitability_score: number;
+  growth_score: number;
+  leverage_score: number;
+  efficiency_score: number;
+  composite: number;
+  red_flags: string[];
+  green_flags: string[];
+  raw: {
+    grossMarginPct: number;
+    operatingMarginPct: number;
+    netMarginPct: number;
+    roe: number;
+    debtToEquity: number;
+    currentRatio: number;
+    revenueGrowthPct: number;
+    earningsGrowthPct: number;
+    lastSurpisePct: number;
+    consecutiveBeats: number;
+  };
+}
+
+function calcInterestCoverage(report: AVIncomeStatement['annualReports'][number] | undefined): number {
+  if (!report) return 5;
+  const ebit = sp(report.ebit);
+  const interest = sp(report.interestExpense);
+  if (interest === 0) return 10; // no debt
+  return Math.abs(ebit / interest);
+}
+
+function calcROIC(
+  income: AVIncomeStatement['annualReports'][number] | undefined,
+  balance: AVBalanceSheet['annualReports'][number] | undefined,
+): number {
+  if (!income || !balance) return 0;
+  const nopat = sp(income.ebit) * 0.79; // rough 21% tax
+  const investedCapital =
+    sp(balance.totalShareholderEquity) + sp(balance.longTermDebt) + sp(balance.shortTermDebt);
+  if (investedCapital === 0) return 0;
+  return nopat / investedCapital;
+}
+
+export function analyzeFinancialHealth(
+  overview: AVOverview,
+  income: AVIncomeStatement,
+  balance: AVBalanceSheet,
+  cashflow: AVCashFlow,
+  earnings: AVEarnings,
+): FinancialHealth {
+  const red_flags: string[] = [];
+  const green_flags: string[] = [];
+
+  // === Profitability ===
+  const grossProfit = sp(overview.GrossProfitTTM);
+  const revenue = sp(overview.RevenueTTM);
+  const grossMarginPct = revenue > 0 ? (grossProfit / revenue) * 100 : 0;
+  const operatingMarginPct = sp(overview.OperatingMarginTTM) * 100;
+  const netMarginPct = sp(overview.ProfitMargin) * 100;
+  const roe = sp(overview.ReturnOnEquityTTM) * 100;
+
+  if (grossMarginPct > 60) green_flags.push(`Gross margin ${grossMarginPct.toFixed(1)}% — strong pricing power`);
+  if (netMarginPct < 0) red_flags.push(`Net margin negative at ${netMarginPct.toFixed(1)}%`);
+  if (roe > 20) green_flags.push(`ROE ${roe.toFixed(1)}% — excellent capital efficiency`);
+  if (roe < 0) red_flags.push(`ROE negative at ${roe.toFixed(1)}% — destroying shareholder value`);
+
+  const profitability_score = weightedAvg([
+    [scoreMetricInverse(grossMarginPct, { excellent: 60, good: 40, fair: 25, poor: 10 }), 0.30],
+    [scoreMetricInverse(operatingMarginPct, { excellent: 25, good: 15, fair: 8, poor: 0 }), 0.35],
+    [scoreMetricInverse(roe, { excellent: 25, good: 15, fair: 8, poor: 0 }), 0.35],
+  ]);
+
+  // === Growth ===
+  const revenueGrowthPct = calcYoYGrowth(income.quarterlyReports, 'totalRevenue');
+  const earningsGrowthPct = calcYoYGrowth(income.quarterlyReports, 'netIncome');
+  const fcfGrowthPct = calcYoYGrowth(cashflow.quarterlyReports, 'operatingCashflow');
+
+  const lastEarnings = earnings.quarterlyEarnings[0];
+  const lastSurpisePct = sp(lastEarnings?.surprisePercentage);
+  if (lastSurpisePct > 10) green_flags.push(`Last earnings beat estimates by ${lastSurpisePct.toFixed(1)}%`);
+  if (lastSurpisePct < -10) red_flags.push(`Last earnings missed estimates by ${Math.abs(lastSurpisePct).toFixed(1)}%`);
+
+  const consecutiveBeats = countConsecutiveBeats(earnings.quarterlyEarnings);
+  if (consecutiveBeats >= 4) green_flags.push(`${consecutiveBeats} consecutive quarters of earnings beats`);
+  if (revenueGrowthPct > 20) green_flags.push(`Revenue growing ${revenueGrowthPct.toFixed(1)}% YoY`);
+  if (revenueGrowthPct < -10) red_flags.push(`Revenue declining ${Math.abs(revenueGrowthPct).toFixed(1)}% YoY`);
+
+  const growth_score = weightedAvg([
+    [scoreGrowth(revenueGrowthPct), 0.35],
+    [scoreGrowth(earningsGrowthPct), 0.35],
+    [scoreGrowth(fcfGrowthPct), 0.20],
+    [scoreSurprise(lastSurpisePct), 0.10],
+  ]);
+
+  // === Leverage ===
+  const debtToEquity = sp(overview.DebtToEquity);
+  const currentRatio = sp(overview.CurrentRatio);
+  const interestCoverage = calcInterestCoverage(income.annualReports[0]);
+
+  if (debtToEquity > 2.0) red_flags.push(`Debt/Equity ${debtToEquity.toFixed(2)} — heavily leveraged`);
+  if (currentRatio < 1.0) red_flags.push(`Current ratio ${currentRatio.toFixed(2)} — potential liquidity risk`);
+  if (currentRatio > 2.0) green_flags.push(`Current ratio ${currentRatio.toFixed(2)} — strong liquidity`);
+  if (interestCoverage < 2.0) red_flags.push(`Interest coverage ${interestCoverage.toFixed(1)}x — thin margin`);
+  if (debtToEquity < 0.3) green_flags.push(`Low leverage: Debt/Equity ${debtToEquity.toFixed(2)}`);
+
+  const leverage_score = weightedAvg([
+    [scoreMetric(debtToEquity, { excellent: 0.3, good: 0.8, fair: 1.5, poor: 3.0 }), 0.40],
+    [scoreMetricInverse(currentRatio, { excellent: 2.5, good: 1.5, fair: 1.0, poor: 0.5 }), 0.30],
+    [scoreMetricInverse(interestCoverage, { excellent: 10, good: 5, fair: 2, poor: 1 }), 0.30],
+  ]);
+
+  // === Efficiency ===
+  const totalAssets = sp(balance.annualReports[0]?.totalAssets);
+  const assetTurnover = totalAssets > 0 ? revenue / totalAssets : 0;
+  const roic = calcROIC(income.annualReports[0], balance.annualReports[0]);
+
+  const efficiency_score = weightedAvg([
+    [scoreMetricInverse(assetTurnover, { excellent: 1.5, good: 1.0, fair: 0.5, poor: 0.2 }), 0.50],
+    [scoreMetricInverse(roic * 100, { excellent: 20, good: 12, fair: 7, poor: 0 }), 0.50],
+  ]);
+
+  const composite = weightedAvg([
+    [profitability_score, 0.30],
+    [growth_score, 0.30],
+    [leverage_score, 0.20],
+    [efficiency_score, 0.20],
+  ]);
+
+  return {
+    profitability_score,
+    growth_score,
+    leverage_score,
+    efficiency_score,
+    composite,
+    red_flags,
+    green_flags,
+    raw: {
+      grossMarginPct,
+      operatingMarginPct,
+      netMarginPct,
+      roe,
+      debtToEquity,
+      currentRatio,
+      revenueGrowthPct,
+      earningsGrowthPct,
+      lastSurpisePct,
+      consecutiveBeats,
+    },
+  };
+}

package/skills/deep-stock-analyst/src/analysis/sentiment.ts

@@ -0,0 +1,68 @@
+import type { AVNewsSentiment } from '../api/types.js';
+import { mapRange, sp } from './utils.js';
+
+export interface SentimentScore {
+  news_sentiment: number;   // -1 to +1
+  news_volume: number;      // relevant articles in feed
+  bullish_ratio: number;    // 0–1
+  topic_breakdown: Record<string, number>; // topic → avg relevance
+  key_headlines: string[];  // top 5 by sentiment magnitude
+  composite: number;        // 0–100
+}
+
+export function analyzeSentiment(newsData: AVNewsSentiment, ticker: string): SentimentScore {
+  const articles = newsData.feed ?? [];
+  const t = ticker.toUpperCase();
+
+  // Filter to articles where this ticker has relevance_score > 0.5
+  const relevant = articles.filter((a) => {
+    const ts = a.ticker_sentiment?.find(
+      (s) => s.ticker === t && sp(s.relevance_score) > 0.5,
+    );
+    return !!ts;
+  });
+
+  let totalSentiment = 0;
+  let bullishCount = 0;
+
+  for (const article of relevant) {
+    const ts = article.ticker_sentiment.find((s) => s.ticker === t);
+    if (!ts) continue;
+    const score = sp(ts.ticker_sentiment_score);
+    totalSentiment += score;
+    if (score > 0.15) bullishCount++;
+  }
+
+  const news_sentiment = relevant.length > 0 ? totalSentiment / relevant.length : 0;
+  const bullish_ratio = relevant.length > 0 ? bullishCount / relevant.length : 0.5;
+
+  // Topic breakdown: topic → avg relevance across articles
+  const topicMap: Record<string, number[]> = {};
+  for (const article of relevant) {
+    for (const topic of article.topics ?? []) {
+      if (!topicMap[topic.topic]) topicMap[topic.topic] = [];
+      topicMap[topic.topic]!.push(sp(topic.relevance_score));
+    }
+  }
+  const topic_breakdown: Record<string, number> = {};
+  for (const [topic, scores] of Object.entries(topicMap)) {
+    topic_breakdown[topic] = scores.reduce((a, b) => a + b, 0) / scores.length;
+  }
+
+  // Top 5 headlines sorted by overall sentiment magnitude
+  const key_headlines = relevant
+    .sort((a, b) =>
+      Math.abs(sp(b.overall_sentiment_score)) - Math.abs(sp(a.overall_sentiment_score)),
+    )
+    .slice(0, 5)
+    .map((a) => `[${a.overall_sentiment_label}] ${a.title}`);
+
+  return {
+    news_sentiment,
+    news_volume: relevant.length,
+    bullish_ratio,
+    topic_breakdown,
+    key_headlines,
+    composite: mapRange(news_sentiment, -1, 1, 0, 100),
+  };
+}

package/skills/deep-stock-analyst/src/analysis/signal.ts

@@ -0,0 +1,188 @@
+import type { AVDailyPrice } from '../api/types.js';
+import type { ValuationScore } from './valuation.js';
+import type { TechnicalScore } from './technicals.js';
+import type { FinancialHealth } from './financial-health.js';
+import type { SentimentScore } from './sentiment.js';
+import { sp } from './utils.js';
+
+export type InvestmentStyle = 'growth' | 'value' | 'momentum' | 'hybrid';
+export type SignalVerdict = 'strong_buy' | 'buy' | 'hold' | 'sell' | 'strong_sell';
+
+interface StyleWeights {
+  valuation: number;
+  technicals: number;
+  financials: number;
+  sentiment: number;
+}
+
+function getStyleWeights(style: InvestmentStyle): StyleWeights {
+  const presets: Record<InvestmentStyle, StyleWeights> = {
+    growth: { valuation: 0.15, technicals: 0.25, financials: 0.40, sentiment: 0.20 },
+    value: { valuation: 0.40, technicals: 0.15, financials: 0.30, sentiment: 0.15 },
+    momentum: { valuation: 0.10, technicals: 0.45, financials: 0.15, sentiment: 0.30 },
+    hybrid: { valuation: 0.25, technicals: 0.30, financials: 0.25, sentiment: 0.20 },
+  };
+  return presets[style];
+}
+
+/** Find local support levels from price data */
+function findSupportLevels(daily: AVDailyPrice[], count: number): number[] {
+  const prices = daily.slice(0, 90).map((d) => sp(d.low));
+  const levels: number[] = [];
+
+  for (let i = 2; i < prices.length - 2; i++) {
+    const p = prices[i] ?? 0;
+    if (
+      p <= (prices[i - 1] ?? 0) &&
+      p <= (prices[i - 2] ?? 0) &&
+      p <= (prices[i + 1] ?? 0) &&
+      p <= (prices[i + 2] ?? 0)
+    ) {
+      levels.push(parseFloat(p.toFixed(2)));
+    }
+  }
+
+  // Cluster nearby levels (within 1%)
+  const clustered: number[] = [];
+  for (const lvl of levels.sort((a, b) => b - a)) {
+    const isDuplicate = clustered.some((c) => Math.abs(c - lvl) / lvl < 0.01);
+    if (!isDuplicate) clustered.push(lvl);
+    if (clustered.length >= count) break;
+  }
+  return clustered;
+}
+
+/** Find local resistance levels from price data */
+function findResistanceLevels(daily: AVDailyPrice[], count: number): number[] {
+  const prices = daily.slice(0, 90).map((d) => sp(d.high));
+  const levels: number[] = [];
+
+  for (let i = 2; i < prices.length - 2; i++) {
+    const p = prices[i] ?? 0;
+    if (
+      p >= (prices[i - 1] ?? 0) &&
+      p >= (prices[i - 2] ?? 0) &&
+      p >= (prices[i + 1] ?? 0) &&
+      p >= (prices[i + 2] ?? 0)
+    ) {
+      levels.push(parseFloat(p.toFixed(2)));
+    }
+  }
+
+  const clustered: number[] = [];
+  for (const lvl of levels.sort((a, b) => b - a)) {
+    const isDuplicate = clustered.some((c) => Math.abs(c - lvl) / lvl < 0.01);
+    if (!isDuplicate) clustered.push(lvl);
+    if (clustered.length >= count) break;
+  }
+  return clustered;
+}
+
+/** How much do the four sub-scores agree? 0–1 */
+function calculateAgreement(
+  valuation: ValuationScore,
+  technicals: TechnicalScore,
+  financials: FinancialHealth,
+  sentiment: SentimentScore,
+): number {
+  const scores = [
+    valuation.composite,
+    technicals.composite,
+    financials.composite,
+    sentiment.composite,
+  ];
+  const mean = scores.reduce((a, b) => a + b, 0) / scores.length;
+  const variance = scores.reduce((acc, s) => acc + (s - mean) ** 2, 0) / scores.length;
+  const stdDev = Math.sqrt(variance);
+  // Low stdDev = high agreement → high confidence
+  return Math.max(0, 1 - stdDev / 30);
+}
+
+/** Data completeness: 0–1 based on whether modules have real data */
+function calculateCompleteness(
+  valuation: ValuationScore,
+  technicals: TechnicalScore,
+  financials: FinancialHealth,
+  sentiment: SentimentScore,
+): number {
+  let score = 0;
+  if (valuation.raw.pe > 0) score += 0.25;
+  if (technicals.raw.price > 0) score += 0.25;
+  if (financials.raw.revenueGrowthPct !== 0) score += 0.25;
+  if (sentiment.news_volume > 3) score += 0.25;
+  return score;
+}
+
+export interface CompositeSignal {
+  signal: SignalVerdict;
+  confidence: number; // 0–1
+  composite_score: number; // 0–100
+  support_levels: number[];
+  resistance_levels: number[];
+  key_factors: string[];
+  risk_factors: string[];
+  data_completeness: number; // 0–1
+}
+
+export function generateCompositeSignal(
+  valuation: ValuationScore,
+  technicals: TechnicalScore,
+  financials: FinancialHealth,
+  sentiment: SentimentScore,
+  daily: AVDailyPrice[],
+  style: InvestmentStyle,
+): CompositeSignal {
+  const w = getStyleWeights(style);
+
+  const composite_score =
+    valuation.composite * w.valuation +
+    technicals.composite * w.technicals +
+    financials.composite * w.financials +
+    sentiment.composite * w.sentiment;
+
+  const signal: SignalVerdict =
+    composite_score > 80 ? 'strong_buy'
+      : composite_score > 62 ? 'buy'
+        : composite_score > 42 ? 'hold'
+          : composite_score > 25 ? 'sell'
+            : 'strong_sell';
+
+  const agreementScore = calculateAgreement(valuation, technicals, financials, sentiment);
+  const data_completeness = calculateCompleteness(valuation, technicals, financials, sentiment);
+  const confidence = parseFloat((agreementScore * 0.6 + data_completeness * 0.4).toFixed(2));
+
+  const support_levels = findSupportLevels(daily, 3);
+  const resistance_levels = findResistanceLevels(daily, 3);
+
+  // Key positive factors
+  const key_factors: string[] = [];
+  if (valuation.verdict === 'undervalued') key_factors.push(`Undervalued: composite valuation ${valuation.composite.toFixed(0)}/100`);
+  if (financials.growth_score > 70) key_factors.push(`Strong growth: revenue +${financials.raw.revenueGrowthPct.toFixed(1)}% YoY`);
+  if (technicals.signals.some((s) => s.type === 'bullish' && s.strength >= 4)) {
+    const sig = technicals.signals.find((s) => s.type === 'bullish' && s.strength >= 4);
+    if (sig) key_factors.push(`Technical: ${sig.name}`);
+  }
+  if (sentiment.bullish_ratio > 0.7) key_factors.push(`Bullish sentiment: ${(sentiment.bullish_ratio * 100).toFixed(0)}% positive coverage`);
+  for (const flag of financials.green_flags.slice(0, 2)) key_factors.push(flag);
+
+  // Key risk factors
+  const risk_factors: string[] = [];
+  if (valuation.verdict === 'expensive') risk_factors.push(`Expensive valuation: composite ${valuation.composite.toFixed(0)}/100`);
+  if (technicals.signals.some((s) => s.type === 'bearish' && s.strength >= 4)) {
+    const sig = technicals.signals.find((s) => s.type === 'bearish' && s.strength >= 4);
+    if (sig) risk_factors.push(`Technical: ${sig.name}`);
+  }
+  for (const flag of financials.red_flags.slice(0, 2)) risk_factors.push(flag);
+  if (sentiment.bullish_ratio < 0.3) risk_factors.push(`Negative sentiment: only ${(sentiment.bullish_ratio * 100).toFixed(0)}% positive coverage`);
+
+  return {
+    signal,
+    confidence,
+    composite_score: parseFloat(composite_score.toFixed(1)),
+    support_levels,
+    resistance_levels,
+    key_factors: key_factors.slice(0, 3),
+    risk_factors: risk_factors.slice(0, 3),
+    data_completeness,
+  };
+}