Add comprehensive Equity Research agent

app.py

@@ -1,134 +1,161 @@
 """
 Eugene Intelligence — Gradio Web App
-Financial data infrastructure for AI agents and humans.
 """
 
 import gradio as gr
 from eugene.config import Config
 from eugene.agents.health import HealthMonitor
 from eugene.agents.earnings import EarningsAgent
+from eugene.agents.equity_research import EquityResearchAgent
 from eugene.sources.yahoo import get_stock_prices, get_earnings_data
 from eugene.sources.insider import get_insider_transactions
 
 config = Config()
 health = HealthMonitor(config)
 earnings_agent = EarningsAgent(config)
+equity_agent = EquityResearchAgent(config)
 
-def analyze_fundamentals(tickers_input: str) -> str:
-    if not tickers_input.strip():
-        return "Enter a ticker symbol (e.g., AAPL)"
+def analyze_fundamentals(tickers_input):
+    if not tickers_input.strip(): return "Enter a ticker"
     tickers = [t.strip().upper() for t in tickers_input.split(",")]
     if len(tickers) == 1:
         report = health.analyze(tickers[0])
         return f"## {report.company_name} ({report.ticker})\n\n" + "\n".join([f"**{k}:** {v}" for k, v in report.to_dict().get("metrics", {}).items()])
-    else:
-        result = health.compare(tickers[:5])
-        return f"```json\n{result}\n```"
+    return str(health.compare(tickers[:5]))
 
-def analyze_prices(ticker: str, period: str = "1y") -> str:
-    if not ticker.strip():
-        return "Enter a ticker symbol"
+def analyze_prices(ticker, period="1y"):
+    if not ticker.strip(): return "Enter a ticker"
     data = get_stock_prices(ticker.strip().upper(), period, "1d")
-    if "error" in data:
-        return f"❌ {data['error']}"
-    
-    quote = data.get("current_quote", {})
-    stats = data.get("summary_stats", {})
-    
+    if "error" in data: return f"❌ {data['error']}"
+    quote, stats = data.get("current_quote", {}), data.get("summary_stats", {})
     output = f"## {data.get('company_name', ticker)} ({data['ticker']})\n"
     output += f"**Price:** ${quote.get('price', 'N/A')} | **P/E:** {quote.get('pe_ratio', 'N/A')} | **Beta:** {quote.get('beta', 'N/A')}\n\n"
-    output += f"### Performance ({period})\n"
-    output += f"- **Return:** {stats.get('total_return_pct', 'N/A')}%\n"
-    output += f"- **52W High:** ${stats.get('52_week_high', 'N/A')} | **52W Low:** ${stats.get('52_week_low', 'N/A')}\n"
-    output += f"- **50 SMA:** ${stats.get('sma_50', 'N/A')} | **200 SMA:** ${stats.get('sma_200', 'N/A')}\n"
-    
-    prices = data.get("prices", [])[-10:]
-    if prices:
-        output += "\n### Recent Prices\n| Date | Close | Volume |\n|------|-------|--------|\n"
-        for p in reversed(prices):
-            output += f"| {p['date']} | ${p['close']} | {p['volume']:,} |\n"
+    output += f"**Return:** {stats.get('total_return_pct', 'N/A')}% | **52W:** ${stats.get('52_week_low', 'N/A')} - ${stats.get('52_week_high', 'N/A')}\n"
     return output
 
-def analyze_earnings(ticker: str) -> str:
-    if not ticker.strip():
-        return "Enter a ticker symbol"
+def analyze_earnings(ticker):
+    if not ticker.strip(): return "Enter a ticker"
     data = get_earnings_data(ticker.strip().upper())
-    if "error" in data:
-        return f"❌ {data['error']}"
-    
+    if "error" in data: return f"❌ {data['error']}"
     track = data.get("track_record", {})
     output = f"## {data.get('company_name', ticker)} — Earnings\n\n"
-    output += f"**Beat Rate:** {track.get('beat_rate_pct', 'N/A')}% ({track.get('beats', 0)} beats, {track.get('misses', 0)} misses)\n\n"
-    
-    if data.get("next_earnings"):
-        output += f"**Next Earnings:** {data['next_earnings'].get('date', 'TBD')}\n\n"
-    
-    hist = [e for e in data.get("earnings_history", []) if e.get("result") in ("beat", "miss", "inline")][:8]
-    if hist:
-        output += "### History\n| Date | EPS Est | EPS Actual | Result |\n|------|---------|------------|--------|\n"
-        for e in hist:
-            emoji = "✅" if e["result"] == "beat" else "❌" if e["result"] == "miss" else "➖"
-            output += f"| {e['date']} | ${e.get('eps_estimate', 'N/A')} | ${e.get('eps_actual', 'N/A')} | {emoji} |\n"
+    output += f"**Beat Rate:** {track.get('beat_rate_pct', 'N/A')}% | **Next:** {data.get('next_earnings', {}).get('date', 'TBD')}\n"
     return output
 
