aria-code 0.52.0__py3-none-any.whl

aria_code/agents/financial/technical.py

@@ -0,0 +1,258 @@
+"""
+agents/financial/technical.py — 技术分析 Agent
+===============================================
+分析 K线形态、均线结构、MACD/RSI、布林带、关键价位。
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, List
+
+from ..base import BaseAgent, AgentResult
+
+logger = logging.getLogger(__name__)
+
+
+class TechnicalAgent(BaseAgent):
+
+    name        = "technical"
+    description = "技术分析：图形形态、动量指标、关键价位"
+
+    _SYSTEM = (
+        "You are a quantitative technical analyst. Analyze price action, "
+        "chart patterns, momentum indicators (RSI, MACD), moving averages, "
+        "and Bollinger Bands. Provide concise, data-driven insights. "
+        "Conclude with a clear directional bias: BULLISH / NEUTRAL / BEARISH."
+    )
+
+    async def fetch_data(self, symbol: str) -> Dict[str, Any]:
+        data = await super().fetch_data(symbol)
+        if self.data:
+            try:
+                h = self.data.history(symbol, days=120)
+                if h and h.data is not None:
+                    df = h.data
+                    data["history"] = _compute_indicators(df)
+            except Exception as e:
+                logger.debug(f"[technical] fetch history {symbol}: {e}")
+        return data
+
+    async def analyze(self, symbol: str, data: Dict[str, Any]) -> AgentResult:
+        quote   = data.get("quote", {})
+        history = data.get("history", {})
+        price   = quote.get("price", 0)
+
+        # 提取指标用于 prompt
+        indicators = _format_indicators(history)
+        pattern    = history.get("pattern", "无特殊形态")
+
+        prompt = (
+            f"Stock: {symbol}  Current Price: {price}\n"
+            f"Technical Indicators:\n{indicators}\n"
+            f"Pattern: {pattern}\n\n"
+            "Provide: 1) Trend assessment 2) Key support/resistance levels "
+            "3) Signal strength 4) Short-term outlook (3-10 days) "
+            "5) Conclusion: BULLISH / NEUTRAL / BEARISH"
+        )
+
+        analysis = await self._call_llm(self._SYSTEM, prompt, max_tokens=600, quote=quote)
+        if not analysis:
+            analysis = _template_analysis(symbol, price, history)
+
+        signal     = _extract_signal(analysis, history)
+        confidence = history.get("signal_strength", 0.5)
+        key_points = _extract_key_points(history, price)
+
+        return AgentResult(
+            agent=self.name, symbol=symbol,
+            analysis=analysis, confidence=confidence,
+            signal=signal, key_points=key_points,
+            data_used={"price": price, "indicators": history},
+        )
+
+
+# ── 技术指标计算 ──────────────────────────────────────────────────────────────
+
+def _compute_indicators(df) -> Dict[str, Any]:
+    """从 OHLCV DataFrame 计算常用指标"""
+    try:
+        import numpy as np
+        close = df["close"].values if "close" in df.columns else df.iloc[:, -1].values
+
+        # MA
+        ma5  = float(np.mean(close[-5:]))  if len(close) >= 5  else 0
+        ma20 = float(np.mean(close[-20:])) if len(close) >= 20 else 0
+        ma60 = float(np.mean(close[-60:])) if len(close) >= 60 else 0
+
+        # RSI(14)
+        delta = np.diff(close[-15:])
+        gains = np.where(delta > 0, delta, 0)
+        losses= np.where(delta < 0, -delta, 0)
+        rs    = np.mean(gains[-14:]) / (np.mean(losses[-14:]) + 1e-9)
+        rsi   = round(100 - 100 / (1 + rs), 1)
+
+        # MACD
+        ema12 = _ema(close, 12)
+        ema26 = _ema(close, 26)
+        macd  = ema12 - ema26
+        signal= _ema_arr(macd[-50:] if len(macd) >= 50 else macd, 9)
+        macd_val  = round(float(macd[-1]), 4)
+        signal_val= round(float(signal[-1]), 4)
+        hist_val  = round(macd_val - signal_val, 4)
+
+        # 布林带
+        std20 = float(np.std(close[-20:])) if len(close) >= 20 else 0
+        bb_up = round(ma20 + 2 * std20, 2)
+        bb_lo = round(ma20 - 2 * std20, 2)
+
+        # 信号强度
+        price   = float(close[-1])
+        ma_bull = price > ma5 > ma20
+        strength = 0.5
+        if ma_bull and macd_val > signal_val:
+            strength = 0.75
+        elif not ma_bull and macd_val < signal_val:
+            strength = 0.25
+
+        # 形态检测（简单）
+        pattern = _detect_simple_pattern(close)
+
+        return {
+            "price":   round(price, 2),
+            "ma5":     round(ma5, 2),
+            "ma20":    round(ma20, 2),
+            "ma60":    round(ma60, 2),
+            "rsi":     rsi,
+            "macd":    macd_val,
+            "macd_signal": signal_val,
+            "macd_hist":   hist_val,
+            "bb_upper":    bb_up,
+            "bb_lower":    bb_lo,
+            "signal_strength": strength,
+            "pattern": pattern,
+        }
+    except Exception as e:
+        logger.debug(f"compute_indicators 失败: {e}")
+        return {}
+
+
+def _ema(arr, period):
+    import numpy as np
+    k = 2 / (period + 1)
+    ema = np.zeros(len(arr))
+    ema[0] = arr[0]
+    for i in range(1, len(arr)):
+        ema[i] = arr[i] * k + ema[i-1] * (1 - k)
+    return ema
+
+def _ema_arr(arr, period):
+    return _ema(arr, period)
+
+def _detect_simple_pattern(close) -> str:
+    if len(close) < 3:
+        return "数据不足"
+    o, h, c = close[-3], close[-2], close[-1]
+    if c > o and c > h and (c - h) > abs(c - o) * 2:
+        return "锤子线"
+    if c > o and o < close[-4] and c > close[-4]:
+        return "阳线吞噬"
+    if abs(c - o) / (max(close[-3:]) - min(close[-3:]) + 1e-9) < 0.1:
+        return "十字星"
+    return "无特殊形态"
+
+
+def _format_indicators(history: Dict) -> str:
+    if not history:
+        return "  (无指标数据)"
+    return (
+        f"  MA5={history.get('ma5',0):.2f}  MA20={history.get('ma20',0):.2f}  "
+        f"MA60={history.get('ma60',0):.2f}\n"
+        f"  RSI={history.get('rsi',50):.1f}  "
+        f"MACD={history.get('macd',0):.4f} Signal={history.get('macd_signal',0):.4f}\n"
+        f"  BB Upper={history.get('bb_upper',0):.2f}  BB Lower={history.get('bb_lower',0):.2f}"
+    )
+
+
+def _extract_signal(analysis: str, history: Dict) -> str:
+    import re as _re
+    text = analysis.upper()
+
+    # Unambiguous strong signals always win
+    if "STRONG_BUY" in text or "强烈买入" in text:
+        return "STRONG_BUY"
+    if "STRONG_SELL" in text or "强烈卖出" in text:
+        return "STRONG_SELL"
+
+    # The LLM prompt asks the model to conclude with BULLISH/NEUTRAL/BEARISH.
+    # Use the LAST occurrence — it's the conclusion, not mid-text context like
+    # "a potential BULLISH reversal" appearing before "currently BEARISH".
+    matches = _re.findall(r'\b(BULLISH|BEARISH|NEUTRAL)\b', text)
+    if matches:
+        last = matches[-1]
+        if last == "BULLISH":
+            return "BUY"
+        if last == "BEARISH":
+            return "SELL"
+        # NEUTRAL → fall through to quantitative check below
+
+    # Explicit Chinese directional signals
+    if "看多" in analysis:
+        return "BUY"
+    if "看空" in analysis:
+        return "SELL"
+
+    # Quantitative fallback: score RSI + MACD crossover
+    rsi  = history.get("rsi", 50)
+    macd = history.get("macd", 0)
+    msig = history.get("macd_signal", 0)
+    score = 0
+    if rsi < 30:    score += 2   # oversold — strong mean-reversion signal
+    elif rsi < 45:  score -= 1
+    elif rsi > 70:  score -= 2   # overbought
+    elif rsi > 55:  score += 1
+    if macd > msig: score += 1
+    elif macd < msig: score -= 1
+    if score >= 2:  return "BUY"
+    if score <= -2: return "SELL"
+    return "HOLD"
+
+
+def _extract_key_points(history: Dict, price: float) -> List[str]:
+    points = []
+    rsi = history.get("rsi", 50)
+    ma20 = history.get("ma20", 0)
+    ma60 = history.get("ma60", 0)
+    if rsi < 35:
+        points.append(f"RSI超卖({rsi:.0f})，有反弹机会")
+    elif rsi > 70:
+        points.append(f"RSI超买({rsi:.0f})，注意回调风险")
+    if ma20 > 0:
+        diff_pct = (price - ma20) / ma20 * 100
+        points.append(f"距MA20 {diff_pct:+.1f}%")
+    macd = history.get("macd", 0)
+    sig  = history.get("macd_signal", 0)
+    if macd > sig and history.get("macd_hist", 0) > 0:
+        points.append("MACD金叉，多头动能")
+    elif macd < sig:
+        points.append("MACD死叉，空头压力")
+    pattern = history.get("pattern", "")
+    if pattern and pattern != "无特殊形态":
+        points.append(f"K线形态: {pattern}")
+    return points
+
+
+def _template_analysis(symbol: str, price: float, history: Dict) -> str:
+    rsi  = history.get("rsi", 50)
+    ma20 = history.get("ma20", 0)
+    macd = history.get("macd", 0)
+    sig  = history.get("macd_signal", 0)
+    trend = "上升趋势" if price > ma20 else "下降趋势"
+    momentum = "偏多" if macd > sig else "偏空"
+    return (
+        f"{symbol} 技术面分析（模板）:\n"
+        f"• 当前价格 {price}，处于 {trend}（MA20={ma20:.2f}）\n"
+        f"• RSI={rsi:.0f}，{'超卖' if rsi<35 else '超买' if rsi>70 else '正常区间'}\n"
+        f"• MACD 动能{momentum}\n"
+        f"• 整体技术面{'BULLISH' if momentum=='偏多' and trend=='上升趋势' else 'NEUTRAL'}"
+    )

aria_code/agents/orchestrator.py

@@ -0,0 +1,44 @@
+from typing import Any
+import json
+from .base import BaseAgent
+from .registry import get_registry
+
+class OrchestratorAgent(BaseAgent):
+    name = "orchestrator"
+    description = "动态分析用户意图，从注册中心挑选最合适的专业智能体进行流转和编排。"
+
+    def get_prompt(self, context: Any) -> str:
+        registry = get_registry()
+        agents = registry.list()
+        # Remove orchestrator itself from the list to avoid recursive loop
+        agents = [a for a in agents if a["name"] != "orchestrator"]
+        
+        agents_info = "\n".join([f"- {a['name']}: {a['description']}" for a in agents])
+        
+        prompt = (
+            "你是一个高级架构师智能体 (Orchestrator)。\n"
+            "你的任务是分析用户的请求，并从以下可用的专业智能体库中，挑选出最合适的一个或多个智能体来解决问题。\n"
+            "可用智能体库:\n"
+            f"{agents_info}\n\n"
+            "请直接输出 JSON 格式的结果，包含两项:\n"
+            "1. 'plan': 简要的一句话解释为什么选择这些智能体。\n"
+            "2. 'agents': 一个字符串列表，包含需要调用的智能体名称（最多选 3 个）。\n"
+            "注意: 必须且只能输出合法的 JSON，不要有任何代码块包裹或前言后语。\n"
+        )
+        return prompt
+
+    def get_tools(self) -> list:
+        return []
+
+    async def execute(self, provider, model_name: str, **kwargs) -> Any:
+        context = kwargs.get("context", "")
+        # Because Orchestrator doesn't have its own tools, it just calls the LLM with a basic generate_text
+        # We need a simple non-streaming call or accumulate the stream.
+        from aria_cli import send_message
+        prompt = self.get_prompt(context)
+        
+        # Or we can just use the provider directly if we have a simple function.
+        # But BaseAgent usually operates via `AgentTeam` which handles the loops.
+        # Since Orchestrator is special, it should probably be used by the CLI directly.
+        pass
+

aria_code/agents/portfolio_agent.py

@@ -0,0 +1,363 @@
+"""
+agents/portfolio_agent.py — 组合级分析 Agent
+=============================================
+跨标的分析：相关性矩阵、波动率、集中度风险、再平衡建议。
+数据源：yfinance 1年日线（免费，无需 key）
+触发：/portfolio analyze [symbols…]
+      /portfolio rebalance [symbols…]
+"""
+
+from __future__ import annotations
+
+import logging
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+from .base import BaseAgent, AgentResult
+
+logger = logging.getLogger(__name__)
+
+
+class PortfolioAgent(BaseAgent):
+
+    name        = "portfolio"
+    description = "组合级分析 — 相关性、分散度、整体风险、再平衡建议"
+
+    _SYSTEM = (
+        "You are a portfolio risk analyst. Given price history and statistics for "
+        "a portfolio of stocks, your job is to:\n"
+        "1. Evaluate overall portfolio risk (Low / Medium / High)\n"
+        "2. Identify diversification gaps — highly correlated pairs, sector crowding\n"
+        "3. Flag concentration risk if any single position dominates\n"
+        "4. Give 2-3 actionable rebalancing suggestions (be specific: which stocks to "
+        "trim / add / replace and why)\n"
+        "5. End with a one-line verdict: HEALTHY / NEEDS_ATTENTION / HIGH_RISK\n"
+        "Be concrete. Avoid boilerplate."
+    )
+
+    # ── BaseAgent compatibility ───────────────────────────────────────────────
+
+    async def fetch_data(self, symbol: str) -> Dict[str, Any]:
+        symbols = [s.strip().upper() for s in symbol.split(",") if s.strip()]
+        return await self.fetch_portfolio_data(symbols)
+
+    async def analyze(self, symbol: str, data: Dict[str, Any]) -> AgentResult:
+        symbols = data.get("symbols") or [s.strip().upper() for s in symbol.split(",") if s.strip()]
+        return await self.analyze_portfolio(symbols, data)
+
+    # ── Multi-symbol interface ────────────────────────────────────────────────
+
+    async def run_portfolio(
+        self, symbols: List[str], weights: Optional[Dict[str, float]] = None
+    ) -> AgentResult:
+        """Primary entry point for multi-symbol analysis.
+
+        weights: optional {symbol: dollar_cost_basis} from the user's real
+        holdings (portfolio_ledger.PortfolioLedger.get_positions()). Without
+        it, every position is silently treated as equal-weight — which used
+        to be the ONLY mode this agent supported, so a user who actually
+        holds 80% NVDA and 20% everything else got a risk verdict computed
+        on a fictional 1/n-weighted portfolio instead of their real exposure.
+        """
+        data   = await self.fetch_portfolio_data(symbols, weights=weights)
+        return await self.analyze_portfolio(symbols, data)
+
+    async def fetch_portfolio_data(
+        self, symbols: List[str], weights: Optional[Dict[str, float]] = None
+    ) -> Dict[str, Any]:
+        data: Dict[str, Any] = {"symbols": symbols}
+        if len(symbols) < 2:
+            return data
+
+        price_series: Dict[str, Any] = {}
+        latest_prices: Dict[str, float] = {}
+        sector_map: Dict[str, str] = {}
+
+        for sym in symbols:
+            try:
+                import yfinance as yf
+                ticker = yf.Ticker(sym)
+                hist   = ticker.history(period="1y")
+                if not hist.empty and len(hist) > 20:
+                    price_series[sym] = hist["Close"]
+                    latest_prices[sym] = float(hist["Close"].iloc[-1])
+                    # Try to get sector info
+                    try:
+                        info = ticker.info or {}
+                        sector = info.get("sector") or info.get("industry", "")
+                        if sector:
+                            sector_map[sym] = sector
+                    except Exception:
+                        pass
+            except Exception as e:
+                logger.debug("[portfolio] yfinance %s: %s", sym, e)
+
+        if len(price_series) < 2:
+            data["error"] = "insufficient_data"
+            return data
+
+        try:
+            import pandas as pd
+            import numpy as np
+
+            df      = pd.DataFrame(price_series).dropna()
+            returns = df.pct_change().dropna()
+
+            corr        = returns.corr()
+            ann_returns = (returns.mean() * 252).round(4)
+            ann_vols    = (returns.std() * np.sqrt(252)).round(4)
+            cov_matrix  = returns.cov() * 252
+            valid_syms  = list(df.columns)
+            n           = len(valid_syms)
+            if weights and any(weights.get(s, 0) > 0 for s in valid_syms):
+                raw = np.array([max(weights.get(s, 0.0), 0.0) for s in valid_syms])
+                w_vec = raw / raw.sum() if raw.sum() > 0 else np.ones(n) / n
+                weight_source = "ledger"
+            else:
+                w_vec = np.ones(n) / n
+                weight_source = "equal"
+            port_vol = float(np.sqrt(w_vec @ cov_matrix.values @ w_vec))
+            position_weights = {s: round(float(w_vec[i]), 4) for i, s in enumerate(valid_syms)}
+
+            # High correlation pairs (|r| > 0.70)
+            high_corr: List[Dict] = []
+            for i in range(len(valid_syms)):
+                for j in range(i + 1, len(valid_syms)):
+                    c = float(corr.iloc[i, j])
+                    if abs(c) > 0.70:
+                        high_corr.append({
+                            "sym1": valid_syms[i],
+                            "sym2": valid_syms[j],
+                            "corr": round(c, 3),
+                        })
+
+            # Diversification ratio: weighted avg individual vol / portfolio vol.
+            # Was np.mean() (unweighted) despite the comment already claiming
+            # "weighted" — with real ledger weights now available, actually weight it.
+            avg_vol = float(sum(w_vec[i] * float(ann_vols.get(s, 0)) for i, s in enumerate(valid_syms)))
+            div_ratio = round(avg_vol / port_vol, 2) if port_vol > 0 else 1.0
+
+            # 52-week return per symbol
+            returns_1y: Dict[str, float] = {}
+            for sym in valid_syms:
+                first = float(df[sym].iloc[0])
+                last  = float(df[sym].iloc[-1])
+                if first > 0:
+                    returns_1y[sym] = round((last - first) / first, 4)
+
+            # Best/worst performer
+            sorted_ret = sorted(returns_1y.items(), key=lambda x: x[1], reverse=True)
+
+            data.update({
+                "valid_symbols": valid_syms,
+                "latest_prices": latest_prices,
+                "ann_returns":   {s: float(v) for s, v in ann_returns.items()},
+                "ann_vols":      {s: float(v) for s, v in ann_vols.items()},
+                "port_vol_ann":  round(port_vol, 4),
+                "div_ratio":     div_ratio,
+                "corr_matrix":   corr.round(3).to_dict(),
+                "high_corr":     high_corr,
+                "returns_1y":    returns_1y,
+                "best_performer":  sorted_ret[0]  if sorted_ret else None,
+                "worst_performer": sorted_ret[-1] if sorted_ret else None,
+                "sector_map":    sector_map,
+                "position_weights": position_weights,
+                "weight_source":    weight_source,
+            })
+
+        except ImportError:
+            data["error"] = "pandas/numpy not available"
+        except Exception as e:
+            logger.warning("[portfolio] stats calculation: %s", e)
+            data["error"] = str(e)
+
+        return data
+
+    async def analyze_portfolio(
+        self, symbols: List[str], data: Dict[str, Any]
+    ) -> AgentResult:
+        if len(symbols) < 2:
+            return AgentResult(
+                agent=self.name, symbol=",".join(symbols),
+                analysis="组合分析需要至少 2 个标的。",
+                confidence=0.0, signal="HOLD",
+                key_points=["标的数量不足"],
+            )
+
+        if data.get("error") == "insufficient_data":
+            return AgentResult(
+                agent=self.name, symbol=",".join(symbols),
+                analysis="无法获取足够的历史价格数据进行组合分析。",
+                confidence=0.3, signal="HOLD",
+                key_points=["历史数据不足（需要 >20 个交易日）"],
+            )
+
+        valid_syms = data.get("valid_symbols", symbols)
+        port_block = _format_portfolio_stats(data)
+        weight_desc = ("your actual position sizes" if data.get("weight_source") == "ledger"
+                       else "equal weight — no real position sizes available")
+
+        prompt = (
+            f"Portfolio: {', '.join(valid_syms)} ({len(valid_syms)} positions, weighted by {weight_desc})\n\n"
+            f"{port_block}\n\n"
+            "Analyze this portfolio:\n"
+            "1. Overall risk level (Low / Medium / High)\n"
+            "2. Diversification quality — any dangerous correlations or sector crowding?\n"
+            "3. Top 2-3 concerns (be specific about which symbols)\n"
+            "4. Concrete rebalancing suggestions\n"
+            "5. End with: HEALTHY / NEEDS_ATTENTION / HIGH_RISK"
+        )
+
+        analysis = await self._call_llm(self._SYSTEM, prompt, max_tokens=650)
+        if not analysis:
+            analysis = _template_analysis(valid_syms, data)
+
+        verdict    = _extract_verdict(analysis)
+        signal     = _verdict_to_signal(verdict)
+        confidence = _estimate_confidence(data)
+        key_points = _build_key_points(data, verdict)
+
+        return AgentResult(
+            agent=self.name,
+            symbol=",".join(valid_syms),
+            analysis=analysis,
+            confidence=confidence,
+            signal=signal,
+            key_points=key_points,
+            data_used={
+                "n": len(valid_syms),
+                "port_vol_ann": data.get("port_vol_ann"),
+                "div_ratio": data.get("div_ratio"),
+                "high_corr_count": len(data.get("high_corr", [])),
+            },
+        )
+
+
+# ── Helpers ───────────────────────────────────────────────────────────────────
+
+def _format_portfolio_stats(d: Dict) -> str:
+    lines = []
+
+    # Returns & volatility table
+    vols    = d.get("ann_vols", {})
+    rets    = d.get("ann_returns", {})
+    rets_1y = d.get("returns_1y", {})
+    pweights = d.get("position_weights", {})
+    if vols:
+        lines.append("Symbol │ Weight │ Ann.Vol │ Ann.Ret │ 1Y Return")
+        lines.append("─" * 52)
+        for sym in d.get("valid_symbols", list(vols)):
+            v  = vols.get(sym, 0)
+            r  = rets.get(sym, 0)
+            y  = rets_1y.get(sym, 0)
+            w  = pweights.get(sym, 0)
+            lines.append(
+                f"{sym:<6} │ {w*100:>5.1f}% │ {v*100:>6.1f}% │ {r*100:>6.1f}% │ {y*100:>+7.1f}%"
+            )
+
+    port_vol = d.get("port_vol_ann", 0)
+    div_r    = d.get("div_ratio", 1)
+    if port_vol:
+        lines.append(f"\nPortfolio Ann.Vol: {port_vol*100:.1f}%")
+        lines.append(f"Diversification Ratio: {div_r:.2f}x "
+                     f"({'good' if div_r >= 1.3 else 'poor'})")
+
+    high_corr = d.get("high_corr", [])
+    if high_corr:
+        lines.append("\nHigh-Correlation Pairs (|r|>0.70):")
+        for p in high_corr[:5]:
+            lines.append(f"  {p['sym1']} ↔ {p['sym2']}: {p['corr']:+.2f}")
+
+    sectors = d.get("sector_map", {})
+    if sectors:
+        from collections import Counter
+        sector_counts = Counter(sectors.values())
+        dominant = [(s, c) for s, c in sector_counts.items() if c >= 2]
+        if dominant:
+            lines.append("\nSector Concentration:")
+            for sec, cnt in dominant:
+                lines.append(f"  {sec}: {cnt} positions")
+
+    best  = d.get("best_performer")
+    worst = d.get("worst_performer")
+    if best and worst:
+        lines.append(f"\nBest 1Y: {best[0]} ({best[1]*100:+.1f}%)")
+        lines.append(f"Worst 1Y: {worst[0]} ({worst[1]*100:+.1f}%)")
+
+    return "\n".join(lines)
+
+
+def _extract_verdict(analysis: str) -> str:
+    text = analysis.upper()
+    if "HIGH_RISK" in text or "HIGH RISK" in text:
+        return "HIGH_RISK"
+    if "NEEDS_ATTENTION" in text or "NEEDS ATTENTION" in text:
+        return "NEEDS_ATTENTION"
+    if "HEALTHY" in text:
+        return "HEALTHY"
+    return "NEEDS_ATTENTION"
+
+
+def _verdict_to_signal(verdict: str) -> str:
+    return {"HEALTHY": "HOLD", "NEEDS_ATTENTION": "SELL", "HIGH_RISK": "SELL"}.get(verdict, "HOLD")
+
+
+def _estimate_confidence(d: Dict) -> float:
+    base = 0.60
+    n    = len(d.get("valid_symbols", []))
+    if n >= 5:
+        base += 0.05
+    if d.get("div_ratio", 1) < 1.1:
+        base += 0.05
+    return min(round(base, 2), 0.75)
+
+
+def _build_key_points(d: Dict, verdict: str) -> List[str]:
+    pts = []
+    n   = len(d.get("valid_symbols", []))
+    if d.get("weight_source") == "ledger":
+        pts.append(f"{n} 个标的，按真实持仓成本加权")
+    else:
+        pts.append(f"{n} 个标的，等权配置（无真实持仓数据，非实际风险暴露）")
+
+    port_vol = d.get("port_vol_ann", 0)
+    if port_vol:
+        risk_lv = "高风险" if port_vol > 0.30 else ("中等" if port_vol > 0.18 else "低风险")
+        pts.append(f"组合年化波动 {port_vol*100:.1f}%（{risk_lv}）")
+
+    div_r = d.get("div_ratio", 1)
+    if div_r < 1.1:
+        pts.append(f"分散度不足（ratio {div_r:.2f}x，标的相关性高）")
+    else:
+        pts.append(f"分散度合理（ratio {div_r:.2f}x）")
+
+    high_corr = d.get("high_corr", [])
+    if high_corr:
+        top = high_corr[0]
+        pts.append(f"最高相关对: {top['sym1']}↔{top['sym2']} ({top['corr']:+.2f})")
+
+    pts.append(f"整体评级: {verdict}")
+    return pts[:6]
+
+
+def _template_analysis(symbols: List[str], d: Dict) -> str:
+    high_corr = d.get("high_corr", [])
+    port_vol  = d.get("port_vol_ann", 0)
+    div_r     = d.get("div_ratio", 1)
+
+    verdict = "NEEDS_ATTENTION"
+    if not high_corr and port_vol < 0.20 and div_r >= 1.2:
+        verdict = "HEALTHY"
+    elif len(high_corr) >= 3 or port_vol > 0.30:
+        verdict = "HIGH_RISK"
+
+    lines = [f"{','.join(symbols)} 组合分析报告（模板）"]
+    lines.append(f"年化波动率: {port_vol*100:.1f}%")
+    lines.append(f"分散度系数: {div_r:.2f}x")
+    if high_corr:
+        lines.append(f"高相关对 {len(high_corr)} 组，最高: "
+                     f"{high_corr[0]['sym1']}↔{high_corr[0]['sym2']} {high_corr[0]['corr']:+.2f}")
+    else:
+        lines.append("无显著高相关对，分散良好。")
+    lines.append(f"\n{verdict}")
+    return "\n".join(lines)