@lightcone-ai/daemon 0.9.79 → 0.10.0

package/mcp-servers/portfolio-analysis/core.js

@@ -0,0 +1,592 @@
+const DEFAULT_ASSET_CLASS = 'equity';
+const DISCLAIMER = '以上内容为信息整合与分析思路，不构成投资建议。具体决策请结合自身情况，投资有风险。';
+
+function normalizeText(value) {
+  return String(value ?? '').trim();
+}
+
+function normalizeHeader(value) {
+  return normalizeText(value)
+    .toLowerCase()
+    .replace(/\s+/g, '_')
+    .replace(/[-/]+/g, '_');
+}
+
+function toNumber(value) {
+  if (typeof value === 'number') return Number.isFinite(value) ? value : null;
+  const raw = normalizeText(value);
+  if (!raw) return null;
+  const cleaned = raw
+    .replace(/,/g, '')
+    .replace(/\$/g, '')
+    .replace(/¥/g, '')
+    .replace(/％/g, '%');
+  const percent = cleaned.endsWith('%');
+  const numeric = Number(percent ? cleaned.slice(0, -1) : cleaned);
+  if (!Number.isFinite(numeric)) return null;
+  return percent ? numeric / 100 : numeric;
+}
+
+function round(value, digits = 6) {
+  if (!Number.isFinite(value)) return null;
+  const factor = 10 ** digits;
+  return Math.round(value * factor) / factor;
+}
+
+function parseMaybeJson(input, label) {
+  if (input == null) return null;
+  if (typeof input === 'string') {
+    const trimmed = input.trim();
+    if (!trimmed) return null;
+    try {
+      return JSON.parse(trimmed);
+    } catch (error) {
+      throw new Error(`${label} is not valid JSON: ${error.message}`);
+    }
+  }
+  if (typeof input === 'object') return input;
+  throw new Error(`${label} must be an object/array or JSON string`);
+}
+
+function pickValue(raw, keys) {
+  for (const key of keys) {
+    if (Object.prototype.hasOwnProperty.call(raw, key) && normalizeText(raw[key])) {
+      return raw[key];
+    }
+  }
+  return '';
+}
+
+function normalizeHolding(raw, index) {
+  const normalized = {};
+  for (const [key, value] of Object.entries(raw ?? {})) {
+    normalized[normalizeHeader(key)] = value;
+  }
+
+  const symbol = normalizeText(
+    pickValue(normalized, ['symbol', 'ticker', 'code', 'security_code', '证券代码', '股票代码'])
+  ).toUpperCase();
+  if (!symbol) return null;
+
+  const name = normalizeText(
+    pickValue(normalized, ['name', 'asset_name', 'security_name', '证券名称', '股票名称'])
+  ) || symbol;
+
+  const quantity = toNumber(pickValue(normalized, ['quantity', 'qty', 'shares', 'position', '持仓', '数量']));
+  const marketPrice = toNumber(pickValue(normalized, ['market_price', 'price', 'last_price', 'close', '现价', '最新价']));
+  const avgCost = toNumber(pickValue(normalized, ['avg_cost', 'average_cost', 'cost', 'cost_price', '买入均价', '成本价']));
+
+  let marketValue = toNumber(
+    pickValue(normalized, ['market_value', 'value', 'position_value', '持仓市值', '市值'])
+  );
+  if (marketValue == null && quantity != null && marketPrice != null) marketValue = quantity * marketPrice;
+  if (marketValue == null && quantity != null && avgCost != null) marketValue = quantity * avgCost;
+
+  const sector = normalizeText(
+    pickValue(normalized, ['sector', 'industry', '行业', '板块'])
+  ) || 'Unknown';
+
+  return {
+    id: `pos_${index + 1}`,
+    symbol,
+    name,
+    sector,
+    asset_class: normalizeText(pickValue(normalized, ['asset_class', 'asset_type', '资产类别'])) || DEFAULT_ASSET_CLASS,
+    quantity: round(quantity, 6),
+    market_price: round(marketPrice, 6),
+    avg_cost: round(avgCost, 6),
+    market_value: round(marketValue, 2),
+  };
+}
+
+function normalizeHoldingsInput(holdingsInput) {
+  const parsed = parseMaybeJson(holdingsInput, 'portfolio_json');
+  const list = Array.isArray(parsed)
+    ? parsed
+    : (Array.isArray(parsed?.holdings) ? parsed.holdings : []);
+
+  if (list.length === 0) {
+    throw new Error('portfolio_json must contain holdings array with at least one position');
+  }
+
+  const holdings = [];
+  for (let i = 0; i < list.length; i += 1) {
+    const normalized = normalizeHolding(list[i], i);
+    if (normalized) holdings.push(normalized);
+  }
+
+  if (holdings.length === 0) {
+    throw new Error('portfolio_json has no valid holdings after normalization');
+  }
+
+  const valued = holdings.filter(item => item.market_value != null && item.market_value > 0);
+  const usingEqualWeight = valued.length === 0;
+  const totalMarketValue = usingEqualWeight
+    ? holdings.length
+    : valued.reduce((sum, item) => sum + item.market_value, 0);
+
+  const weighted = holdings.map(item => {
+    const numerator = usingEqualWeight ? 1 : (item.market_value ?? 0);
+    const weight = totalMarketValue > 0 ? numerator / totalMarketValue : 0;
+    return {
+      ...item,
+      weight,
+      effective_market_value: usingEqualWeight ? null : item.market_value,
+    };
+  });
+
+  return {
+    holdings: weighted,
+    total_market_value: usingEqualWeight ? null : round(totalMarketValue, 2),
+    using_equal_weight: usingEqualWeight,
+  };
+}
+
+function normalizeDate(value, fallback) {
+  const text = normalizeText(value);
+  if (!text) return fallback;
+  const ms = Date.parse(text);
+  if (!Number.isFinite(ms)) return fallback;
+  return new Date(ms).toISOString().slice(0, 10);
+}
+
+function normalizeSeries(symbol, value) {
+  const parsed = parseMaybeJson(value, `market_data_json.${symbol}`);
+
+  let list = parsed;
+  if (!Array.isArray(list)) {
+    if (Array.isArray(parsed?.prices)) list = parsed.prices;
+    else if (Array.isArray(parsed?.history)) list = parsed.history;
+    else if (Array.isArray(parsed?.data)) list = parsed.data;
+    else list = [];
+  }
+
+  if (list.length === 0) return [];
+
+  if (typeof list[0] === 'number') {
+    return list
+      .map((close, idx) => ({ date: `idx_${idx}`, close: toNumber(close) }))
+      .filter(item => item.close != null && item.close > 0);
+  }
+
+  const rows = [];
+  for (let i = 0; i < list.length; i += 1) {
+    const item = list[i] ?? {};
+    const date = normalizeDate(item.date ?? item.day ?? item.trade_date ?? item.time, `idx_${i}`);
+    const close = toNumber(item.close ?? item.price ?? item.value ?? item.last);
+    if (close == null || close <= 0) continue;
+    rows.push({ date, close });
+  }
+
+  rows.sort((a, b) => a.date.localeCompare(b.date));
+  return rows;
+}
+
+function normalizeMarketDataInput(marketDataInput) {
+  const parsed = parseMaybeJson(marketDataInput, 'market_data_json');
+  if (!parsed) return {};
+
+  if (Array.isArray(parsed)) {
+    const bySymbol = {};
+    for (const item of parsed) {
+      const symbol = normalizeText(item?.symbol).toUpperCase();
+      if (!symbol) continue;
+      bySymbol[symbol] = normalizeSeries(symbol, item?.series ?? item?.prices ?? item?.history ?? []);
+    }
+    return bySymbol;
+  }
+
+  const bySymbol = {};
+  for (const [symbol, series] of Object.entries(parsed)) {
+    const key = normalizeText(symbol).toUpperCase();
+    if (!key) continue;
+    bySymbol[key] = normalizeSeries(key, series);
+  }
+  return bySymbol;
+}
+
+function pearsonCorrelation(xs, ys) {
+  if (xs.length !== ys.length || xs.length < 2) return null;
+
+  const n = xs.length;
+  const sumX = xs.reduce((acc, v) => acc + v, 0);
+  const sumY = ys.reduce((acc, v) => acc + v, 0);
+  const avgX = sumX / n;
+  const avgY = sumY / n;
+
+  let numerator = 0;
+  let denomX = 0;
+  let denomY = 0;
+  for (let i = 0; i < n; i += 1) {
+    const dx = xs[i] - avgX;
+    const dy = ys[i] - avgY;
+    numerator += dx * dy;
+    denomX += dx * dx;
+    denomY += dy * dy;
+  }
+
+  if (denomX <= 0 || denomY <= 0) return null;
+  return numerator / Math.sqrt(denomX * denomY);
+}
+
+function buildReturnMap(series) {
+  const returns = new Map();
+  for (let i = 1; i < series.length; i += 1) {
+    const prev = series[i - 1]?.close;
+    const curr = series[i]?.close;
+    if (!Number.isFinite(prev) || !Number.isFinite(curr) || prev <= 0) continue;
+    returns.set(series[i].date, (curr / prev) - 1);
+  }
+  return returns;
+}
+
+function buildCorrelationSection(holdings, marketDataBySymbol) {
+  const symbols = holdings
+    .map(item => item.symbol)
+    .filter(symbol => (marketDataBySymbol[symbol] ?? []).length >= 3);
+
+  if (symbols.length < 2) {
+    return {
+      available: false,
+      matrix: [],
+      avg_pairwise_correlation: null,
+      observations: 0,
+    };
+  }
+
+  const maxSymbols = 8;
+  const chosen = holdings
+    .filter(item => symbols.includes(item.symbol))
+    .sort((a, b) => b.weight - a.weight)
+    .slice(0, maxSymbols)
+    .map(item => item.symbol);
+
+  const returnsBySymbol = Object.fromEntries(
+    chosen.map(symbol => [symbol, buildReturnMap(marketDataBySymbol[symbol])])
+  );
+
+  const matrix = [];
+  const corrValues = [];
+
+  for (let i = 0; i < chosen.length; i += 1) {
+    for (let j = i + 1; j < chosen.length; j += 1) {
+      const a = chosen[i];
+      const b = chosen[j];
+      const mapA = returnsBySymbol[a];
+      const mapB = returnsBySymbol[b];
+      const commonDates = [...mapA.keys()].filter(date => mapB.has(date));
+      const xs = commonDates.map(date => mapA.get(date));
+      const ys = commonDates.map(date => mapB.get(date));
+      const corr = pearsonCorrelation(xs, ys);
+      if (corr == null) continue;
+
+      const rounded = round(corr, 4);
+      matrix.push({ pair: [a, b], correlation: rounded, observations: commonDates.length });
+      corrValues.push(corr);
+    }
+  }
+
+  const avg = corrValues.length > 0
+    ? corrValues.reduce((sum, value) => sum + value, 0) / corrValues.length
+    : null;
+
+  return {
+    available: matrix.length > 0,
+    matrix,
+    avg_pairwise_correlation: avg == null ? null : round(avg, 4),
+    observations: matrix.reduce((sum, item) => sum + item.observations, 0),
+  };
+}
+
+function buildDrawdownSection(holdings, marketDataBySymbol, maxPoints = 120) {
+  const symbols = holdings
+    .map(item => item.symbol)
+    .filter(symbol => (marketDataBySymbol[symbol] ?? []).length >= 2);
+  if (symbols.length === 0) {
+    return {
+      available: false,
+      max_drawdown: null,
+      curve: [],
+    };
+  }
+
+  const maps = {};
+  const baseClose = {};
+  const allDates = new Set();
+
+  for (const symbol of symbols) {
+    const series = marketDataBySymbol[symbol];
+    maps[symbol] = new Map(series.map(item => [item.date, item.close]));
+    baseClose[symbol] = series[0].close;
+    for (const item of series) allDates.add(item.date);
+  }
+
+  const sortedDates = [...allDates].sort();
+  const lastClose = {};
+  const curve = [];
+
+  for (const date of sortedDates) {
+    const availableSymbols = [];
+    for (const symbol of symbols) {
+      if (maps[symbol].has(date)) {
+        lastClose[symbol] = maps[symbol].get(date);
+      }
+      if (Number.isFinite(lastClose[symbol]) && Number.isFinite(baseClose[symbol]) && baseClose[symbol] > 0) {
+        availableSymbols.push(symbol);
+      }
+    }
+
+    if (availableSymbols.length === 0) continue;
+
+    const totalWeight = availableSymbols.reduce((sum, symbol) => {
+      const weight = holdings.find(item => item.symbol === symbol)?.weight ?? 0;
+      return sum + weight;
+    }, 0);
+
+    if (totalWeight <= 0) continue;
+
+    const portfolioIndex = availableSymbols.reduce((sum, symbol) => {
+      const weight = holdings.find(item => item.symbol === symbol)?.weight ?? 0;
+      const normalizedPrice = lastClose[symbol] / baseClose[symbol];
+      return sum + (weight / totalWeight) * normalizedPrice;
+    }, 0) * 100;
+
+    curve.push({ date, value: round(portfolioIndex, 4) });
+  }
+
+  if (curve.length < 2) {
+    return {
+      available: false,
+      max_drawdown: null,
+      curve,
+    };
+  }
+
+  let peak = curve[0].value;
+  let maxDrawdown = 0;
+  const withDrawdown = curve.map(point => {
+    if (point.value > peak) peak = point.value;
+    const drawdown = peak > 0 ? (point.value - peak) / peak : 0;
+    if (drawdown < maxDrawdown) maxDrawdown = drawdown;
+    return {
+      ...point,
+      drawdown: round(drawdown, 4),
+    };
+  });
+
+  return {
+    available: true,
+    max_drawdown: round(maxDrawdown, 4),
+    curve: downsampleCurve(withDrawdown, maxPoints),
+  };
+}
+
+function downsampleCurve(curve, maxPoints) {
+  if (!Number.isFinite(maxPoints) || maxPoints <= 0 || curve.length <= maxPoints) return curve;
+  if (maxPoints < 3) return [curve[0], curve[curve.length - 1]].filter(Boolean);
+
+  const step = (curve.length - 1) / (maxPoints - 1);
+  const result = [];
+  for (let i = 0; i < maxPoints; i += 1) {
+    const idx = Math.round(i * step);
+    result.push(curve[idx]);
+  }
+  result[0] = curve[0];
+  result[result.length - 1] = curve[curve.length - 1];
+  return result;
+}
+
+function buildAttributionSection(holdings, marketDataBySymbol) {
+  const bySymbol = [];
+  const bySectorMap = new Map();
+
+  for (const holding of holdings) {
+    const series = marketDataBySymbol[holding.symbol] ?? [];
+    if (series.length < 2) continue;
+    const first = series[0].close;
+    const last = series[series.length - 1].close;
+    if (!Number.isFinite(first) || !Number.isFinite(last) || first <= 0) continue;
+
+    const periodReturn = (last / first) - 1;
+    const contribution = holding.weight * periodReturn;
+    bySymbol.push({
+      symbol: holding.symbol,
+      weight: round(holding.weight, 4),
+      period_return: round(periodReturn, 4),
+      contribution: round(contribution, 4),
+    });
+
+    const sector = holding.sector || 'Unknown';
+    const current = bySectorMap.get(sector) ?? 0;
+    bySectorMap.set(sector, current + contribution);
+  }
+
+  const bySector = [...bySectorMap.entries()]
+    .map(([sector, contribution]) => ({ sector, contribution: round(contribution, 4) }))
+    .sort((a, b) => Math.abs(b.contribution) - Math.abs(a.contribution));
+
+  const portfolioReturn = bySymbol.reduce((sum, item) => sum + (item.contribution ?? 0), 0);
+
+  return {
+    available: bySymbol.length > 0,
+    estimated_period_return: bySymbol.length > 0 ? round(portfolioReturn, 4) : null,
+    by_symbol: bySymbol,
+    by_sector: bySector,
+  };
+}
+
+function buildConcentrationSection(holdings) {
+  const sorted = [...holdings].sort((a, b) => b.weight - a.weight);
+  const hhi = sorted.reduce((sum, item) => sum + (item.weight ** 2), 0);
+
+  return {
+    hhi: round(hhi, 4),
+    effective_position_count: hhi > 0 ? round(1 / hhi, 2) : null,
+    top1_weight: sorted[0] ? round(sorted[0].weight, 4) : null,
+    top3_weight: round(sorted.slice(0, 3).reduce((sum, item) => sum + item.weight, 0), 4),
+    top5_weight: round(sorted.slice(0, 5).reduce((sum, item) => sum + item.weight, 0), 4),
+    top_positions: sorted.slice(0, 10).map(item => ({
+      symbol: item.symbol,
+      name: item.name,
+      sector: item.sector,
+      weight: round(item.weight, 4),
+      market_value: item.market_value,
+    })),
+  };
+}
+
+function buildSectorDistribution(holdings) {
+  const bySector = new Map();
+  for (const item of holdings) {
+    const sector = item.sector || 'Unknown';
+    const current = bySector.get(sector) ?? { market_value: 0, weight: 0, count: 0 };
+    const marketValue = Number.isFinite(item.market_value) ? item.market_value : 0;
+    bySector.set(sector, {
+      market_value: current.market_value + marketValue,
+      weight: current.weight + item.weight,
+      count: current.count + 1,
+    });
+  }
+
+  return [...bySector.entries()]
+    .map(([sector, value]) => ({
+      sector,
+      position_count: value.count,
+      weight: round(value.weight, 4),
+      market_value: round(value.market_value, 2),
+    }))
+    .sort((a, b) => b.weight - a.weight);
+}
+
+function buildRiskFlags({ concentration, sectorDistribution, correlation, drawdown, missingMarketDataSymbols }) {
+  const flags = [];
+
+  if ((concentration.top1_weight ?? 0) >= 0.35) {
+    flags.push({
+      code: 'high_single_name_concentration',
+      severity: 'high',
+      message: `Top1 weight ${(concentration.top1_weight * 100).toFixed(1)}% exceeds 35%`,
+    });
+  }
+
+  if ((concentration.top3_weight ?? 0) >= 0.7) {
+    flags.push({
+      code: 'high_top3_concentration',
+      severity: 'medium',
+      message: `Top3 weight ${(concentration.top3_weight * 100).toFixed(1)}% exceeds 70%`,
+    });
+  }
+
+  if ((concentration.hhi ?? 0) >= 0.18) {
+    flags.push({
+      code: 'hhi_high',
+      severity: 'medium',
+      message: `HHI ${concentration.hhi.toFixed(3)} indicates elevated concentration`,
+    });
+  }
+
+  const unknownSector = sectorDistribution.find(item => item.sector === 'Unknown');
+  if ((unknownSector?.weight ?? 0) >= 0.25) {
+    flags.push({
+      code: 'sector_data_incomplete',
+      severity: 'low',
+      message: `Unknown sector weight ${(unknownSector.weight * 100).toFixed(1)}% is high`,
+    });
+  }
+
+  if ((correlation.avg_pairwise_correlation ?? 0) >= 0.75) {
+    flags.push({
+      code: 'high_correlation_cluster',
+      severity: 'medium',
+      message: `Average pairwise correlation ${correlation.avg_pairwise_correlation.toFixed(2)} is high`,
+    });
+  }
+
+  if ((drawdown.max_drawdown ?? 0) <= -0.2) {
+    flags.push({
+      code: 'drawdown_risk',
+      severity: 'high',
+      message: `Estimated max drawdown ${(drawdown.max_drawdown * 100).toFixed(1)}% is beyond 20%`,
+    });
+  }
+
+  if (missingMarketDataSymbols.length > 0) {
+    flags.push({
+      code: 'market_data_missing',
+      severity: 'low',
+      message: `Missing historical data for symbols: ${missingMarketDataSymbols.join(', ')}`,
+    });
+  }
+
+  return flags;
+}
+
+export function analyzePortfolioReport({
+  holdingsInput,
+  marketDataInput = null,
+  asOf = null,
+  maxDrawdownPoints = 120,
+} = {}) {
+  const normalized = normalizeHoldingsInput(holdingsInput);
+  const marketDataBySymbol = normalizeMarketDataInput(marketDataInput);
+
+  const holdings = normalized.holdings;
+  const missingMarketDataSymbols = holdings
+    .map(item => item.symbol)
+    .filter(symbol => (marketDataBySymbol[symbol] ?? []).length < 2);
+
+  const concentration = buildConcentrationSection(holdings);
+  const sectorDistribution = buildSectorDistribution(holdings);
+  const correlation = buildCorrelationSection(holdings, marketDataBySymbol);
+  const drawdown = buildDrawdownSection(holdings, marketDataBySymbol, maxDrawdownPoints);
+  const attribution = buildAttributionSection(holdings, marketDataBySymbol);
+
+  const riskFlags = buildRiskFlags({
+    concentration,
+    sectorDistribution,
+    correlation,
+    drawdown,
+    missingMarketDataSymbols,
+  });
+
+  return {
+    as_of: asOf || new Date().toISOString(),
+    source_risk: 'normal',
+    portfolio_summary: {
+      position_count: holdings.length,
+      total_market_value: normalized.total_market_value,
+      weight_mode: normalized.using_equal_weight ? 'equal_weight_fallback' : 'market_value',
+      missing_market_data_count: missingMarketDataSymbols.length,
+    },
+    concentration,
+    sector_distribution: sectorDistribution,
+    correlation,
+    drawdown,
+    attribution,
+    risk_flags: riskFlags,
+    compliance: {
+      contains_trade_recommendation: false,
+      disclaimer: DISCLAIMER,
+    },
+  };
+}

