aria-code 0.167.0__py3-none-win_amd64.whl

aria_code/agents/financial/news.py

@@ -0,0 +1,231 @@
+"""
+agents/financial/news.py — 新闻与舆情分析 Agent
+================================================
+分析近期新闻标题、公告和媒体情绪，识别关键事件类型。
+数据源：yfinance.news（美股/港股）、akshare公告（A股，可选）
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from datetime import datetime, timezone
+from typing import Any, Dict, List
+
+from ..base import BaseAgent, AgentResult
+
+logger = logging.getLogger(__name__)
+
+_EVENT_KEYWORDS = {
+    "earnings":    ["earnings", "revenue", "profit", "EPS", "业绩", "净利润", "营收"],
+    "upgrade":     ["upgrade", "outperform", "buy", "overweight", "上调", "买入"],
+    "downgrade":   ["downgrade", "underperform", "sell", "underweight", "下调", "卖出"],
+    "insider":     ["insider", "director", "CEO", "增持", "减持", "大股东"],
+    "regulatory":  ["SEC", "CSRC", "证监会", "regulatory", "investigation", "调查"],
+    "dividend":    ["dividend", "分红", "派息", "股息"],
+    "merger":      ["merger", "acquisition", "takeover", "合并", "收购"],
+}
+
+
+class NewsAgent(BaseAgent):
+
+    name        = "news"
+    description = "新闻与舆情分析 — 近期重大事件、公告、媒体情绪"
+
+    _SYSTEM = (
+        "You are a financial news analyst. Analyze the provided news headlines "
+        "and summaries for a stock. Identify the most impactful recent events, "
+        "classify sentiment (POSITIVE / NEUTRAL / NEGATIVE), and assess likely "
+        "price impact. Focus on material events: earnings, analyst changes, "
+        "regulatory actions, M&A, and insider activity. "
+        "Conclude with: POSITIVE / NEUTRAL / NEGATIVE"
+    )
+
+    async def fetch_data(self, symbol: str) -> Dict[str, Any]:
+        data = await super().fetch_data(symbol)
+        news_items: List[Dict] = []
+
+        # 1. yfinance news (works for US / HK stocks)
+        try:
+            import yfinance as yf
+            ticker = yf.Ticker(symbol)
+            raw = ticker.news or []
+            now = datetime.now(timezone.utc).timestamp()
+            for item in raw[:12]:
+                pub = item.get("providerPublishTime", 0)
+                age_days = (now - pub) / 86400 if pub else 999
+                news_items.append({
+                    "title":    item.get("title", ""),
+                    "summary":  item.get("summary", "") or item.get("description", ""),
+                    "source":   item.get("publisher", ""),
+                    "age_days": round(age_days, 1),
+                })
+        except Exception as e:
+            logger.debug("[news] yfinance fetch failed for %s: %s", symbol, e)
+
+        # 2. akshare A-share announcements (optional)
+        if not news_items and re.match(r"^[036]\d{5}$", symbol):
+            try:
+                import akshare as ak
+                df = ak.stock_news_em(symbol=symbol)
+                if df is not None and not df.empty:
+                    for _, row in df.head(10).iterrows():
+                        news_items.append({
+                            "title":    str(row.get("新闻标题", "")),
+                            "summary":  str(row.get("新闻内容", ""))[:200],
+                            "source":   str(row.get("新闻来源", "")),
+                            "age_days": 0,
+                        })
+            except Exception as e:
+                logger.debug("[news] akshare fetch failed for %s: %s", symbol, e)
+
+        data["news"] = news_items
+        return data
+
+    async def analyze(self, symbol: str, data: Dict[str, Any]) -> AgentResult:
+        news  = data.get("news", [])
+        quote = data.get("quote", {})
+        price = quote.get("price", 0)
+
+        if not news:
+            return AgentResult(
+                agent=self.name, symbol=symbol,
+                analysis=(f"{symbol}: 未获取到近期新闻数据。" if str(self.lang).startswith("zh")
+                          else f"{symbol}: no recent news."),
+                confidence=0.3, signal="HOLD",
+                key_points=["无近期新闻数据" if str(self.lang).startswith("zh") else "no recent news"],
+            )
+
+        events = _classify_events(news)
+        news_block = _format_news(news[:8])
+
+        prompt = (
+            f"Stock: {symbol}  Price: {price}\n\n"
+            f"Recent News ({len(news)} items):\n{news_block}\n\n"
+            "Tasks:\n"
+            "1. Identify the 2-3 most impactful recent events\n"
+            "2. Classify overall media sentiment\n"
+            "3. Assess potential price catalyst (short-term, 1-5 days)\n"
+            "4. Conclude with: POSITIVE / NEUTRAL / NEGATIVE"
+        )
+
+        analysis = await self._call_llm(self._SYSTEM, prompt, max_tokens=500)
+        if not analysis:
+            analysis = _template_analysis(symbol, news, events, lang=self.lang)
+
+        signal     = _extract_signal(analysis, events)
+        confidence = _estimate_confidence(news, events)
+        key_points = _build_key_points(news, events, lang=self.lang)
+
+        return AgentResult(
+            agent=self.name, symbol=symbol,
+            analysis=analysis,
+            confidence=confidence,
+            signal=signal,
+            key_points=key_points,
+            data_used={"news_count": len(news), "events": list(events.keys())},
+        )
+
+
+# ── Helpers ───────────────────────────────────────────────────────────────────
+
+def _classify_events(news: List[Dict]) -> Dict[str, int]:
+    counts: Dict[str, int] = {}
+    for item in news:
+        text = (item.get("title", "") + " " + item.get("summary", "")).lower()
+        for event_type, keywords in _EVENT_KEYWORDS.items():
+            if any(kw.lower() in text for kw in keywords):
+                counts[event_type] = counts.get(event_type, 0) + 1
+    return counts
+
+
+def _format_news(news: List[Dict]) -> str:
+    lines = []
+    for i, item in enumerate(news, 1):
+        age = f"{item['age_days']:.0f}d ago" if item.get("age_days", 999) < 30 else ""
+        src = item.get("source", "")
+        title = item.get("title", "").strip()
+        lines.append(f"{i}. [{src}] {title} {age}".strip())
+    return "\n".join(lines)
+
+
+def _extract_signal(analysis: str, events: Dict[str, int]) -> str:
+    text = analysis.upper()
+    if "POSITIVE" in text:
+        if events.get("upgrade", 0) > 0 or "STRONG" in text:
+            return "BUY"
+        return "BUY"
+    if "NEGATIVE" in text:
+        if events.get("downgrade", 0) > 0 or events.get("regulatory", 0) > 0:
+            return "SELL"
+        return "SELL"
+    return "HOLD"
+
+
+def _estimate_confidence(news: List[Dict], events: Dict[str, int]) -> float:
+    base = 0.45
+    recent = sum(1 for n in news if n.get("age_days", 999) <= 3)
+    base += min(recent * 0.05, 0.15)
+    if events.get("earnings") or events.get("upgrade") or events.get("downgrade"):
+        base += 0.1
+    return min(round(base, 2), 0.75)
+
+
+_EVENT_EN = {"earnings": "earnings-related", "upgrade": "analyst upgrades", "downgrade": "analyst downgrades",
+             "insider": "insider trades", "regulatory": "regulatory events", "dividend": "dividend news",
+             "merger": "M&A news"}
+
+
+def _build_key_points(news: List[Dict], events: Dict[str, int], lang: str = "zh") -> List[str]:
+    zh = str(lang).lower().startswith("zh")
+    points = []
+    recent = [n for n in news if n.get("age_days", 999) <= 3]
+    if recent:
+        points.append(f"近3日 {len(recent)} 条新鲜新闻" if zh else f"{len(recent)} stories in the last 3 days")
+    for etype, count in events.items():
+        if not zh:
+            points.append(f"{_EVENT_EN.get(etype, etype)} × {count}")
+            continue
+        label = {
+            "earnings": "业绩/财报相关",
+            "upgrade": "分析师升级评级",
+            "downgrade": "分析师降级评级",
+            "insider": "内部人士交易",
+            "regulatory": "监管/调查事件",
+            "dividend": "股息/分红公告",
+            "merger": "并购/重组消息",
+        }.get(etype, etype)
+        points.append(f"{label} × {count}")
+    return points[:5]
+
+
+def _template_analysis(symbol: str, news: List[Dict], events: Dict[str, int], lang: str = "zh") -> str:
+    recent = [n for n in news if n.get("age_days", 999) <= 7]
+    if not str(lang).lower().startswith("zh"):
+        tone = "neutral"
+        if events.get("upgrade", 0) > events.get("downgrade", 0):
+            tone = "positive"
+        elif events.get("downgrade", 0) > 0 or events.get("regulatory", 0) > 0:
+            tone = "negative"
+        titles = "\n".join(f"  • {n['title'][:60]}" for n in recent[:3])
+        return (
+            f"{symbol} recent news tone: {tone}\n"
+            f"{len(recent)} related stories in the last 7 days\n"
+            f"Headlines:\n{titles or '  (no recent headlines)'}\n"
+            f"Events: {', '.join(events.keys()) or 'none'}\n"
+            f"Conclusion: {tone.upper() if tone != 'neutral' else 'NEUTRAL'}"
+        )
+    sentiment = "中性"
+    if events.get("upgrade", 0) > events.get("downgrade", 0):
+        sentiment = "偏正面"
+    elif events.get("downgrade", 0) > 0 or events.get("regulatory", 0) > 0:
+        sentiment = "偏负面"
+
+    titles = "\n".join(f"  • {n['title'][:60]}" for n in recent[:3])
+    return (
+        f"{symbol} 近期新闻情绪：{sentiment}\n"
+        f"近7日 {len(recent)} 条相关新闻\n"
+        f"主要标题：\n{titles or '  （无最新标题）'}\n"
+        f"事件分类：{', '.join(events.keys()) or '无特定事件'}\n"
+        f"结论：{'POSITIVE' if sentiment == '偏正面' else ('NEGATIVE' if sentiment == '偏负面' else 'NEUTRAL')}"
+    )

aria_code/agents/financial/risk.py

@@ -0,0 +1,146 @@
+"""
+agents/financial/risk.py — 风险评估 Agent
+==========================================
+分析：波动率、最大回撤、与大盘相关性、仓位建议。
+"""
+from __future__ import annotations
+from typing import Any, Dict, List
+from ..base import BaseAgent, AgentResult
+
+try:
+    import numpy as np
+    _HAS_NP = True
+except ImportError:
+    _HAS_NP = False
+    np = None  # type: ignore[assignment]
+
+class RiskAgent(BaseAgent):
+    name        = "risk"
+    description = "风险评估：波动率/回撤/相关性/仓位建议"
+
+    _SYSTEM = (
+        "You are a risk manager. Assess: historical volatility, max drawdown, "
+        "liquidity risk, correlation to market, and position sizing recommendation. "
+        "Output: risk score 1-10 (1=very low, 10=very high) and "
+        "POSITION: <percentage> (e.g. POSITION: 10%)."
+    )
+
+    async def fetch_data(self, symbol: str) -> Dict[str, Any]:
+        data = await super().fetch_data(symbol)
+        if self.data:
+            h = self.data.history(symbol, days=252)  # 1年
+            if h and h.data is not None:
+                data["risk_metrics"] = _compute_risk(h.data)
+        return data
+
+    async def analyze(self, symbol: str, data: Dict[str, Any]) -> AgentResult:
+        quote   = data.get("quote", {})
+        metrics = data.get("risk_metrics", {})
+        price   = quote.get("price", 0)
+        beta = metrics.get("beta")
+        beta_text = f"{beta:.2f}" if isinstance(beta, (int, float)) else "n/a"
+
+        risk_str = (
+            f"  Ann. Volatility: {metrics.get('ann_vol',0):.1f}%\n"
+            f"  Max Drawdown:    {metrics.get('max_dd',0):.1f}%\n"
+            f"  Sharpe (1Y):     {metrics.get('sharpe',0):.2f}\n"
+            f"  Beta est.:       {beta_text}\n"
+            f"  Avg Daily Vol:   {metrics.get('avg_vol_usd',0):,.0f}"
+        ) if metrics else "  (risk metrics unavailable)"
+
+        prompt = (
+            f"Stock: {symbol}  Price: {price}\n"
+            f"Risk Metrics:\n{risk_str}\n\n"
+            "Assess:\n"
+            "1. Volatility profile (high/medium/low)\n"
+            "2. Drawdown history and recovery\n"
+            "3. Liquidity adequacy\n"
+            "4. Tail risk and black swan exposure\n"
+            "5. Recommended position size for a diversified portfolio\n"
+            "Output format: Risk Score: X/10\nPOSITION: Y%\n\n"
+            "Data limits: only the historical risk metrics above are available. No portfolio stress "
+            "test, tail-risk decomposition or benchmark return series is connected; do not claim those "
+            "were run or invent a beta. If the history is missing, state that the risk metrics are unavailable."
+        )
+
+        analysis  = await self._call_llm(self._SYSTEM, prompt, max_tokens=400, quote=quote)
+        if not analysis:
+            analysis = _template_risk(symbol, metrics, lang=self.lang)
+
+        signal     = _risk_to_signal(metrics)
+        confidence = 0.70
+        zh = str(self.lang).lower().startswith("zh")
+        key_points = [
+            f"年化波动率 {metrics.get('ann_vol',0):.1f}%" if zh else f"annualised volatility {metrics.get('ann_vol',0):.1f}%",
+            f"最大回撤 {metrics.get('max_dd',0):.1f}%" if zh else f"max drawdown {metrics.get('max_dd',0):.1f}%",
+            f"夏普比率 {metrics.get('sharpe',0):.2f}" if zh else f"Sharpe ratio {metrics.get('sharpe',0):.2f}",
+        ] if metrics else ["风险数据不可用" if zh else "risk data unavailable"]
+
+        return AgentResult(
+            agent=self.name, symbol=symbol,
+            analysis=analysis, confidence=confidence,
+            signal=signal, key_points=key_points,
+            data_used=metrics,
+        )
+
+
+def _compute_risk(df) -> Dict:
+    if not _HAS_NP:
+        return {}
+    try:
+        close = df["close"].values if "close" in df.columns else df.iloc[:, -1].values
+        vol   = df["volume"].values if "volume" in df.columns else np.ones(len(close))
+        rets  = np.diff(close) / close[:-1]
+
+        ann_vol   = float(np.std(rets) * np.sqrt(252) * 100)
+        ann_ret   = float(np.mean(rets) * 252 * 100)
+        sharpe    = ann_ret / max(ann_vol, 0.01)
+        cum       = np.cumprod(1 + rets)
+        peaks     = np.maximum.accumulate(cum)
+        drawdowns = (cum - peaks) / peaks
+        max_dd    = float(drawdowns.min() * 100)
+        avg_vol   = float(np.mean(vol[-20:]) * close[-1]) if len(close) > 20 else 0
+
+        return {
+            "ann_vol":    round(ann_vol, 1),
+            "ann_ret":    round(ann_ret, 1),
+            "sharpe":     round(sharpe, 2),
+            "max_dd":     round(max_dd, 1),
+            "avg_vol_usd": round(avg_vol, 0),
+        }
+    except Exception:
+        return {}
+
+
+def _risk_to_signal(metrics: Dict) -> str:
+    vol = metrics.get("ann_vol", 30)
+    dd  = metrics.get("max_dd", -20)
+    if vol < 20 and dd > -15:
+        return "BUY"
+    if vol > 50 or dd < -40:
+        return "REDUCE"
+    return "HOLD"
+
+
+def _template_risk(symbol: str, m: Dict, lang: str = "zh") -> str:
+    vol = m.get("ann_vol", 0)
+    dd  = m.get("max_dd",  0)
+    if not str(lang).lower().startswith("zh"):
+        level = "high" if vol > 40 else ("medium" if vol > 20 else "low")
+        return (
+            f"{symbol} risk (template):\n"
+            f"• Annualised volatility: {vol:.1f}% (risk {level})\n"
+            f"• Max drawdown: {dd:.1f}%\n"
+            f"• Sharpe ratio: {m.get('sharpe',0):.2f}\n"
+            f"• Suggested position: {'5-10%' if vol>40 else '10-15%' if vol>20 else '15-20%'}\n"
+            f"• Risk Score: {min(10, int(vol/5))}/10"
+        )
+    risk_level = "高" if vol > 40 else ("中" if vol > 20 else "低")
+    return (
+        f"{symbol} 风险分析（模板）:\n"
+        f"• 年化波动率: {vol:.1f}%（风险水平: {risk_level}）\n"
+        f"• 最大回撤: {dd:.1f}%\n"
+        f"• 夏普比率: {m.get('sharpe',0):.2f}\n"
+        f"• 建议仓位: {'5-10%' if vol>40 else '10-15%' if vol>20 else '15-20%'}\n"
+        f"• Risk Score: {min(10, int(vol/5))}/10"
+    )

aria_code/agents/financial/sector.py

@@ -0,0 +1,279 @@
+"""
+agents/financial/sector.py — 行业轮动分析 Agent
+================================================
+分析标的所属行业的相对强弱：行业指数表现、资金流入/流出趋势、
+板块轮动阶段，以判断标的是否处于顺风还是逆风环境。
+数据源：yfinance 行业 ETF（XLK/XLF/XLE/…）+ akshare 行业指数（A股）
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, List, Optional
+
+from ..base import BaseAgent, AgentResult
+
+logger = logging.getLogger(__name__)
+
+# 美股行业 ETF 映射 (GICS Sectors)
+_US_SECTOR_ETFS: Dict[str, str] = {
+    "Technology":             "XLK",
+    "Health Care":            "XLV",
+    "Financials":             "XLF",
+    "Consumer Discretionary": "XLY",
+    "Consumer Staples":       "XLP",
+    "Industrials":            "XLI",
+    "Energy":                 "XLE",
+    "Materials":              "XLB",
+    "Real Estate":            "XLRE",
+    "Utilities":              "XLU",
+    "Communication Services": "XLC",
+}
+
+# 默认参考基准
+_BENCHMARK = "SPY"
+
+
+class SectorAgent(BaseAgent):
+
+    name        = "sector"
+    description = "行业轮动 — 所属板块相对强弱、资金流入/流出趋势"
+
+    _SYSTEM = (
+        "You are a sector rotation analyst. Given a stock and its sector's "
+        "recent performance relative to the broader market, assess:\n"
+        "1. Is the sector in an uptrend or downtrend vs the S&P 500?\n"
+        "2. Is money flowing INTO or OUT OF this sector recently?\n"
+        "3. What stage of the sector rotation cycle is this sector in "
+        "(early/mid/late recovery, contraction)?\n"
+        "4. Does the sector tailwind/headwind support BUY/HOLD/SELL on the stock?\n"
+        "Conclude: TAILWIND (sector supports bullish) / NEUTRAL / HEADWIND (sector drags bearish)"
+    )
+
+    async def fetch_data(self, symbol: str) -> Dict[str, Any]:
+        data = await super().fetch_data(symbol)
+        sector_data: Dict[str, Any] = {}
+
+        try:
+            import yfinance as yf
+            ticker = yf.Ticker(symbol)
+
+            # 1. Identify sector from stock info
+            info   = ticker.info or {}
+            sector = info.get("sector", "")
+            industry = info.get("industry", "")
+            sector_data["sector"]   = sector
+            sector_data["industry"] = industry
+
+            # 2. Get sector ETF for US stocks
+            etf_sym = _US_SECTOR_ETFS.get(sector)
+            if not etf_sym:
+                # Try to guess from ticker pattern for A-shares
+                if _is_a_share(symbol):
+                    sector_data["market"] = "CN"
+                    sector_data["etf_sym"] = None
+                else:
+                    sector_data["market"] = "US"
+                    sector_data["etf_sym"] = None
+            else:
+                sector_data["etf_sym"] = etf_sym
+                sector_data["market"] = "US"
+
+            # 3. Fetch returns for sector ETF and benchmark
+            comparisons: Dict[str, Dict] = {}
+            for periods in [("1mo", 21), ("3mo", 63), ("6mo", 126)]:
+                period_key, _ = periods[0], periods[1]
+                comparisons[period_key] = {}
+
+            syms_to_fetch = [_BENCHMARK]
+            if etf_sym:
+                syms_to_fetch.append(etf_sym)
+
+            for fetch_sym in syms_to_fetch:
+                try:
+                    hist = yf.Ticker(fetch_sym).history(period="6mo")
+                    if hist.empty:
+                        continue
+                    close = hist["Close"]
+                    for period_key, days in [("1mo", 21), ("3mo", 63), ("6mo", len(close))]:
+                        if len(close) >= days:
+                            ret = (float(close.iloc[-1]) - float(close.iloc[-days])) / float(close.iloc[-days])
+                            comparisons[period_key][fetch_sym] = round(ret * 100, 2)
+                except Exception as e:
+                    logger.debug("[sector] fetch %s: %s", fetch_sym, e)
+
+            sector_data["comparisons"] = comparisons
+
+            # 4. Stock's own recent performance vs sector
+            try:
+                hist = ticker.history(period="3mo")
+                if not hist.empty and len(hist) >= 21:
+                    close = hist["Close"]
+                    stock_1mo = (float(close.iloc[-1]) - float(close.iloc[-21])) / float(close.iloc[-21]) * 100
+                    sector_data["stock_1mo_return"] = round(stock_1mo, 2)
+            except Exception as e:
+                logger.debug("[sector] stock return %s: %s", symbol, e)
+
+            # 5. A-share sector data via akshare
+            if _is_a_share(symbol):
+                try:
+                    import akshare as ak
+                    sector_df = ak.stock_board_industry_name_em()
+                    if sector_df is not None and not sector_df.empty:
+                        sector_data["cn_sectors_available"] = True
+                except Exception:
+                    pass
+
+        except Exception as e:
+            logger.debug("[sector] yfinance init %s: %s", symbol, e)
+
+        data["sector_data"] = sector_data
+        return data
+
+    async def analyze(self, symbol: str, data: Dict[str, Any]) -> AgentResult:
+        sd    = data.get("sector_data", {})
+        quote = data.get("quote", {})
+        price = quote.get("price", 0)
+
+        if not sd:
+            return AgentResult(
+                agent=self.name, symbol=symbol,
+                analysis=f"{symbol}: 未获取到行业数据。",
+                confidence=0.3, signal="HOLD",
+                key_points=["无行业数据"],
+            )
+
+        sector_block = _format_sector_stats(sd)
+        rel_strength = _compute_relative_strength(sd)
+
+        prompt = (
+            f"Stock: {symbol}  Sector: {sd.get('sector', 'Unknown')}  "
+            f"Industry: {sd.get('industry', 'Unknown')}\n\n"
+            f"Sector Performance vs Market:\n{sector_block}\n\n"
+            f"Relative Strength Assessment: {rel_strength}\n\n"
+            "Analyze sector rotation dynamics and conclude:\n"
+            "TAILWIND / NEUTRAL / HEADWIND"
+        )
+
+        analysis = await self._call_llm(self._SYSTEM, prompt, max_tokens=450)
+        if not analysis:
+            analysis = _template_analysis(symbol, sd, rel_strength)
+
+        signal, confidence = _derive_signal(analysis, sd, rel_strength)
+        key_points         = _build_key_points(sd, rel_strength, signal)
+
+        return AgentResult(
+            agent=self.name, symbol=symbol,
+            analysis=analysis,
+            confidence=confidence,
+            signal=signal,
+            key_points=key_points,
+            data_used={
+                "sector": sd.get("sector"),
+                "etf": sd.get("etf_sym"),
+                "rel_strength": rel_strength,
+            },
+        )
+
+
+# ── Helpers ───────────────────────────────────────────────────────────────────
+
+def _is_a_share(symbol: str) -> bool:
+    import re
+    return bool(re.match(r"^[036]\d{5}$", symbol))
+
+
+def _format_sector_stats(sd: Dict) -> str:
+    lines = []
+    sector  = sd.get("sector", "Unknown")
+    etf_sym = sd.get("etf_sym", "")
+    comps   = sd.get("comparisons", {})
+    lines.append(f"Sector: {sector}{f'  ETF: {etf_sym}' if etf_sym else ''}")
+
+    if comps:
+        lines.append(f"\n{'Period':<8} {'SPY':>8} {etf_sym or 'SECTOR':>8}  Rel.Strength")
+        for period in ("1mo", "3mo", "6mo"):
+            c = comps.get(period, {})
+            spy = c.get(_BENCHMARK)
+            etf = c.get(etf_sym) if etf_sym else None
+            spy_str = f"{spy:+.1f}%" if spy is not None else "  N/A"
+            etf_str = f"{etf:+.1f}%" if etf is not None else "  N/A"
+            rel = ""
+            if spy is not None and etf is not None:
+                diff = etf - spy
+                rel  = f"{diff:+.1f}% vs SPY"
+            lines.append(f"{period:<8} {spy_str:>8} {etf_str:>8}  {rel}")
+
+    stock_1mo = sd.get("stock_1mo_return")
+    if stock_1mo is not None:
+        lines.append(f"\nStock 1-month: {stock_1mo:+.1f}%")
+
+    return "\n".join(lines)
+
+
+def _compute_relative_strength(sd: Dict) -> str:
+    etf_sym = sd.get("etf_sym")
+    comps   = sd.get("comparisons", {})
+    if not etf_sym or not comps:
+        return "无法计算（无行业 ETF 数据）"
+
+    scores = []
+    for period in ("1mo", "3mo"):
+        c   = comps.get(period, {})
+        spy = c.get(_BENCHMARK)
+        etf = c.get(etf_sym)
+        if spy is not None and etf is not None:
+            scores.append(etf - spy)
+
+    if not scores:
+        return "数据不足"
+    avg_rs = sum(scores) / len(scores)
+    if avg_rs > 3:
+        return f"行业强于大盘 +{avg_rs:.1f}%（顺风）"
+    if avg_rs > 0:
+        return f"行业小幅跑赢 +{avg_rs:.1f}%（中性偏正）"
+    if avg_rs > -3:
+        return f"行业小幅落后 {avg_rs:.1f}%（中性偏负）"
+    return f"行业明显弱于大盘 {avg_rs:.1f}%（逆风）"
+
+
+def _derive_signal(analysis: str, sd: Dict, rel_str: str) -> tuple[str, float]:
+    text = analysis.upper()
+    if "TAILWIND" in text:
+        return "BUY", 0.55
+    if "HEADWIND" in text:
+        return "SELL", 0.55
+
+    # Fallback: use relative strength
+    if "顺风" in rel_str or "跑赢" in rel_str:
+        return "BUY", 0.45
+    if "逆风" in rel_str or "落后" in rel_str:
+        return "SELL", 0.45
+    return "HOLD", 0.40
+
+
+def _build_key_points(sd: Dict, rel_str: str, signal: str) -> List[str]:
+    pts = []
+    sec = sd.get("sector", "")
+    if sec:
+        pts.append(f"行业: {sec}")
+    etf = sd.get("etf_sym")
+    if etf:
+        pts.append(f"对应 ETF: {etf}")
+    pts.append(f"板块强弱: {rel_str[:40]}")
+    stock_1mo = sd.get("stock_1mo_return")
+    if stock_1mo is not None:
+        pts.append(f"个股1月涨跌: {stock_1mo:+.1f}%")
+    pts.append(f"行业信号: {signal}")
+    return pts[:5]
+
+
+def _template_analysis(symbol: str, sd: Dict, rel_str: str) -> str:
+    sector = sd.get("sector", "Unknown")
+    verdict = "TAILWIND" if "顺风" in rel_str else ("HEADWIND" if "逆风" in rel_str else "NEUTRAL")
+    return (
+        f"{symbol} 行业分析（模板）\n"
+        f"所属行业: {sector}\n"
+        f"行业强弱: {rel_str}\n"
+        f"结论: {verdict}"
+    )