-def analyze_insider(ticker: str, days: int = 365) -> str:
-    if not ticker.strip():
-        return "Enter a ticker symbol"
+def analyze_insider(ticker, days=365):
+    if not ticker.strip(): return "Enter a ticker"
     data = get_insider_transactions(ticker.strip().upper(), int(days))
-    if "error" in data:
-        return f"❌ {data['error']}"
-    
+    if "error" in data: return f"❌ {data['error']}"
     s = data.get("summary", {})
     signal = s.get("signal", "neutral")
     emoji = "🟢" if signal == "net_buying" else "🔴" if signal == "net_selling" else "⚪"
-    
     output = f"## {data.get('company_name', ticker)} — Insider Activity\n\n"
     output += f"### Signal: {emoji} {signal.upper()}\n\n"
-    output += f"- **Buys:** {s.get('total_buys', 0)} (${s.get('total_buy_value', 0):,.0f})\n"
-    output += f"- **Sells:** {s.get('total_sells', 0)} (${s.get('total_sell_value', 0):,.0f})\n"
-    output += f"- **Net:** ${s.get('net_value', 0):,.0f}\n\n"
-    
-    txns = data.get("transactions", [])[:10]
-    if txns:
-        output += "### Recent Transactions\n| Date | Insider | Type | Value |\n|------|---------|------|-------|\n"
-        for t in txns:
-            val = f"${t['total_value']:,.0f}" if t.get('total_value') else "—"
-            output += f"| {t.get('date', '—')} | {t.get('owner_name', '—')[:20]} | {t.get('transaction_type', '—')[:15]} | {val} |\n"
+    output += f"**Buys:** {s.get('total_buys', 0)} (${s.get('total_buy_value', 0):,.0f}) | **Sells:** {s.get('total_sells', 0)} (${s.get('total_sell_value', 0):,.0f})\n"
     return output
 
-def analyze_earnings_calendar(tickers_input: str) -> str:
-    if not tickers_input.strip():
-        return "Enter ticker symbols (e.g., AAPL, NVDA, TSLA)"
+def analyze_earnings_calendar(tickers_input):
+    if not tickers_input.strip(): return "Enter tickers"
     tickers = [t.strip().upper() for t in tickers_input.split(",")]
     data = earnings_agent.get_earnings_calendar(tickers)
-    
-    output = f"## Earnings Calendar\n*{data['upcoming_earnings']} upcoming from {data['tickers_checked']} tickers*\n\n"
-    output += "| Ticker | Company | Date | Days | Beat Rate |\n|--------|---------|------|------|----------|\n"
-    
+    output = f"## Earnings Calendar\n\n| Ticker | Date | Days | Beat Rate |\n|--------|------|------|----------|\n"
     for e in data.get("calendar", []):
-        output += f"| {e['ticker']} | {e['company_name'][:20]} | {e['earnings_date']} | {e['days_until']} | {e.get('beat_rate_pct', 'N/A')}% |\n"
-    
+        output += f"| {e['ticker']} | {e['earnings_date']} | {e['days_until']} | {e.get('beat_rate_pct', 'N/A')}% |\n"
     return output
 
-def analyze_post_earnings(ticker: str) -> str:
-    if not ticker.strip():
-        return "Enter a ticker symbol"
+def analyze_post_earnings(ticker):
+    if not ticker.strip(): return "Enter a ticker"
     data = earnings_agent.analyze_post_earnings_moves(ticker.strip().upper(), 8)
-    if "error" in data:
-        return f"❌ {data['error']}"
-    
+    if "error" in data: return f"❌ {data['error']}"
     s = data.get("summary", {})
     output = f"## {data.get('company_name', ticker)} — Post-Earnings Moves\n\n"