package/mcp-servers/portfolio-analysis/index.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+
+import { analyzePortfolioReport } from './core.js';
+
+const server = new McpServer({ name: 'portfolio-analysis', version: '0.1.0' });
+
+server.tool(
+  'portfolio_analyze',
+  'Analyze a portfolio using holdings and optional historical market data. Returns concentration, sector distribution, correlation, drawdown, attribution, and risk flags. No trade recommendation is produced.',
+  {
+    portfolio_json: z.string().describe('Portfolio JSON string. Accepts either { holdings: [...] } or [...] from portfolio_read output.'),
+    market_data_json: z.string().optional().describe('Optional market history JSON keyed by symbol. Each symbol can map to [{date,close}] or {prices:[...]}.'),
+    as_of: z.string().optional().describe('As-of timestamp override (ISO8601 recommended).'),
+    max_drawdown_points: z.number().optional().describe('Maximum points returned in drawdown curve, default 120.'),
+  },
+  async ({ portfolio_json, market_data_json, as_of, max_drawdown_points }) => {
+    try {
+      const report = analyzePortfolioReport({
+        holdingsInput: portfolio_json,
+        marketDataInput: market_data_json,
+        asOf: as_of,
+        maxDrawdownPoints: max_drawdown_points,
+      });
+
+      return {
+        content: [{
+          type: 'text',
+          text: JSON.stringify(report, null, 2),
+        }],
+      };
+    } catch (error) {
+      return {
+        isError: true,
+        content: [{ type: 'text', text: `Error: ${error.message}` }],
+      };
+    }
+  }
+);
+
+const transport = new StdioServerTransport();
+await server.connect(transport);
+console.error('[portfolio-analysis] MCP Server started');