-    output += f"**Avg Move on Beat:** {s.get('avg_move_on_beat_pct', 'N/A')}%\n"
-    output += f"**Avg Move on Miss:** {s.get('avg_move_on_miss_pct', 'N/A')}%\n"
-    output += f"**Beat Rate:** {s.get('beat_rate_pct', 'N/A')}%\n\n"
-    
-    hist = data.get("history", [])[:8]
-    if hist:
-        output += "### Recent Earnings Reactions\n| Date | Result | EPS | 1D Move | 5D Move |\n|------|--------|-----|---------|--------|\n"
-        for h in hist:
-            result_emoji = "✅" if h["result"] == "beat" else "❌" if h["result"] == "miss" else "➖"
-            output += f"| {h['date']} | {result_emoji} | ${h.get('eps_actual', 'N/A')} | {h.get('move_1d_pct', 'N/A')}% | {h.get('move_5d_pct', 'N/A')}% |\n"
+    output += f"**Avg on Beat:** {s.get('avg_move_on_beat_pct', 'N/A')}% | **Avg on Miss:** {s.get('avg_move_on_miss_pct', 'N/A')}%\n\n"
+    output += "| Date | Result | 1D Move | 5D Move |\n|------|--------|---------|--------|\n"
+    for h in data.get("history", [])[:6]:
+        emoji = "✅" if h["result"] == "beat" else "❌" if h["result"] == "miss" else "➖"
+        output += f"| {h['date']} | {emoji} | {h.get('move_1d_pct', 'N/A')}% | {h.get('move_5d_pct', 'N/A')}% |\n"
+    return output
+
+def generate_equity_report(ticker, peers_input=""):
+    if not ticker.strip(): return "Enter a ticker"
+    peers = [p.strip().upper() for p in peers_input.split(",") if p.strip()] if peers_input else []
+    report = equity_agent.generate_report(ticker.strip().upper(), peers)
+    
+    o = report.get("overview", {})
+    fh = report.get("financial_health", {})
+    prof = fh.get("profitability", {})
+    lev = fh.get("leverage", {})
+    perf = report.get("price_performance", {})
+    val = report.get("valuation", {})
+    earn = report.get("earnings", {})
+    ins = report.get("insider_activity", {})
+    risk = report.get("risks", {})
+    thesis = report.get("thesis", {})
+    
+    output = f"# {o.get('company_name', ticker)} ({report['ticker']}) — Equity Research\n\n"
+    output += f"*Generated: {report['generated_at']}*\n\n"
+    
+    # Overview
+    mcap = o.get('market_cap')
+    mcap_str = f"${mcap/1e9:.1f}B" if mcap and mcap > 1e9 else f"${mcap/1e6:.0f}M" if mcap else "N/A"
+    output += f"**Market Cap:** {mcap_str} | **Price:** ${o.get('current_price', 'N/A')}\n\n"
+    
+    # Financial Health
+    output += "## Financial Health\n"
+    output += f"| Metric | Value |\n|--------|-------|\n"
+    output += f"| ROE | {prof.get('roe_pct', 'N/A')}% |\n"
+    output += f"| ROA | {prof.get('roa_pct', 'N/A')}% |\n"
+    output += f"| Net Margin | {prof.get('net_margin_pct', 'N/A')}% |\n"
+    output += f"| Debt/Equity | {lev.get('debt_to_equity', 'N/A')}x |\n\n"
+    
+    # Price Performance
+    output += "## Price Performance\n"
+    output += f"| 1M | 3M | 6M | 1Y | 5Y |\n|----|----|----|----|----|\n"
+    output += f"| {perf.get('return_1M', 'N/A')}% | {perf.get('return_3M', 'N/A')}% | {perf.get('return_6M', 'N/A')}% | {perf.get('return_1Y', 'N/A')}% | {perf.get('return_5Y', 'N/A')}% |\n\n"
+    output += f"**52W Range:** ${perf.get('52_week_low', 'N/A')} - ${perf.get('52_week_high', 'N/A')} | **Beta:** {perf.get('beta', 'N/A')}\n\n"
+    
+    # Valuation
+    output += "## Valuation\n"
+    output += f"**P/E:** {val.get('pe_ratio', 'N/A')}x | **Fwd P/E:** {val.get('forward_pe', 'N/A')}x | **P/S:** {val.get('ps_ratio', 'N/A')}x | **Div Yield:** {val.get('dividend_yield_pct', 'N/A')}%\n\n"
+    
+    # Earnings
+    output += "## Earnings Quality\n"
+    output += f"**Beat Rate:** {earn.get('beat_rate_pct', 'N/A')}% | **Next Earnings:** {earn.get('next_earnings', 'TBD')}\n"
+    output += f"**EPS Growth:** {earn.get('earnings_growth_pct', 'N/A')}% | **Rev Growth:** {earn.get('revenue_growth_pct', 'N/A')}%\n\n"
+    
+    # Insider
+    signal = ins.get('signal', 'neutral')
+    emoji = "🟢" if signal == "net_buying" else "🔴" if signal == "net_selling" else "⚪"
+    output += f"## Insider Activity: {emoji} {signal.upper()}\n"
+    output += f"**Net Value:** ${ins.get('net_value', 0):,.0f} ({ins.get('total_buys', 0)} buys, {ins.get('total_sells', 0)} sells)\n\n"
+    
+    # Risk
+    output += f"## Risk Assessment: {risk.get('risk_level', 'N/A')} (Score: {risk.get('risk_score', 0)})\n"
+    for r in risk.get("identified_risks", []):
+        output += f"- ⚠️ **{r['type']}:** {r['detail']}\n"
+    output += "\n"
+    
+    # Thesis
+    output += "## Investment Thesis\n"
+    output += "### Bull Case 🐂\n"
+    for b in thesis.get("bull_case", []):
+        output += f"- {b}\n"
+    output += "\n### Bear Case 🐻\n"
+    for b in thesis.get("bear_case", []):
+        output += f"- {b}\n"
+    output += f"\n### Summary\n{thesis.get('summary', '')}\n"
+    
+    # Peer comparison
+    if "peer_comparison" in report:
+        pc = report["peer_comparison"]
+        output += "\n## Peer Comparison\n"
+        output += "| Ticker | Mkt Cap | P/E | 1Y Ret | ROE | Margin |\n"
+        output += "|--------|---------|-----|--------|-----|--------|\n"
+        for t, m in pc.get("metrics", {}).items():
+            if "error" in m: continue
+            mc = m.get('market_cap')
+            mc_str = f"${mc/1e9:.0f}B" if mc and mc > 1e9 else "N/A"
+            output += f"| {t} | {mc_str} | {m.get('pe_ratio', 'N/A')}x | {m.get('return_1y_pct', 'N/A')}% | {m.get('roe_pct', 'N/A')}% | {m.get('net_margin_pct', 'N/A')}% |\n"
     
     return output
 
@@ -136,15 +163,22 @@ with gr.Blocks(title="Eugene Intelligence") as demo:
     gr.Markdown("# 🏛️ Eugene Intelligence\n**Financial data infrastructure for AI agents.**")
     
     with gr.Tabs():
+        with gr.TabItem("🔬 Equity Research"):
+            gr.Markdown("Comprehensive equity research report with financials, valuation, earnings, insider activity, risk assessment, and investment thesis.")
+            with gr.Row():
+                er_ticker = gr.Textbox(label="Ticker", placeholder="NVDA")
+                er_peers = gr.Textbox(label="Peers (optional)", placeholder="AMD, INTC")
+            er_btn = gr.Button("Generate Report", variant="primary")
+            er_output = gr.Markdown()
+            er_btn.click(generate_equity_report, inputs=[er_ticker, er_peers], outputs=er_output)
+        
         with gr.TabItem("📊 Fundamentals"):
-            gr.Markdown("SEC XBRL financial metrics")
             f_input = gr.Textbox(label="Ticker(s)", placeholder="AAPL or JPM, BAC, GS")
             f_btn = gr.Button("Analyze", variant="primary")
             f_output = gr.Markdown()
             f_btn.click(analyze_fundamentals, inputs=f_input, outputs=f_output)
         
         with gr.TabItem("📈 Stock Prices"):
-            gr.Markdown("20+ years of price history")
             with gr.Row():
                 p_ticker = gr.Textbox(label="Ticker", placeholder="AAPL")
                 p_period = gr.Dropdown(choices=["1mo", "3mo", "6mo", "1y", "2y", "5y", "max"], value="1y", label="Period")
@@ -153,32 +187,28 @@ with gr.Blocks(title="Eugene Intelligence") as demo:
             p_btn.click(analyze_prices, inputs=[p_ticker, p_period], outputs=p_output)
         
         with gr.TabItem("💰 Earnings"):
-            gr.Markdown("EPS beat/miss history")
             e_input = gr.Textbox(label="Ticker", placeholder="NVDA")
             e_btn = gr.Button("Get Earnings", variant="primary")
             e_output = gr.Markdown()
             e_btn.click(analyze_earnings, inputs=e_input, outputs=e_output)
         
         with gr.TabItem("📅 Earnings Calendar"):
-            gr.Markdown("Upcoming earnings for your watchlist")
             cal_input = gr.Textbox(label="Tickers", placeholder="AAPL, NVDA, TSLA, META, GOOGL")
             cal_btn = gr.Button("Get Calendar", variant="primary")
             cal_output = gr.Markdown()
             cal_btn.click(analyze_earnings_calendar, inputs=cal_input, outputs=cal_output)
         
         with gr.TabItem("📉 Post-Earnings Moves"):
-            gr.Markdown("How does the stock move after earnings?")
             pe_input = gr.Textbox(label="Ticker", placeholder="NVDA")
-            pe_btn = gr.Button("Analyze Moves", variant="primary")
+            pe_btn = gr.Button("Analyze", variant="primary")
             pe_output = gr.Markdown()
             pe_btn.click(analyze_post_earnings, inputs=pe_input, outputs=pe_output)
         
         with gr.TabItem("🕵️ Insider Trades"):
-            gr.Markdown("SEC Form 4 insider activity")
             with gr.Row():
                 i_ticker = gr.Textbox(label="Ticker", placeholder="TSLA")
                 i_days = gr.Slider(minimum=30, maximum=730, value=365, label="Days Back")
-            i_btn = gr.Button("Get Insider Activity", variant="primary")
+            i_btn = gr.Button("Get Activity", variant="primary")
             i_output = gr.Markdown()
             i_btn.click(analyze_insider, inputs=[i_ticker, i_days], outputs=i_output)
     

eugene/agents/equity_research.py

@@ -0,0 +1,527 @@
+"""
+Eugene Intelligence — Equity Research Agent
+Comprehensive equity research reports combining fundamentals, 
+price performance, earnings quality, insider activity, and peer analysis.
+"""
+
+from datetime import datetime, timedelta
+from typing import List, Optional, Dict
+from eugene.sources.yahoo import get_stock_prices, get_earnings_data
+from eugene.sources.insider import get_insider_transactions
+
+
+class EquityResearchAgent:
+    """Comprehensive equity research agent."""
+    
+    def __init__(self, config):
+        self.config = config
+        self._health = None
+        self._earnings = None
+    
+    @property
+    def health(self):
+        if self._health is None:
+            from eugene.agents.health import HealthMonitor
+            self._health = HealthMonitor(self.config)
+        return self._health
+    
+    @property
+    def earnings_agent(self):
+        if self._earnings is None:
+            from eugene.agents.earnings import EarningsAgent
+            self._earnings = EarningsAgent(self.config)
+        return self._earnings
+    
+    def generate_report(self, ticker: str, peers: List[str] = None) -> dict:
+        """
+        Generate comprehensive equity research report.
+        
+        Args:
+            ticker: Stock symbol
+            peers: Optional list of peer tickers for comparison
+        
+        Returns:
+            Full equity research report
+        """
+        ticker = ticker.upper().strip()
+        peers = [p.upper().strip() for p in (peers or [])][:5]
+        
+        report = {
+            "ticker": ticker,
+            "generated_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+            "source": "Eugene Intelligence",
+        }
+        
+        # 1. Company Overview & Fundamentals
+        report["overview"] = self._get_overview(ticker)
+        
+        # 2. Financial Health
+        report["financial_health"] = self._get_financial_health(ticker)
+        
+        # 3. Growth Analysis
+        report["growth"] = self._get_growth_analysis(ticker)
+        
+        # 4. Price Performance
+        report["price_performance"] = self._get_price_performance(ticker)
+        
+        # 5. Valuation
+        report["valuation"] = self._get_valuation(ticker)
+        
+        # 6. Earnings Quality
+        report["earnings"] = self._get_earnings_quality(ticker)
+        
+        # 7. Insider Sentiment
+        report["insider_activity"] = self._get_insider_sentiment(ticker)
+        
+        # 8. Peer Comparison
+        if peers:
+            report["peer_comparison"] = self._get_peer_comparison(ticker, peers)
+        
+        # 9. Risk Assessment
+        report["risks"] = self._get_risk_assessment(report)
+        
+        # 10. Investment Thesis
+        report["thesis"] = self._generate_thesis(report)
+        
+        return report
+    
+    def _get_overview(self, ticker: str) -> dict:
+        """Company overview from Yahoo + XBRL."""
+        prices = get_stock_prices(ticker, "1d", "1d")
+        
+        overview = {
+            "company_name": prices.get("company_name", ticker),
+            "ticker": ticker,
+            "exchange": prices.get("exchange", ""),
+            "currency": prices.get("currency", "USD"),
+        }
+        
+        quote = prices.get("current_quote", {})
+        overview["market_cap"] = quote.get("market_cap")
+        overview["current_price"] = quote.get("price")
+        
+        # Get fundamentals for additional context
+        try:
+            health_data = self.health.analyze(ticker)
+            if hasattr(health_data, 'to_dict'):
+                metrics = health_data.to_dict().get("metrics", {})
+                overview["revenue"] = metrics.get("_revenue", {}).get("value")
+                overview["net_income"] = metrics.get("_net_income", {}).get("value")
+                overview["total_assets"] = metrics.get("_total_assets", {}).get("value")
+        except:
+            pass
+        
+        return overview
+    
+    def _get_financial_health(self, ticker: str) -> dict:
+        """Financial ratios and health metrics."""
+        try:
+            health_data = self.health.analyze(ticker)
+            if hasattr(health_data, 'to_dict'):
+                metrics = health_data.to_dict().get("metrics", {})
+                
+                return {
+                    "liquidity": {
+                        "current_ratio": metrics.get("current_ratio", {}).get("value"),
+                    },
+                    "leverage": {
+                        "debt_to_assets": metrics.get("debt_to_assets", {}).get("value"),
+                        "debt_to_equity": metrics.get("debt_to_equity", {}).get("value"),
+                        "net_debt_to_ebitda": metrics.get("net_debt_to_ebitda", {}).get("value"),
+                    },
+                    "profitability": {
+                        "roe_pct": metrics.get("roe_pct", {}).get("value"),
+                        "roa_pct": metrics.get("roa_pct", {}).get("value"),
+                        "net_margin_pct": metrics.get("net_margin_pct", {}).get("value"),
+                    },
+                    "balance_sheet": {
+                        "cash": metrics.get("_cash", {}).get("value"),
+                        "total_debt": metrics.get("_total_debt", {}).get("value"),
+                        "total_assets": metrics.get("_total_assets", {}).get("value"),
+                    },
+                }
+        except Exception as e:
+            return {"error": str(e)}
+        
+        return {}
+    
+    def _get_growth_analysis(self, ticker: str) -> dict:
+        """5-year growth trends."""
+        try:
+            health_data = self.health.analyze(ticker, include_trends=True)
+            if hasattr(health_data, 'to_dict'):
+                data = health_data.to_dict()
+                trends = data.get("trends", {})
+                
+                return {
+                    "revenue_cagr_5y": trends.get("revenue_cagr"),
+                    "net_income_cagr_5y": trends.get("net_income_cagr"),
+                    "eps_cagr_5y": trends.get("eps_cagr"),
+                    "asset_growth_5y": trends.get("asset_growth"),
+                    "revenue_history": trends.get("revenue_history", [])[-5:],
+                    "net_income_history": trends.get("net_income_history", [])[-5:],
+                }
+        except:
+            pass
+        
+        # Fallback to Yahoo
+        earnings = get_earnings_data(ticker)
+        return {
+            "annual_financials": earnings.get("annual_financials", [])[:5],
+            "quarterly_revenue": earnings.get("quarterly_revenue", [])[:8],
+        }
+    
+    def _get_price_performance(self, ticker: str) -> dict:
+        """Price performance and technicals."""
+        # Multiple timeframes
+        perf = {}
+        
+        for period, label in [("1mo", "1M"), ("3mo", "3M"), ("6mo", "6M"), ("1y", "1Y"), ("5y", "5Y")]:
+            data = get_stock_prices(ticker, period, "1d")
+            if "error" not in data:
+                perf[f"return_{label}"] = data.get("summary_stats", {}).get("total_return_pct")
+        
+        # Get current data
+        current = get_stock_prices(ticker, "1y", "1d")
+        if "error" not in current:
+            stats = current.get("summary_stats", {})
+            quote = current.get("current_quote", {})
+            
+            perf["current_price"] = quote.get("price")
+            perf["52_week_high"] = stats.get("52_week_high")
+            perf["52_week_low"] = stats.get("52_week_low")
+            perf["sma_50"] = stats.get("sma_50")
+            perf["sma_200"] = stats.get("sma_200")
+            perf["beta"] = quote.get("beta")
+            
+            # Price vs SMAs
+            price = quote.get("price", 0)
+            if stats.get("sma_50") and price:
+                perf["vs_sma_50_pct"] = round(((price - stats["sma_50"]) / stats["sma_50"]) * 100, 2)
+            if stats.get("sma_200") and price:
+                perf["vs_sma_200_pct"] = round(((price - stats["sma_200"]) / stats["sma_200"]) * 100, 2)
+            
+            # 52W range position
+            high = stats.get("52_week_high", 0)
+            low = stats.get("52_week_low", 0)
+            if high and low and high != low:
+                perf["52w_range_position_pct"] = round(((price - low) / (high - low)) * 100, 2)
+        
+        return perf
+    
+    def _get_valuation(self, ticker: str) -> dict:
+        """Valuation metrics."""
+        prices = get_stock_prices(ticker, "1d", "1d")
+        quote = prices.get("current_quote", {})
+        
+        valuation = {
+            "pe_ratio": quote.get("pe_ratio"),
+            "forward_pe": quote.get("forward_pe"),
+            "dividend_yield_pct": quote.get("dividend_yield"),
+        }
+        
+        # Calculate P/S if we have data
+        market_cap = quote.get("market_cap")
+        try:
+            health_data = self.health.analyze(ticker)
+            if hasattr(health_data, 'to_dict'):
+                metrics = health_data.to_dict().get("metrics", {})
+                revenue = metrics.get("_revenue", {}).get("value")
+                if market_cap and revenue and revenue > 0:
+                    valuation["ps_ratio"] = round(market_cap / revenue, 2)
+        except:
+            pass
+        
+        return valuation
+    
+    def _get_earnings_quality(self, ticker: str) -> dict:
+        """Earnings quality and predictability."""
+        earnings = get_earnings_data(ticker)
+        if "error" in earnings:
+            return earnings
+        
+        track = earnings.get("track_record", {})
+        
+        # Get post-earnings moves
+        try:
+            moves = self.earnings_agent.analyze_post_earnings_moves(ticker, 8)
+            post_moves = moves.get("summary", {})
+        except:
+            post_moves = {}
+        
+        return {
+            "beat_rate_pct": track.get("beat_rate_pct"),
+            "total_beats": track.get("beats"),
+            "total_misses": track.get("misses"),
+            "next_earnings": earnings.get("next_earnings", {}).get("date"),
+            "trailing_eps": earnings.get("current_estimates", {}).get("trailing_eps"),
+            "forward_eps": earnings.get("current_estimates", {}).get("forward_eps"),
+            "earnings_growth_pct": earnings.get("current_estimates", {}).get("earnings_growth"),
+            "revenue_growth_pct": earnings.get("current_estimates", {}).get("revenue_growth"),
+            "peg_ratio": earnings.get("current_estimates", {}).get("peg_ratio"),
+            "avg_move_on_beat_pct": post_moves.get("avg_move_on_beat_pct"),
+            "avg_move_on_miss_pct": post_moves.get("avg_move_on_miss_pct"),
+            "recent_history": earnings.get("earnings_history", [])[:4],
+        }
+    
+    def _get_insider_sentiment(self, ticker: str) -> dict:
+        """Insider trading activity and sentiment."""
+        insider = get_insider_transactions(ticker, days_back=180)
+        if "error" in insider:
+            return insider
+        
+        s = insider.get("summary", {})
+        
+        return {
+            "signal": s.get("signal"),
+            "total_buys": s.get("total_buys"),
+            "total_sells": s.get("total_sells"),
+            "total_buy_value": s.get("total_buy_value"),
+            "total_sell_value": s.get("total_sell_value"),
+            "net_value": s.get("net_value"),
+            "unique_buyers": s.get("unique_buyers", 0),
+            "unique_sellers": s.get("unique_sellers", 0),
+            "notable_transactions": insider.get("notable_transactions", [])[:3],
+        }
+    
+    def _get_peer_comparison(self, ticker: str, peers: List[str]) -> dict:
+        """Side-by-side peer comparison."""
+        all_tickers = [ticker] + peers
+        
+        comparison = {"tickers": all_tickers, "metrics": {}}
+        
+        for t in all_tickers:
+            try:
+                # Get key metrics for each
+                prices = get_stock_prices(t, "1y", "1d")
+                quote = prices.get("current_quote", {})
+                stats = prices.get("summary_stats", {})
+                
+                health_data = self.health.analyze(t)
+                metrics = {}
+                if hasattr(health_data, 'to_dict'):
+                    metrics = health_data.to_dict().get("metrics", {})
+                
+                comparison["metrics"][t] = {
+                    "market_cap": quote.get("market_cap"),
+                    "pe_ratio": quote.get("pe_ratio"),
+                    "return_1y_pct": stats.get("total_return_pct"),
+                    "roe_pct": metrics.get("roe_pct", {}).get("value"),
+                    "net_margin_pct": metrics.get("net_margin_pct", {}).get("value"),
+                    "debt_to_equity": metrics.get("debt_to_equity", {}).get("value"),
+                }
+            except:
+                comparison["metrics"][t] = {"error": "Could not retrieve data"}
+        
+        return comparison
+    
+    def _get_risk_assessment(self, report: dict) -> dict:
+        """Assess key risks based on collected data."""
+        risks = []
+        risk_score = 0
+        
+        # Leverage risk
+        leverage = report.get("financial_health", {}).get("leverage", {})
+        debt_to_equity = leverage.get("debt_to_equity")
+        if debt_to_equity and debt_to_equity > 2:
+            risks.append({"type": "HIGH_LEVERAGE", "detail": f"Debt/Equity of {debt_to_equity}x is elevated"})
+            risk_score += 2
+        elif debt_to_equity and debt_to_equity > 1:
+            risks.append({"type": "MODERATE_LEVERAGE", "detail": f"Debt/Equity of {debt_to_equity}x"})
+            risk_score += 1
+        
+        # Earnings volatility
+        earnings = report.get("earnings", {})
+        beat_rate = earnings.get("beat_rate_pct")
+        if beat_rate and beat_rate < 50:
+            risks.append({"type": "EARNINGS_VOLATILITY", "detail": f"Only {beat_rate}% beat rate"})
+            risk_score += 2
+        
+        # Insider selling
+        insider = report.get("insider_activity", {})
+        if insider.get("signal") == "net_selling":
+            net_sell = insider.get("net_value", 0)
+            risks.append({"type": "INSIDER_SELLING", "detail": f"Net insider selling of ${abs(net_sell):,.0f}"})
+            risk_score += 1
+        
+        # Valuation risk
+        valuation = report.get("valuation", {})
+        pe = valuation.get("pe_ratio")
+        if pe and pe > 50:
+            risks.append({"type": "HIGH_VALUATION", "detail": f"P/E of {pe}x is elevated"})
+            risk_score += 1
+        
+        # Price momentum
+        perf = report.get("price_performance", {})
+        vs_sma_200 = perf.get("vs_sma_200_pct")
+        if vs_sma_200 and vs_sma_200 < -20:
+            risks.append({"type": "NEGATIVE_MOMENTUM", "detail": f"Trading {abs(vs_sma_200)}% below 200-day SMA"})
+            risk_score += 1
+        
+        # Liquidity risk
+        liquidity = report.get("financial_health", {}).get("liquidity", {})
+        current_ratio = liquidity.get("current_ratio")
+        if current_ratio and current_ratio < 1:
+            risks.append({"type": "LIQUIDITY_CONCERN", "detail": f"Current ratio of {current_ratio}x below 1"})
+            risk_score += 2
+        
+        return {
+            "risk_score": risk_score,
+            "risk_level": "HIGH" if risk_score >= 5 else "MODERATE" if risk_score >= 2 else "LOW",
+            "identified_risks": risks,
+        }
+    
+    def _generate_thesis(self, report: dict) -> dict:
+        """Generate bull/bear thesis and key catalysts."""
+        bull_points = []
+        bear_points = []
+        catalysts = []
+        
+        # Analyze the data for thesis points
+        
+        # Profitability
+        prof = report.get("financial_health", {}).get("profitability", {})
+        roe = prof.get("roe_pct")
+        margin = prof.get("net_margin_pct")
+        
+        if roe and roe > 15:
+            bull_points.append(f"Strong ROE of {roe}% indicates efficient capital deployment")
+        elif roe and roe < 10:
+            bear_points.append(f"Below-average ROE of {roe}%")
+        
+        if margin and margin > 20:
+            bull_points.append(f"High profit margins of {margin}% provide cushion")
+        elif margin and margin < 5:
+            bear_points.append(f"Thin margins of {margin}% limit flexibility")
+        
+        # Growth
+        growth = report.get("growth", {})
+        rev_cagr = growth.get("revenue_cagr_5y")
+        if rev_cagr and rev_cagr > 10:
+            bull_points.append(f"Strong revenue growth of {rev_cagr}% CAGR over 5 years")
+        elif rev_cagr and rev_cagr < 0:
+            bear_points.append(f"Declining revenue ({rev_cagr}% CAGR)")
+        
+        # Earnings
+        earnings = report.get("earnings", {})
+        beat_rate = earnings.get("beat_rate_pct")
+        if beat_rate and beat_rate > 75:
+            bull_points.append(f"Consistent earnings beats ({beat_rate}% beat rate)")
+        
+        earnings_growth = earnings.get("earnings_growth_pct")
+        if earnings_growth and earnings_growth > 15:
+            bull_points.append(f"Strong earnings growth outlook ({earnings_growth}%)")
+        elif earnings_growth and earnings_growth < 0:
+            bear_points.append(f"Negative earnings growth expected ({earnings_growth}%)")
+        
+        # Insider activity
+        insider = report.get("insider_activity", {})
+        if insider.get("signal") == "net_buying":
+            bull_points.append("Insider buying signals management confidence")
+        elif insider.get("signal") == "net_selling":
+            bear_points.append("Notable insider selling activity")
+        
+        # Valuation
+        valuation = report.get("valuation", {})
+        pe = valuation.get("pe_ratio")
+        forward_pe = valuation.get("forward_pe")
+        if pe and forward_pe and forward_pe < pe:
+            bull_points.append(f"Forward P/E ({forward_pe}x) below trailing ({pe}x) suggests growth")
+        if pe and pe > 40:
+            bear_points.append(f"Premium valuation at {pe}x P/E")
+        
+        # Catalysts
+        next_earnings = earnings.get("next_earnings")
+        if next_earnings:
+            catalysts.append(f"Upcoming earnings: {next_earnings}")
+        
+        # Technical
+        perf = report.get("price_performance", {})
+        if perf.get("vs_sma_200_pct") and perf["vs_sma_200_pct"] > 0:
+            catalysts.append("Trading above 200-day moving average (bullish trend)")
+        
+        return {
+            "bull_case": bull_points[:5],
+            "bear_case": bear_points[:5],
+            "catalysts": catalysts[:3],
+            "summary": self._generate_summary(report, bull_points, bear_points),
+        }
+    
+    def _generate_summary(self, report: dict, bull_points: list, bear_points: list) -> str:
+        """Generate one-paragraph summary."""
+        ticker = report.get("ticker", "")
+        name = report.get("overview", {}).get("company_name", ticker)
+        
+        # Build summary based on data
+        parts = [f"{name} ({ticker})"]
+        
+        # Market cap context
+        mcap = report.get("overview", {}).get("market_cap")
+        if mcap:
+            if mcap > 200e9:
+                parts.append("is a mega-cap company")
+            elif mcap > 10e9:
+                parts.append("is a large-cap company")
+            elif mcap > 2e9:
+                parts.append("is a mid-cap company")
+            else:
+                parts.append("is a small-cap company")
+        
+        # Financial health
+        risk_level = report.get("risks", {}).get("risk_level", "MODERATE")
+        if risk_level == "LOW":
+            parts.append("with a solid financial profile.")
+        elif risk_level == "HIGH":
+            parts.append("with elevated risk factors.")
+        else:
+            parts.append("with a moderate risk profile.")
+        
+        # Key metrics
+        roe = report.get("financial_health", {}).get("profitability", {}).get("roe_pct")
+        margin = report.get("financial_health", {}).get("profitability", {}).get("net_margin_pct")
+        if roe and margin:
+            parts.append(f"Profitability metrics show {roe}% ROE and {margin}% net margins.")
+        
+        # Verdict hint
+        if len(bull_points) > len(bear_points) + 2:
+            parts.append("The overall picture skews positive.")
+        elif len(bear_points) > len(bull_points) + 2:
+            parts.append("Several concerns warrant caution.")
+        else:
+            parts.append("The investment case is balanced.")
+        
+        return " ".join(parts)
+    
+    def quick_screen(self, tickers: List[str]) -> dict:
+        """
+        Quick screening of multiple stocks.
+        Returns key metrics for comparison.
+        """
+        results = []
+        
+        for ticker in tickers[:20]:
+            try:
+                prices = get_stock_prices(ticker, "1y", "1d")
+                quote = prices.get("current_quote", {})
+                stats = prices.get("summary_stats", {})
+                
+                insider = get_insider_transactions(ticker, days_back=90)
+                insider_signal = insider.get("summary", {}).get("signal", "unknown")
+                
+                results.append({
+                    "ticker": ticker.upper(),
+                    "price": quote.get("price"),
+                    "market_cap": quote.get("market_cap"),
+                    "pe_ratio": quote.get("pe_ratio"),
+                    "return_1y_pct": stats.get("total_return_pct"),
+                    "vs_sma_200_pct": None,  # Would need calculation
+                    "insider_signal": insider_signal,
+                })
+            except:
+                results.append({"ticker": ticker.upper(), "error": "Failed to retrieve"})
+        
+        return {
+            "source": "Eugene Intelligence",
+            "tickers_screened": len(tickers),
+            "results": results,
+        }