sigma-terminal 2.0.2__py3-none-any.whl → 3.3.0__py3-none-any.whl

sigma/app.py

@@ -1,947 +1,856 @@
-"""Sigma CLI - Professional financial research interface."""
+"""Sigma v3.3.0 - Finance Research Agent."""
 
 import asyncio
-import sys
+import os
 import re
-from typing import Any, Optional
-import time
+from datetime import datetime
+from typing import Optional, List
 
-from rich.console import Console
+from rich.markdown import Markdown
 from rich.panel import Panel
-from rich.text import Text
 from rich.table import Table
-from rich.markdown import Markdown
-from rich.padding import Padding
-from rich.box import ROUNDED, SIMPLE, HEAVY, DOUBLE
-from rich.columns import Columns
-from rich import box
+from rich.text import Text
+from textual import on, work
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.containers import Container, Horizontal, Vertical, ScrollableContainer
+from textual.widgets import Footer, Input, RichLog, Static
+from textual.suggester import Suggester
+
+from .config import LLMProvider, get_settings, save_api_key, AVAILABLE_MODELS
+from .llm import get_llm
+from .tools import TOOLS, execute_tool
+from .backtest import run_backtest, get_available_strategies, BACKTEST_TOOL
+
 
-from sigma.core.agent import SigmaAgent
-from sigma.core.config import LLMProvider, get_settings
+__version__ = "3.3.0"
+SIGMA = "σ"
 
+# Common stock tickers for recognition
+COMMON_TICKERS = {
+    "AAPL", "MSFT", "GOOGL", "GOOG", "AMZN", "NVDA", "META", "TSLA", "BRK.A", "BRK.B",
+    "JPM", "JNJ", "V", "PG", "UNH", "HD", "MA", "DIS", "PYPL", "BAC", "ADBE", "NFLX",
+    "CRM", "INTC", "AMD", "CSCO", "PEP", "KO", "ABT", "NKE", "MRK", "PFE", "TMO",
+    "COST", "AVGO", "WMT", "ACN", "LLY", "MCD", "DHR", "TXN", "NEE", "PM", "HON",
+    "UPS", "BMY", "QCOM", "LOW", "MS", "RTX", "UNP", "ORCL", "IBM", "GE", "CAT",
+    "SBUX", "AMAT", "GS", "BLK", "DE", "AMT", "NOW", "ISRG", "LMT", "MDLZ", "AXP",
+    "SYK", "BKNG", "PLD", "GILD", "ADI", "TMUS", "CVS", "MMC", "ZTS", "CB", "C",
+    "SPY", "QQQ", "IWM", "DIA", "VTI", "VOO", "VXX", "ARKK", "XLF", "XLK", "XLE",
+}
+
+# Small sigma animation frames (minimal footprint)
+SMALL_SIGMA_FRAMES = [
+    "[bold blue]σ[/bold blue]",
+    "[bold cyan]σ[/bold cyan]",
+    "[bold white]σ[/bold white]",
+    "[bold #60a5fa]σ[/bold #60a5fa]",
+]
 
-console = Console()
+# Tool call animation frames
+TOOL_CALL_FRAMES = [
+    "⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"
+]
 
-# Version
-VERSION = "2.0.2"
+# Welcome banner - clean design
+WELCOME_BANNER = """
+[bold blue]███████╗██╗ ██████╗ ███╗   ███╗ █████╗ [/bold blue]
+[bold blue]██╔════╝██║██╔════╝ ████╗ ████║██╔══██╗[/bold blue]
+[bold blue]███████╗██║██║  ███╗██╔████╔██║███████║[/bold blue]
+[bold blue]╚════██║██║██║   ██║██║╚██╔╝██║██╔══██║[/bold blue]
+[bold blue]███████║██║╚██████╔╝██║ ╚═╝ ██║██║  ██║[/bold blue]
+[bold blue]╚══════╝╚═╝ ╚═════╝ ╚═╝     ╚═╝╚═╝  ╚═╝[/bold blue]
 
-# ASCII Art Banner
-BANNER = """[bold bright_blue]
- ███████╗██╗ ██████╗ ███╗   ███╗ █████╗ 
- ██╔════╝██║██╔════╝ ████╗ ████║██╔══██╗
- ███████╗██║██║  ███╗██╔████╔██║███████║
- ╚════██║██║██║   ██║██║╚██╔╝██║██╔══██║
- ███████║██║╚██████╔╝██║ ╚═╝ ██║██║  ██║
- ╚══════╝╚═╝ ╚═════╝ ╚═╝     ╚═╝╚═╝  ╚═╝[/bold bright_blue]
+[bold cyan]Finance Research Agent[/bold cyan]  [dim]v3.3.0 | Native macOS[/dim]
 """
 
-SUB_BANNER = """[dim]━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━[/dim]
-[bold white]        Institutional-Grade Financial Research Agent[/bold white]
-[dim]━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━[/dim]"""
-
-
-def print_banner(model: str):
-    """Print the startup banner."""
-    console.print()
-    console.print(BANNER)
-    console.print(SUB_BANNER)
-    console.print()
-    
-    # Status line
-    console.print(f"  [dim]Version:[/dim] [bright_cyan]{VERSION}[/bright_cyan]    [dim]Model:[/dim] [bright_cyan]{model}[/bright_cyan]")
-    console.print()
-    console.print("  [dim]Type[/dim] [bold bright_yellow]/help[/bold bright_yellow] [dim]for commands[/dim]    [dim]Type[/dim] [bold bright_yellow]/quit[/bold bright_yellow] [dim]to exit[/dim]")
-    console.print()
-
-
-def print_help():
-    """Print comprehensive help."""
-    console.print()
-    
-    # Commands table
-    commands = Table(title="[bold bright_cyan]Commands[/bold bright_cyan]", box=ROUNDED, show_header=True, header_style="bold")
-    commands.add_column("Command", style="bright_yellow")
-    commands.add_column("Description", style="white")
-    
-    commands.add_row("/help, /h, /?", "Show this help message")
-    commands.add_row("/model <provider>", "Switch LLM provider (openai, anthropic, google, groq, ollama)")
-    commands.add_row("/mode <mode>", "Switch analysis mode (default, technical, fundamental, quant)")
-    commands.add_row("/clear", "Clear conversation history")
-    commands.add_row("/status", "Show current configuration")
-    commands.add_row("/chart <symbol>", "Quick price chart for a symbol")
-    commands.add_row("/compare <sym1> <sym2>...", "Quick comparison chart")
-    commands.add_row("/backtest <symbol> <strategy>", "Generate backtest algorithm")
-    commands.add_row("/lean setup", "Setup LEAN Engine for backtesting")
-    commands.add_row("/lean run <symbol> <strategy>", "Run backtest with LEAN Engine")
-    commands.add_row("/quit, /exit, /q", "Exit Sigma")
-    
-    console.print(commands)
-    console.print()
-    
-    # Analysis modes
-    modes = Table(title="[bold bright_cyan]Analysis Modes[/bold bright_cyan]", box=ROUNDED, show_header=True, header_style="bold")
-    modes.add_column("Mode", style="bright_yellow")
-    modes.add_column("Description", style="white")
-    
-    modes.add_row("default", "Comprehensive analysis using all available tools")
-    modes.add_row("technical", "Focus on technical indicators, charts, and price action")
-    modes.add_row("fundamental", "Focus on financial statements, ratios, and valuations")
-    modes.add_row("quant", "Quantitative analysis with predictions and backtesting")
-    
-    console.print(modes)
-    console.print()
-    
-    # Examples
-    examples = Table(title="[bold bright_cyan]Example Queries[/bold bright_cyan]", box=ROUNDED, show_header=False)
-    examples.add_column("Query", style="white")
-    
-    examples.add_row("[dim]── Stock Analysis ──[/dim]")
-    examples.add_row("  Analyze NVDA stock")
-    examples.add_row("  Is AAPL a good investment?")
-    examples.add_row("  Give me a deep dive on Tesla")
-    examples.add_row("")
-    examples.add_row("[dim]── Charts & Visualization ──[/dim]")
-    examples.add_row("  Show me a chart of MSFT for the past 6 months")
-    examples.add_row("  Compare NVDA, AMD, and INTC")
-    examples.add_row("  Show RSI chart for SPY")
-    examples.add_row("")
-    examples.add_row("[dim]── Technical Analysis ──[/dim]")
-    examples.add_row("  Technical analysis on QQQ")
-    examples.add_row("  What are the support levels for META?")
-    examples.add_row("  Is GOOGL overbought?")
-    examples.add_row("")
-    examples.add_row("[dim]── Predictions & Sentiment ──[/dim]")
-    examples.add_row("  Predict AMZN price for next month")
-    examples.add_row("  What's the sentiment on TSLA?")
-    examples.add_row("  Price forecast for Bitcoin")
-    examples.add_row("")
-    examples.add_row("[dim]── Backtesting & Strategy ──[/dim]")
-    examples.add_row("  Create a MACD strategy backtest for AAPL")
-    examples.add_row("  Generate RSI mean reversion backtest for SPY")
-    examples.add_row("  List available backtest strategies")
-    examples.add_row("")
-    examples.add_row("[dim]── Market Overview ──[/dim]")
-    examples.add_row("  What are today's market movers?")
-    examples.add_row("  Show sector performance")
-    examples.add_row("  How are the major indices doing?")
-    
-    console.print(examples)
-    console.print()
-    
-    # Strategies
-    strategies = Table(title="[bold bright_cyan]Backtest Strategies[/bold bright_cyan]", box=ROUNDED, show_header=True, header_style="bold")
-    strategies.add_column("Strategy", style="bright_yellow")
-    strategies.add_column("Description", style="white")
-    
-    strategies.add_row("sma_crossover", "Classic moving average crossover (fast/slow SMA)")
-    strategies.add_row("rsi_mean_reversion", "Buy oversold, sell overbought using RSI")
-    strategies.add_row("macd_momentum", "MACD histogram momentum strategy")
-    strategies.add_row("bollinger_bands", "Mean reversion at Bollinger Band extremes")
-    strategies.add_row("dual_momentum", "Absolute + relative momentum")
-    strategies.add_row("breakout", "Donchian channel breakout strategy")
-    
-    console.print(strategies)
-    console.print()
-
-
-# Tool name mappings for cleaner display
-TOOL_DISPLAY_NAMES = {
-    "get_stock_quote": "Stock Quote",
-    "get_stock_history": "Price History",
-    "get_company_info": "Company Info",
-    "get_financial_statements": "Financials",
-    "get_analyst_recommendations": "Analyst Ratings",
-    "get_insider_trades": "Insider Trades",
-    "get_institutional_holders": "Institutions",
-    "get_earnings_calendar": "Earnings",
-    "get_options_chain": "Options Chain",
-    "get_dividends": "Dividends",
-    "compare_stocks": "Compare Stocks",
-    "get_market_movers": "Market Movers",
-    "get_sector_performance": "Sectors",
-    "get_market_indices": "Market Indices",
-    "calculate_portfolio_metrics": "Portfolio",
-    "search_stocks": "Stock Search",
-    "get_stock_news": "News",
-    "technical_analysis": "Technicals",
-    "generate_price_chart": "Price Chart",
-    "generate_comparison_chart": "Comparison",
-    "generate_rsi_chart": "RSI Chart",
-    "generate_sector_chart": "Sectors",
-    "list_backtest_strategies": "Strategies",
-    "generate_backtest": "Backtest",
-    "generate_custom_backtest": "Custom Backtest",
-    "price_forecast": "Forecast",
-    "sentiment_analysis": "Sentiment",
-}
+SYSTEM_PROMPT = """You are Sigma, a Finance Research Agent. You provide comprehensive market analysis, trading strategies, and investment insights.
 
-TOOL_ICONS = {
-    "get_stock_quote": ">",
-    "get_stock_history": ">",
-    "get_company_info": ">",
-    "get_financial_statements": ">",
-    "get_analyst_recommendations": ">",
-    "get_insider_trades": ">",
-    "get_institutional_holders": ">",
-    "get_earnings_calendar": ">",
-    "get_options_chain": ">",
-    "get_dividends": ">",
-    "compare_stocks": ">",
-    "get_market_movers": ">",
-    "get_sector_performance": ">",
-    "get_market_indices": ">",
-    "calculate_portfolio_metrics": ">",
-    "search_stocks": ">",
-    "get_stock_news": ">",
-    "technical_analysis": ">",
-    "generate_price_chart": ">",
-    "generate_comparison_chart": ">",
-    "generate_rsi_chart": ">",
-    "generate_sector_chart": ">",
-    "list_backtest_strategies": ">",
-    "generate_backtest": ">",
-    "generate_custom_backtest": ">",
-    "price_forecast": ">",
-    "sentiment_analysis": ">",
-}
+CORE CAPABILITIES:
+- Real-time market data analysis (quotes, charts, technicals)
+- Fundamental analysis (financials, ratios, earnings)
+- Technical analysis (RSI, MACD, Bollinger Bands, moving averages)
+- Backtesting strategies (SMA crossover, RSI, MACD, Bollinger, momentum, breakout)
+- Portfolio analysis and optimization
+- Sector and market overview
+- Insider and fund activity tracking
 
+RESPONSE STYLE:
+- Be concise and data-driven
+- Lead with key insights, then supporting data
+- Use tables for comparative data when appropriate
+- Always cite specific numbers and metrics
+- Provide actionable recommendations when asked
+- Format currency and percentages properly
+- Use STRONG BUY, BUY, HOLD, SELL, STRONG SELL ratings when appropriate
 
-def format_tool_description(name: str, args: dict) -> tuple[str, Optional[str]]:
-    """Format tool call with description. Returns (display_name, detail)."""
-    display_name = TOOL_DISPLAY_NAMES.get(name, name.replace('_', ' ').title())
-    icon = TOOL_ICONS.get(name, "●")
-    
-    symbol = args.get('symbol', '')
-    symbols = args.get('symbols', [])
-    query = args.get('query', '')
-    strategy = args.get('strategy', '')
-    
-    if symbol and strategy:
-        return f"{icon} {display_name}", f"{symbol.upper()} - {strategy}"
-    elif symbol:
-        return f"{icon} {display_name}", symbol.upper()
-    elif symbols:
-        return f"{icon} {display_name}", ', '.join(s.upper() for s in symbols[:3])
-    elif query:
-        return f"{icon} {display_name}", query[:30]
-    else:
-        return f"{icon} {display_name}", None
+When users ask about stocks, always gather current data using your tools before responding."""
 
+# Enhanced autocomplete suggestions with more variety
+SUGGESTIONS = [
+    # Analysis commands
+    "analyze AAPL",
+    "analyze MSFT", 
+    "analyze GOOGL",
+    "analyze NVDA",
+    "analyze TSLA",
+    "analyze META",
+    "analyze AMZN",
+    "analyze AMD",
+    "analyze SPY",
+    # Comparisons
+    "compare AAPL MSFT GOOGL",
+    "compare NVDA AMD INTC",
+    "compare META GOOGL AMZN",
+    "compare TSLA RIVN LCID",
+    # Technical
+    "technical analysis of AAPL",
+    "technical analysis of SPY",
+    "technical analysis of NVDA",
+    "technical analysis of QQQ",
+    # Backtesting
+    "backtest SMA crossover on AAPL",
+    "backtest RSI strategy on SPY",
+    "backtest MACD on NVDA",
+    "backtest momentum on QQQ",
+    # Market
+    "market overview",
+    "sector performance",
+    "what sectors are hot today",
+    # Quotes
+    "get quote for AAPL",
+    "price of NVDA",
+    "how is TSLA doing",
+    # Fundamentals
+    "fundamentals of MSFT",
+    "financials for AAPL",
+    "earnings of NVDA",
+    # Activity
+    "insider trading for AAPL",
+    "institutional holders of NVDA",
+    "analyst recommendations for TSLA",
+    # Natural language queries
+    "what should I know about AAPL",
+    "is NVDA overvalued",
+    "best tech stocks right now",
+    "should I buy TSLA",
+    # Commands
+    "/help",
+    "/clear",
+    "/keys",
+    "/models",
+    "/status",
+    "/backtest",
+]
 
-class SigmaUI:
-    """Professional terminal UI for Sigma."""
+
+def extract_tickers(text: str) -> List[str]:
+    """Extract stock tickers from text."""
+    # Look for common patterns: $AAPL, or standalone uppercase words
+    # Only match if it's a known ticker or starts with $
+    words = text.upper().split()
+    tickers = []
+    
+    for word in words:
+        # Clean the word
+        clean = word.strip('.,!?()[]{}":;')
+        
+        # Check for $TICKER format
+        if clean.startswith('$'):
+            ticker = clean[1:]
+            if ticker and ticker.isalpha() and len(ticker) <= 5:
+                tickers.append(ticker)
+        # Check if it's a known ticker
+        elif clean in COMMON_TICKERS:
+            tickers.append(clean)
+    
+    return list(dict.fromkeys(tickers))  # Dedupe while preserving order
+
+
+class SigmaSuggester(Suggester):
+    """Enhanced autocomplete suggester with ticker recognition."""
     
     def __init__(self):
-        self.settings = get_settings()
-        self.agent: Optional[SigmaAgent] = None
-        self.provider = self.settings.default_provider
-        self.tool_calls: list[tuple[str, float]] = []
-        self.start_time = 0.0
-        self.custom_model: Optional[str] = None
-        self.mode = "default"  # default, technical, fundamental, quant
-        self.chart_output: Optional[str] = None  # Store chart for display
-    
-    def _init_agent(self):
-        """Initialize agent."""
-        self.agent = SigmaAgent(provider=self.provider, model=self.custom_model)
-    
-    def _get_model_display(self) -> str:
-        """Get model name for display."""
-        if self.custom_model:
-            return self.custom_model
-        return self.settings.get_model(self.provider)
-    
-    def on_tool_start(self, name: str, args: dict):
-        """Called when tool starts."""
-        display_name, detail = format_tool_description(name, args)
-        if detail:
-            console.print(f"    [bright_cyan]{display_name}[/bright_cyan] [dim]({detail})[/dim]")
-        else:
-            console.print(f"    [bright_cyan]{display_name}[/bright_cyan]")
+        super().__init__(use_cache=True, case_sensitive=False)
     
-    def on_tool_end(self, name: str, result: Any, duration_ms: float):
-        """Called when tool ends."""
-        self.tool_calls.append((name, duration_ms))
+    async def get_suggestion(self, value: str) -> Optional[str]:
+        """Get autocomplete suggestion."""
+        if not value or len(value) < 2:
+            return None
         
-        # Check for chart output
-        if isinstance(result, dict) and result.get("display_as_chart"):
-            self.chart_output = result.get("chart", "")
-    
-    def on_thinking(self, content: str):
-        """Called when agent is thinking."""
-        pass
-    
-    def on_response(self, content: str):
-        """Called with final response."""
-        pass
-    
-    async def process_query(self, query: str):
-        """Process a query."""
-        if self.agent is None:
-            self._init_agent()
+        value_lower = value.lower()
         
-        assert self.agent is not None
+        # Check for ticker pattern (all caps or starts with $)
+        if value.startswith("$") or value.isupper():
+            ticker = value.lstrip("$").upper()
+            for common in COMMON_TICKERS:
+                if common.startswith(ticker) and common != ticker:
+                    return f"analyze {common}"
         
-        self.tool_calls = []
-        self.start_time = time.time()
-        self.chart_output = None
+        # Standard suggestions
+        for suggestion in SUGGESTIONS:
+            if suggestion.lower().startswith(value_lower):
+                return suggestion
         
-        console.print()
-        console.print("  [dim]╭─ Researching...[/dim]")
+        # Try partial match in middle of suggestion
+        for suggestion in SUGGESTIONS:
+            if value_lower in suggestion.lower():
+                return suggestion
         
-        # Run agent
-        response = await self.agent.run(
-            query,
-            on_tool_start=self.on_tool_start,
-            on_tool_end=self.on_tool_end,
-            on_thinking=self.on_thinking,
-            on_response=self.on_response,
-        )
-        
-        elapsed = time.time() - self.start_time
-        
-        # Print data sources summary
-        if self.tool_calls:
-            console.print(f"  [dim]╰─[/dim] [bright_green]Called {len(self.tool_calls)} data sources[/bright_green] [dim]in {elapsed:.1f}s[/dim]")
-        
-        console.print()
-        
-        # Print chart if generated
-        if self.chart_output:
-            console.print(self.chart_output)
-            console.print()
-        
-        # Print response
-        self._display_response(response)
-        
-        console.print()
+        return None
+
+
+CSS = """
+Screen {
+    background: #0a0a0f;
+}
+
+* {
+    scrollbar-size: 1 1;
+    scrollbar-color: #3b82f6 30%;
+    scrollbar-color-hover: #60a5fa 50%;
+    scrollbar-color-active: #93c5fd 70%;
+}
+
+#main-container {
+    width: 100%;
+    height: 100%;
+    background: #0a0a0f;
+}
+
+#chat-area {
+    height: 1fr;
+    margin: 1 2;
+    background: #0a0a0f;
+}
+
+#chat-log {
+    background: #0a0a0f;
+    padding: 1 0;
+}
+
+#status-bar {
+    height: 3;
+    background: #0d1117;
+    border-top: solid #1a1a2e;
+    padding: 0 2;
+    dock: bottom;
+}
+
+#status-content {
+    width: 100%;
+    height: 100%;
+    content-align: left middle;
+}
+
+#thinking-indicator {
+    width: auto;
+    height: 1;
+    content-align: center middle;
+    display: none;
+}
+
+#thinking-indicator.visible {
+    display: block;
+}
+
+#tool-calls-display {
+    width: 100%;
+    height: auto;
+    max-height: 6;
+    background: #0d1117;
+    border: solid #1a1a2e;
+    margin: 0 2;
+    padding: 0 1;
+    display: none;
+}
+
+#tool-calls-display.visible {
+    display: block;
+}
+
+#input-area {
+    height: 5;
+    padding: 1 2;
+    background: #0d1117;
+}
+
+#input-row {
+    height: 3;
+    width: 100%;
+}
+
+#sigma-indicator {
+    width: 4;
+    height: 3;
+    content-align: center middle;
+}
+
+#prompt-input {
+    width: 1fr;
+    background: #1a1a2e;
+    border: solid #3b82f6;
+    color: #ffffff;
+    padding: 0 1;
+}
+
+#prompt-input:focus {
+    border: solid #60a5fa;
+}
+
+#prompt-input.-autocomplete {
+    border: solid #22c55e;
+}
+
+#ticker-highlight {
+    width: auto;
+    height: 1;
+    padding: 0 1;
+    background: transparent;
+}
+
+Footer {
+    background: #0d1117;
+    height: 1;
+    dock: bottom;
+}
+
+Footer > .footer--highlight {
+    background: transparent;
+}
+
+Footer > .footer--key {
+    background: #1a1a2e;
+    color: #f59e0b;
+    text-style: bold;
+}
+
+Footer > .footer--description {
+    color: #6b7280;
+}
+
+#help-panel {
+    width: 100%;
+    height: auto;
+    padding: 1;
+    background: #0d1117;
+    border: solid #3b82f6;
+    margin: 1 2;
+    display: none;
+}
+
+#help-panel.visible {
+    display: block;
+}
+"""
+
+
+class ToolCallDisplay(Static):
+    """Animated display for tool calls."""
+    
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.tool_calls: List[dict] = []
+        self.frame = 0
+        self.timer = None
+    
+    def add_tool_call(self, name: str, status: str = "running"):
+        """Add a tool call to the display."""
+        self.tool_calls.append({"name": name, "status": status, "frame": 0})
+        self.add_class("visible")
+        self._render()
+        if not self.timer:
+            self.timer = self.set_interval(0.1, self._animate)
+    
+    def complete_tool_call(self, name: str):
+        """Mark a tool call as complete."""
+        for tc in self.tool_calls:
+            if tc["name"] == name and tc["status"] == "running":
+                tc["status"] = "complete"
+                break
+        self._render()
     
-    def _display_response(self, response: str):
-        """Display the response with professional formatting."""
-        lines = response.split('\n')
-        in_table = False
-        table_lines: list[str] = []
+    def clear(self):
+        """Clear all tool calls."""
+        self.tool_calls = []
+        if self.timer:
+            self.timer.stop()
+            self.timer = None
+        self.remove_class("visible")
+        self.update("")
+    
+    def _animate(self):
+        """Animate the spinner."""
+        self.frame = (self.frame + 1) % len(TOOL_CALL_FRAMES)
+        for tc in self.tool_calls:
+            if tc["status"] == "running":
+                tc["frame"] = self.frame
+        self._render()
+    
+    def _render(self):
+        """Render the tool calls display."""
+        if not self.tool_calls:
+            return
         
-        for line in lines:
-            # Check if this is a table line
-            if '|' in line and ('---' in line or line.strip().startswith('|')):
-                if not in_table:
-                    in_table = True
-                    table_lines = []
-                table_lines.append(line)
-                continue
-            elif in_table and line.strip():
-                if '|' in line:
-                    table_lines.append(line)
-                    continue
-                else:
-                    self._print_table(table_lines)
-                    in_table = False
-                    table_lines = []
-            elif in_table and not line.strip():
-                self._print_table(table_lines)
-                in_table = False
-                table_lines = []
-            
-            # Format and print the line
-            formatted = self._format_line(line)
-            if formatted is not None:
-                console.print(formatted)
+        lines = []
+        for tc in self.tool_calls:
+            if tc["status"] == "running":
+                spinner = TOOL_CALL_FRAMES[tc["frame"]]
+                lines.append(f"  [cyan]{spinner}[/cyan] [bold]{tc['name']}[/bold] [dim]executing...[/dim]")
+            else:
+                lines.append(f"  [green]✓[/green] [bold]{tc['name']}[/bold] [green]complete[/green]")
         
-        # Print any remaining table
-        if table_lines:
-            self._print_table(table_lines)
+        self.update(Text.from_markup("\n".join(lines)))
+
+
+class SigmaIndicator(Static):
+    """Pulsing sigma indicator with minimal footprint."""
+    
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.active = False
+        self.frame = 0
+        self.timer = None
+    
+    def on_mount(self):
+        self.update(Text.from_markup(f"[bold blue]{SIGMA}[/bold blue]"))
+    
+    def set_active(self, active: bool):
+        self.active = active
+        if active and not self.timer:
+            self.timer = self.set_interval(0.15, self._pulse)
+        elif not active and self.timer:
+            self.timer.stop()
+            self.timer = None
+            self.update(Text.from_markup(f"[bold blue]{SIGMA}[/bold blue]"))
+    
+    def _pulse(self):
+        self.frame = (self.frame + 1) % len(SMALL_SIGMA_FRAMES)
+        self.update(Text.from_markup(SMALL_SIGMA_FRAMES[self.frame]))
+
+
+class TickerHighlight(Static):
+    """Display detected tickers in real-time."""
+    
+    def update_tickers(self, text: str):
+        """Update displayed tickers based on input."""
+        tickers = extract_tickers(text)
+        if tickers:
+            ticker_text = " ".join([f"[cyan]${t}[/cyan]" for t in tickers[:3]])
+            self.update(Text.from_markup(ticker_text))
+        else:
+            self.update("")
+
+
+class ChatLog(RichLog):
+    """Chat log with rich formatting."""
+    
+    def write_user(self, message: str):
+        # Highlight any tickers in user message
+        highlighted = message
+        for ticker in extract_tickers(message):
+            highlighted = re.sub(
+                rf'\b{ticker}\b',
+                f'[cyan]{ticker}[/cyan]',
+                highlighted,
+                flags=re.IGNORECASE
+            )
+        
+        self.write(Panel(
+            Text.from_markup(highlighted) if '[cyan]' in highlighted else Text(message, style="white"),
+            title="[bold blue]You[/bold blue]",
+            border_style="blue",
+            padding=(0, 1),
+        ))
+    
+    def write_assistant(self, message: str):
+        self.write(Panel(
+            Markdown(message),
+            title=f"[bold cyan]{SIGMA} Sigma[/bold cyan]",
+            border_style="cyan",
+            padding=(0, 1),
+        ))
+    
+    def write_tool(self, tool_name: str):
+        # This is now handled by ToolCallDisplay
+        pass
     
-    def _format_line(self, line: str) -> Optional[str]:
-        """Format a single line with proper markdown rendering."""
-        stripped = line.strip()
-        
-        # Empty line
-        if not stripped:
-            return ""
-        
-        # Headers
-        if stripped.startswith('#'):
-            header_match = re.match(r'^(#+)\s*(.+)$', stripped)
-            if header_match:
-                level = len(header_match.group(1))
-                text = header_match.group(2)
-                if level == 1:
-                    return f"\n[bold bright_white]{text}[/bold bright_white]"
-                elif level == 2:
-                    return f"\n[bold bright_cyan]▸ {text}[/bold bright_cyan]"
-                else:
-                    return f"\n[bold]{text}[/bold]"
-        
-        # Bold-only lines
-        if stripped.startswith('**') and stripped.endswith('**') and stripped.count('**') == 2:
-            text = stripped[2:-2]
-            return f"\n[bold bright_yellow]▸ {text}[/bold bright_yellow]"
-        
-        # Lines starting with bold
-        bold_start = re.match(r'^\*\*(.+?)\*\*(.*)$', stripped)
-        if bold_start:
-            bold_part = bold_start.group(1)
-            rest = bold_start.group(2)
-            rest = re.sub(r'\*\*(.+?)\*\*', r'[bold]\1[/bold]', rest)
-            rest = re.sub(r'`([^`]+)`', r'[bright_cyan]\1[/bright_cyan]', rest)
-            return f"[bold bright_green]{bold_part}[/bold bright_green]{rest}"
-        
-        # Bullet points
-        if stripped.startswith('- ') or stripped.startswith('* '):
-            bullet_text = stripped[2:]
-            bullet_text = re.sub(r'\*\*(.+?)\*\*', r'[bold]\1[/bold]', bullet_text)
-            bullet_text = re.sub(r'`([^`]+)`', r'[bright_cyan]\1[/bright_cyan]', bullet_text)
-            return f"  [dim]•[/dim] {bullet_text}"
-        
-        # Numbered lists
-        numbered = re.match(r'^(\d+)\.\s+(.+)$', stripped)
-        if numbered:
-            num = numbered.group(1)
-            text = numbered.group(2)
-            text = re.sub(r'\*\*(.+?)\*\*', r'[bold]\1[/bold]', text)
-            text = re.sub(r'`([^`]+)`', r'[bright_cyan]\1[/bright_cyan]', text)
-            return f"  [bright_cyan]{num}.[/bright_cyan] {text}"
+    def write_error(self, message: str):
+        self.write(Panel(Text(message, style="red"), title="[red]Error[/red]", border_style="red"))
+    
+    def write_system(self, message: str):
+        self.write(Text.from_markup(f"[dim]{message}[/dim]"))
+    
+    def write_welcome(self):
+        self.write(Text.from_markup(WELCOME_BANNER))
+
+
+class SigmaApp(App):
+    """Sigma Finance Research Agent."""
+    
+    TITLE = "Sigma"
+    CSS = CSS
+    
+    BINDINGS = [
+        Binding("ctrl+l", "clear", "Clear"),
+        Binding("ctrl+m", "models", "Models"),
+        Binding("ctrl+h", "help_toggle", "Help"),
+        Binding("ctrl+p", "palette", "palette", show=True),
+        Binding("escape", "cancel", show=False),
+    ]
+    
+    def __init__(self):
+        super().__init__()
+        self.settings = get_settings()
+        self.llm = None
+        self.conversation = []
+        self.is_processing = False
+        self.history: List[str] = []
+        self.history_idx = -1
+        self.show_help = False
+    
+    def compose(self) -> ComposeResult:
+        yield Container(
+            ScrollableContainer(
+                ChatLog(id="chat-log", highlight=True, markup=True),
+                id="chat-area",
+            ),
+            ToolCallDisplay(id="tool-calls-display"),
+            Static(id="help-panel"),
+            Container(
+                Horizontal(
+                    SigmaIndicator(id="sigma-indicator"),
+                    Input(
+                        placeholder="Ask about any stock, market, or strategy... (Tab to autocomplete)",
+                        id="prompt-input",
+                        suggester=SigmaSuggester(),
+                    ),
+                    TickerHighlight(id="ticker-highlight"),
+                    id="input-row",
+                ),
+                id="input-area",
+            ),
+            id="main-container",
+        )
+        yield Footer()
+    
+    def on_mount(self):
+        chat = self.query_one("#chat-log", ChatLog)
+        chat.write_welcome()
         
-        # Regular line - handle inline formatting
-        formatted = stripped
-        formatted = re.sub(r'\*\*(.+?)\*\*', r'[bold]\1[/bold]', formatted)
-        formatted = re.sub(r'`([^`]+)`', r'[bright_cyan]\1[/bright_cyan]', formatted)
+        provider = getattr(self.settings.default_provider, 'value', str(self.settings.default_provider))
+        chat.write_system(f"{SIGMA} Provider: {provider} | Model: {self.settings.default_model}")
+        chat.write_system(f"{SIGMA} Type /help for commands • Ctrl+H for quick help • Tab to autocomplete")
+        chat.write_system("")
         
-        return formatted
+        self._init_llm()
+        self.query_one("#prompt-input", Input).focus()
     
-    def _print_table(self, lines: list[str]):
-        """Print a markdown table as a Rich table."""
-        if len(lines) < 2:
+    def _init_llm(self):
+        try:
+            self.llm = get_llm(self.settings.default_provider, self.settings.default_model)
+        except Exception as e:
+            chat = self.query_one("#chat-log", ChatLog)
+            chat.write_error(f"LLM init failed: {e}")
+            chat.write_system("Use /keys to configure API keys")
+    
+    @on(Input.Changed)
+    def on_input_change(self, event: Input.Changed):
+        """Update ticker highlight as user types."""
+        ticker_display = self.query_one("#ticker-highlight", TickerHighlight)
+        ticker_display.update_tickers(event.value)
+    
+    @on(Input.Submitted)
+    def handle_input(self, event: Input.Submitted):
+        if self.is_processing:
             return
         
-        header_line = lines[0]
-        headers = [h.strip() for h in header_line.split('|') if h.strip()]
+        text = event.value.strip()
+        if not text:
+            return
         
-        table = Table(box=ROUNDED, show_header=True, header_style="bold bright_cyan")
-        for h in headers:
-            table.add_column(h)
+        self.query_one("#prompt-input", Input).value = ""
+        self.history.append(text)
+        self.history_idx = len(self.history)
         
-        for line in lines[2:]:
-            if '---' in line:
-                continue
-            cells = [c.strip() for c in line.split('|') if c.strip()]
-            if cells:
-                # Color code values
-                colored_cells = []
-                for cell in cells:
-                    if cell.startswith('+') or cell.lower() in ['buy', 'bullish', 'strong buy']:
-                        colored_cells.append(f"[green]{cell}[/green]")
-                    elif cell.startswith('-') or cell.lower() in ['sell', 'bearish']:
-                        colored_cells.append(f"[red]{cell}[/red]")
-                    else:
-                        colored_cells.append(cell)
-                table.add_row(*colored_cells)
+        chat = self.query_one("#chat-log", ChatLog)
         
-        console.print()
-        console.print(Padding(table, (0, 2)))
-    
-    async def quick_chart(self, symbol: str, period: str = "3mo"):
-        """Generate a quick chart."""
-        from sigma.tools.charts import create_price_chart
-        chart = create_price_chart(symbol, period)
-        console.print()
-        console.print(chart)
-        console.print()
-    
-    async def quick_compare(self, symbols: list[str], period: str = "3mo"):
-        """Generate a quick comparison chart."""
-        from sigma.tools.charts import create_comparison_chart
-        chart = create_comparison_chart(symbols, period)
-        console.print()
-        console.print(chart)
-        console.print()
-    
-    def _handle_lean_command(self, args: list[str]):
-        """Handle /lean commands for LEAN Engine backtesting."""
-        from sigma.tools.backtest import setup_lean_engine, run_lean_backtest, check_lean_status, get_available_strategies
+        if text.startswith("/"):
+            self._handle_command(text, chat)
+        else:
+            chat.write_user(text)
+            self._process_query(text, chat)
+    
+    def _handle_command(self, cmd: str, chat: ChatLog):
+        parts = cmd.lower().split()
+        command = parts[0]
+        args = parts[1:] if len(parts) > 1 else []
         
-        if not args:
-            # Show help menu
-            strategies = get_available_strategies()
-            console.print()
-            console.print(Panel(
-                "\n".join([
-                    "[bold cyan]LEAN Engine Backtesting[/bold cyan]",
-                    "",
-                    "[bold]Commands:[/bold]",
-                    "  /lean setup              - Setup LEAN Engine (one-time)",
-                    "  /lean run <SYM> <STRAT>  - Run comprehensive backtest",
-                    "  /lean status             - Check LEAN setup status",
-                    "  /lean strategies         - List available strategies",
-                    "",
-                    "[bold]Quick Start:[/bold]",
-                    "  /lean run AAPL sma_crossover",
-                    "  /lean run TSLA macd_momentum",
-                    "  /lean run NVDA rsi_mean_reversion",
-                    "",
-                    "[bold]Available Strategies:[/bold]",
-                    *[f"  [cyan]{name}[/cyan] - {s['description'][:50]}..." for name, s in list(strategies.items())[:3]],
-                    "  [dim]...use /lean strategies for full list[/dim]"
-                ]),
-                title="[bold bright_cyan]LEAN Backtest Engine[/bold bright_cyan]",
-                border_style="bright_blue"
-            ))
-            console.print()
+        if command == "/help":
+            self._show_comprehensive_help(chat)
+        elif command == "/clear":
+            chat.clear()
+            self.conversation = []
+            chat.write_system("Chat cleared")
+        elif command == "/keys":
+            self._show_keys(chat)
+        elif command == "/models":
+            self._show_models(chat)
+        elif command == "/status":
+            self._show_status(chat)
+        elif command == "/backtest":
+            self._show_strategies(chat)
+        elif command == "/provider" and args:
+            self._switch_provider(args[0], chat)
+        elif command == "/model" and args:
+            self._switch_model(args[0], chat)
+        elif command.startswith("/setkey") and len(parts) >= 3:
+            self._set_key(parts[1], parts[2], chat)
+        elif command == "/tickers":
+            self._show_popular_tickers(chat)
+        else:
+            chat.write_error(f"Unknown command: {command}. Type /help for available commands.")
+    
+    def _show_comprehensive_help(self, chat: ChatLog):
+        """Show comprehensive help with examples."""
+        help_text = f"""
+[bold cyan]═══════════════════════════════════════════════════════════════[/bold cyan]
+[bold]                    {SIGMA} SIGMA HELP CENTER                      [/bold]
+[bold cyan]═══════════════════════════════════════════════════════════════[/bold cyan]
+
+[bold yellow]QUICK START[/bold yellow]
+  Just type naturally! Examples:
+  • "analyze AAPL"           - Full analysis of Apple
+  • "compare NVDA AMD INTC"  - Compare multiple stocks
+  • "is TSLA overvalued?"    - Get AI insights
+  • "market overview"        - See major indices
+
+[bold yellow]COMMANDS[/bold yellow]
+  [cyan]/help[/cyan]              This help screen
+  [cyan]/clear[/cyan]             Clear chat history
+  [cyan]/keys[/cyan]              Configure API keys
+  [cyan]/models[/cyan]            Show available models
+  [cyan]/status[/cyan]            Current configuration
+  [cyan]/backtest[/cyan]          Show backtest strategies
+  [cyan]/provider <name>[/cyan]   Switch AI provider
+  [cyan]/model <name>[/cyan]      Switch model
+  [cyan]/setkey <p> <k>[/cyan]    Set API key
+  [cyan]/tickers[/cyan]           Popular tickers list
+
+[bold yellow]ANALYSIS EXAMPLES[/bold yellow]
+  • "technical analysis of SPY"
+  • "fundamentals of MSFT"
+  • "insider trading for AAPL"
+  • "analyst recommendations for NVDA"
+  • "sector performance"
+
+[bold yellow]BACKTESTING[/bold yellow]
+  • "backtest SMA crossover on AAPL"
+  • "backtest RSI strategy on SPY"
+  • "backtest MACD on NVDA"
+  Strategies: sma_crossover, rsi, macd, bollinger, momentum, breakout
+
+[bold yellow]KEYBOARD SHORTCUTS[/bold yellow]
+  [bold]Tab[/bold]      Autocomplete suggestion
+  [bold]Ctrl+L[/bold]   Clear chat
+  [bold]Ctrl+M[/bold]   Show models
+  [bold]Ctrl+H[/bold]   Toggle quick help
+  [bold]Ctrl+P[/bold]   Command palette
+  [bold]Esc[/bold]      Cancel operation
+
+[bold yellow]TIPS[/bold yellow]
+  • Type [cyan]$AAPL[/cyan] or [cyan]AAPL[/cyan] - tickers auto-detected
+  • Use Tab for smart autocomplete
+  • Detected tickers shown next to input
+"""
+        chat.write(Panel(
+            Text.from_markup(help_text),
+            title=f"[bold cyan]{SIGMA} Help[/bold cyan]",
+            border_style="cyan",
+            padding=(0, 1),
+        ))
+    
+    def _show_popular_tickers(self, chat: ChatLog):
+        """Show popular tickers organized by category."""
+        tickers_text = """
+[bold]Tech Giants[/bold]: AAPL, MSFT, GOOGL, AMZN, META, NVDA
+[bold]Semiconductors[/bold]: NVDA, AMD, INTC, AVGO, QCOM, TSM
+[bold]EVs & Auto[/bold]: TSLA, RIVN, LCID, F, GM
+[bold]Finance[/bold]: JPM, BAC, GS, MS, V, MA
+[bold]Healthcare[/bold]: JNJ, PFE, UNH, MRK, ABBV
+[bold]ETFs[/bold]: SPY, QQQ, IWM, DIA, VTI, VOO
+[bold]Sector ETFs[/bold]: XLK, XLF, XLE, XLV, XLI
+"""
+        chat.write(Panel(
+            Text.from_markup(tickers_text),
+            title=f"[cyan]{SIGMA} Popular Tickers[/cyan]",
+            border_style="dim",
+        ))
+    
+    def _show_keys(self, chat: ChatLog):
+        chat.write_system(f"""
+[bold]{SIGMA} API Keys[/bold]
+Set key: /setkey <provider> <key>
+
+Providers: google, openai, anthropic, groq, xai
+Example: /setkey google AIzaSy...
+""")
+        self._show_status(chat)
+    
+    def _show_status(self, chat: ChatLog):
+        table = Table(show_header=False, box=None, padding=(0, 2))
+        table.add_column("", style="bold")
+        table.add_column("")
+        
+        provider = getattr(self.settings.default_provider, 'value', str(self.settings.default_provider))
+        table.add_row("Provider", provider)
+        table.add_row("Model", self.settings.default_model)
+        table.add_row("", "")
+        
+        keys = [
+            ("Google", self.settings.google_api_key),
+            ("OpenAI", self.settings.openai_api_key),
+            ("Anthropic", self.settings.anthropic_api_key),
+            ("Groq", self.settings.groq_api_key),
+            ("xAI", self.settings.xai_api_key),
+        ]
+        for name, key in keys:
+            status = "[green]OK[/green]" if key else "[dim]--[/dim]"
+            table.add_row(f"  {name}", Text.from_markup(status))
+        
+        chat.write(Panel(table, title=f"[cyan]{SIGMA} Config[/cyan]", border_style="dim"))
+    
+    def _show_models(self, chat: ChatLog):
+        table = Table(title=f"{SIGMA} Models", show_header=True, border_style="dim")
+        table.add_column("Provider", style="cyan")
+        table.add_column("Models")
+        for p, m in AVAILABLE_MODELS.items():
+            table.add_row(p, ", ".join(m))
+        chat.write(table)
+    
+    def _show_strategies(self, chat: ChatLog):
+        strategies = get_available_strategies()
+        table = Table(title=f"{SIGMA} Strategies", show_header=True, border_style="dim")
+        table.add_column("Name", style="cyan")
+        table.add_column("Description")
+        for k, v in strategies.items():
+            table.add_row(k, v.get('description', ''))
+        chat.write(table)
+    
+    def _switch_provider(self, provider: str, chat: ChatLog):
+        valid = ["google", "openai", "anthropic", "groq", "xai", "ollama"]
+        if provider not in valid:
+            chat.write_error(f"Invalid. Use: {', '.join(valid)}")
             return
-        
-        subcmd = args[0].lower()
-        
-        if subcmd == "help":
-            self._handle_lean_command([])
+        try:
+            self.settings.default_provider = LLMProvider(provider)
+            if provider in AVAILABLE_MODELS:
+                self.settings.default_model = AVAILABLE_MODELS[provider][0]
+            self._init_llm()
+            chat.write_system(f"Switched to {provider}")
+        except Exception as e:
+            chat.write_error(str(e))
+    
+    def _switch_model(self, model: str, chat: ChatLog):
+        self.settings.default_model = model
+        self._init_llm()
+        chat.write_system(f"Model: {model}")
+    
+    def _set_key(self, provider: str, key: str, chat: ChatLog):
+        try:
+            save_api_key(LLMProvider(provider), key)
+            chat.write_system(f"{SIGMA} Key saved for {provider}")
+            if provider == getattr(self.settings.default_provider, 'value', ''):
+                self._init_llm()
+        except Exception as e:
+            chat.write_error(str(e))
+    
+    @work(exclusive=True)
+    async def _process_query(self, query: str, chat: ChatLog):
+        if not self.llm:
+            chat.write_error("No LLM. Use /keys to configure.")
             return
         
-        if subcmd == "strategies":
-            strategies = get_available_strategies()
-            console.print()
-            from rich.table import Table
-            table = Table(title="Available Backtest Strategies", border_style="bright_blue")
-            table.add_column("Strategy", style="cyan")
-            table.add_column("Description", style="dim")
-            table.add_column("Parameters", style="yellow")
-            
-            for name, s in strategies.items():
-                params = ", ".join([f"{k}={v}" for k, v in s.get("default_params", {}).items()])
-                table.add_row(name, s["description"][:60], params[:40])
-            
-            console.print(table)
-            console.print()
-            return
+        self.is_processing = True
+        indicator = self.query_one("#sigma-indicator", SigmaIndicator)
+        tool_display = self.query_one("#tool-calls-display", ToolCallDisplay)
+        ticker_highlight = self.query_one("#ticker-highlight", TickerHighlight)
         
-        if subcmd == "status":
-            status = check_lean_status()
-            console.print()
-            console.print(Panel(
-                "\n".join([
-                    f"[dim]Docker Installed:[/dim] {'[green]Yes[/green]' if status['docker_installed'] else '[red]No[/red]'}",
-                    f"[dim]Docker Running:[/dim] {'[green]Yes[/green]' if status['docker_running'] else '[red]No[/red]'}",
-                    f"[dim]LEAN Image:[/dim] {'[green]Pulled[/green]' if status['lean_image_pulled'] else '[yellow]Not pulled[/yellow]'}",
-                    f"[dim]Workspace:[/dim] {'[green]Ready[/green]' if status['workspace_initialized'] else '[yellow]Not initialized[/yellow]'}",
-                    "",
-                    *status['instructions']
-                ]),
-                title="[bold bright_cyan]LEAN Engine Status[/bold bright_cyan]",
-                border_style="bright_blue"
-            ))
-            console.print()
-            return
-        
-        if subcmd == "setup":
-            console.print()
-            console.print("[bright_cyan]Setting up LEAN Engine...[/bright_cyan]")
-            console.print()
-            
-            result = setup_lean_engine()
-            
-            for step in result["steps_completed"]:
-                console.print(f"  [green]✓[/green] {step}")
-            
-            for error in result.get("errors", []):
-                console.print(f"  [red]✗[/red] {error}")
-            
-            console.print()
-            if result["success"]:
-                console.print(Panel(
-                    "\n".join(result["next_steps"]),
-                    title="[bold bright_green]Setup Complete[/bold bright_green]",
-                    border_style="green"
-                ))
-            else:
-                console.print(Panel(
-                    "\n".join(result.get("next_steps", ["Setup failed. Check errors above."])),
-                    title="[bold red]Setup Incomplete[/bold red]",
-                    border_style="red"
-                ))
-            console.print()
+        # Clear ticker highlight and start sigma animation
+        ticker_highlight.update("")
+        indicator.set_active(True)
         
-        elif subcmd == "run":
-            if len(args) < 3:
-                console.print("\n  [red]Usage:[/red] /lean run <symbol> <strategy>\n")
-                console.print("  [dim]Strategies:[/dim] sma_crossover, rsi_mean_reversion, macd_momentum, bollinger_bands, dual_momentum, breakout\n")
-                return
-            
-            symbol = args[1].upper()
-            strategy = args[2].lower()
-            
-            console.print()
-            console.print(f"[bright_cyan]Running Comprehensive Backtest: {symbol} - {strategy}[/bright_cyan]")
-            console.print()
+        try:
+            messages = [{"role": "system", "content": SYSTEM_PROMPT}]
+            messages.extend(self.conversation)
+            messages.append({"role": "user", "content": query})
             
-            result = run_lean_backtest(symbol, strategy)
+            all_tools = TOOLS + [BACKTEST_TOOL]
             
-            for step in result["steps"]:
-                console.print(f"  [dim]>[/dim] {step}")
+            async def on_tool(name: str, args: dict):
+                tool_display.add_tool_call(name)
+                if name == "run_backtest":
+                    result = run_backtest(**args)
+                else:
+                    result = execute_tool(name, args)
+                tool_display.complete_tool_call(name)
+                return result
             
-            console.print()
+            response = await self.llm.generate(messages, tools=all_tools, on_tool_call=on_tool)
             
-            if result["status"] == "success":
-                metrics = result.get("metrics", {})
-                
-                # Performance metrics panel
-                perf = metrics.get("performance", {})
-                console.print(Panel(
-                    "\n".join([
-                        f"  [bold cyan]Initial Capital:[/bold cyan]    {perf.get('initial_capital', 'N/A')}",
-                        f"  [bold cyan]Final Equity:[/bold cyan]       {perf.get('final_equity', 'N/A')}",
-                        f"  [bold cyan]Total Return:[/bold cyan]       {perf.get('total_return', 'N/A')}",
-                        f"  [bold cyan]Annual Return:[/bold cyan]      {perf.get('annual_return', 'N/A')}",
-                        f"  [bold cyan]Buy & Hold:[/bold cyan]         {perf.get('buy_hold_return', 'N/A')}",
-                        f"  [bold cyan]Alpha:[/bold cyan]              {perf.get('alpha', 'N/A')}",
-                    ]),
-                    title=f"[bold bright_green]Performance - {symbol} {strategy}[/bold bright_green]",
-                    border_style="green"
-                ))
-                
-                # Risk metrics panel
-                risk = metrics.get("risk", {})
-                console.print(Panel(
-                    "\n".join([
-                        f"  [bold yellow]Max Drawdown:[/bold yellow]      {risk.get('max_drawdown', 'N/A')}",
-                        f"  [bold yellow]Volatility:[/bold yellow]        {risk.get('volatility', 'N/A')}",
-                        f"  [bold yellow]Sharpe Ratio:[/bold yellow]      {risk.get('sharpe_ratio', 'N/A')}",
-                        f"  [bold yellow]Sortino Ratio:[/bold yellow]     {risk.get('sortino_ratio', 'N/A')}",
-                        f"  [bold yellow]Calmar Ratio:[/bold yellow]      {risk.get('calmar_ratio', 'N/A')}",
-                    ]),
-                    title="[bold bright_yellow]Risk Metrics[/bold bright_yellow]",
-                    border_style="yellow"
-                ))
-                
-                # Trade statistics panel
-                trades = metrics.get("trades", {})
-                console.print(Panel(
-                    "\n".join([
-                        f"  [bold magenta]Total Trades:[/bold magenta]       {trades.get('total_trades', 'N/A')}",
-                        f"  [bold magenta]Win Rate:[/bold magenta]           {trades.get('win_rate', 'N/A')}",
-                        f"  [bold magenta]Profit Factor:[/bold magenta]      {trades.get('profit_factor', 'N/A')}",
-                        f"  [bold magenta]Avg Win:[/bold magenta]            {trades.get('avg_win', 'N/A')}",
-                        f"  [bold magenta]Avg Loss:[/bold magenta]           {trades.get('avg_loss', 'N/A')}",
-                        f"  [bold magenta]Avg Holding:[/bold magenta]        {trades.get('avg_holding_days', 'N/A')} days",
-                    ]),
-                    title="[bold bright_magenta]Trade Statistics[/bold bright_magenta]",
-                    border_style="magenta"
-                ))
-                
-                # Display charts
-                charts = result.get("charts", {})
-                
-                if charts.get("equity_curve"):
-                    console.print()
-                    console.print(charts["equity_curve"])
-                
-                if charts.get("drawdown"):
-                    console.print()
-                    console.print(charts["drawdown"])
-                
-                if charts.get("trade_pnl"):
-                    console.print()
-                    console.print(charts["trade_pnl"])
-                
-                if charts.get("monthly_returns"):
-                    console.print()
-                    console.print(charts["monthly_returns"])
-                
-                # Recent trades table
-                trade_list = result.get("trades", [])
-                if trade_list:
-                    console.print()
-                    from rich.table import Table
-                    table = Table(title="Recent Trades", border_style="dim")
-                    table.add_column("Date", style="dim")
-                    table.add_column("Action", style="bold")
-                    table.add_column("Price", justify="right")
-                    table.add_column("Shares", justify="right")
-                    table.add_column("P&L", justify="right")
-                    
-                    for trade in trade_list[-10:]:
-                        action_style = "green" if trade.get("action") == "BUY" else "red"
-                        pnl = trade.get("pnl")
-                        pnl_str = f"${pnl:+,.2f}" if pnl else "-"
-                        pnl_style = "green" if pnl and pnl > 0 else "red" if pnl else "dim"
-                        table.add_row(
-                            trade.get("date", ""),
-                            f"[{action_style}]{trade.get('action', '')}[/{action_style}]",
-                            f"${trade.get('price', 0):,.2f}",
-                            str(trade.get("shares", "")),
-                            f"[{pnl_style}]{pnl_str}[/{pnl_style}]"
-                        )
-                    console.print(table)
-                
-                # Monthly returns
-                monthly = result.get("monthly_returns", [])
-                if monthly:
-                    console.print()
-                    from rich.table import Table
-                    mtable = Table(title="Monthly Returns", border_style="dim")
-                    mtable.add_column("Month", style="dim")
-                    mtable.add_column("Return", justify="right")
-                    
-                    for m in monthly[-12:]:
-                        ret = m.get("return", 0)
-                        ret_style = "green" if ret > 0 else "red"
-                        mtable.add_row(m.get("month", ""), f"[{ret_style}]{ret:+.2f}%[/{ret_style}]")
-                    console.print(mtable)
-                
-                # QuantConnect instructions
-                console.print()
-                console.print(Panel(
-                    "\n".join(result.get("quantconnect_instructions", [])),
-                    title="[bold bright_blue]QuantConnect Cloud (Institutional Data)[/bold bright_blue]",
-                    border_style="blue"
-                ))
-                
-            else:
-                console.print(Panel(
-                    f"[red]Error:[/red] {result.get('error', 'Unknown error')[:200]}",
-                    title="[bold red]Backtest Failed[/bold red]",
-                    border_style="red"
-                ))
+            # Clear tool display after getting response
+            await asyncio.sleep(0.5)  # Brief pause to show completion
+            tool_display.clear()
             
-            # Always show the algorithm file location
-            if result.get("algorithm_file"):
-                console.print()
-                console.print(f"  [dim]LEAN Algorithm saved:[/dim] {result['algorithm_file']}")
-            console.print()
-        
-        elif subcmd == "status":
-            self._handle_lean_command([])  # Same as no args
-        
-        else:
-            console.print(f"\n  [red]Unknown lean command:[/red] {subcmd}")
-            console.print("  [dim]Available:[/dim] /lean setup, /lean run <symbol> <strategy>, /lean status\n")
-
-    def handle_command(self, cmd: str) -> bool:
-        """Handle slash command. Returns True to continue, False to quit."""
-        parts = cmd.strip().split()
-        command = parts[0].lower()
-        args = parts[1:] if len(parts) > 1 else []
-        
-        if command in ["/quit", "/exit", "/q"]:
-            return False
-        
-        elif command in ["/help", "/h", "/?"]:
-            print_help()
-        
-        elif command == "/model":
-            if not args:
-                available = self.settings.get_available_providers()
-                console.print()
-                console.print(f"  [dim]Current model:[/dim] [bright_cyan]{self._get_model_display()}[/bright_cyan]")
-                console.print(f"  [dim]Available:[/dim] {', '.join(p.value for p in available)}")
-                console.print()
-            else:
-                try:
-                    self.provider = LLMProvider(args[0].lower())
-                    self.agent = None
-                    console.print(f"\n  [bright_green]✓[/bright_green] Switched to [bright_cyan]{self._get_model_display()}[/bright_cyan]\n")
-                except ValueError:
-                    console.print(f"\n  [red]✗[/red] Unknown provider: {args[0]}\n")
-        
-        elif command == "/mode":
-            if not args:
-                console.print()
-                console.print(f"  [dim]Current mode:[/dim] [bright_cyan]{self.mode}[/bright_cyan]")
-                console.print(f"  [dim]Available:[/dim] default, technical, fundamental, quant")
-                console.print()
-            else:
-                mode = args[0].lower()
-                if mode in ["default", "technical", "fundamental", "quant"]:
-                    self.mode = mode
-                    console.print(f"\n  [bright_green]✓[/bright_green] Switched to [bright_cyan]{mode}[/bright_cyan] mode\n")
-                else:
-                    console.print(f"\n  [red]✗[/red] Unknown mode: {mode}\n")
-        
-        elif command == "/clear":
-            if self.agent:
-                self.agent.clear()
-            console.print("\n  [bright_green]✓[/bright_green] Conversation cleared\n")
-        
-        elif command == "/status":
-            console.print()
-            console.print(f"  [dim]Provider:[/dim] [bright_cyan]{self.provider.value}[/bright_cyan]")
-            console.print(f"  [dim]Model:[/dim] [bright_cyan]{self._get_model_display()}[/bright_cyan]")
-            console.print(f"  [dim]Mode:[/dim] [bright_cyan]{self.mode}[/bright_cyan]")
-            available = self.settings.get_available_providers()
-            console.print(f"  [dim]Available providers:[/dim] {', '.join(p.value for p in available)}")
-            if self.agent:
-                stats = self.agent.get_stats()
-                console.print(f"  [dim]Tools called this session:[/dim] {stats['tools_called']}")
-            console.print()
-        
-        elif command == "/chart":
-            if not args:
-                console.print("\n  [red]Usage:[/red] /chart <symbol> [period]\n")
+            if response:
+                chat.write_assistant(response)
+                self.conversation.append({"role": "user", "content": query})
+                self.conversation.append({"role": "assistant", "content": response})
+                if len(self.conversation) > 20:
+                    self.conversation = self.conversation[-20:]
             else:
-                symbol = args[0].upper()
-                period = args[1] if len(args) > 1 else "3mo"
-                try:
-                    asyncio.get_event_loop().run_until_complete(self.quick_chart(symbol, period))
-                except RuntimeError:
-                    asyncio.run(self.quick_chart(symbol, period))
-        
-        elif command == "/compare":
-            if len(args) < 2:
-                console.print("\n  [red]Usage:[/red] /compare <symbol1> <symbol2> ...\n")
-            else:
-                symbols = [s.upper() for s in args[:5]]
-                try:
-                    asyncio.get_event_loop().run_until_complete(self.quick_compare(symbols))
-                except RuntimeError:
-                    asyncio.run(self.quick_compare(symbols))
-        
-        elif command == "/backtest":
-            if len(args) < 2:
-                console.print("\n  [red]Usage:[/red] /backtest <symbol> <strategy>\n")
-                console.print("  [dim]Strategies:[/dim] sma_crossover, rsi_mean_reversion, macd_momentum, bollinger_bands, dual_momentum, breakout\n")
-            else:
-                symbol = args[0]
-                strategy = args[1]
-                try:
-                    loop = asyncio.get_event_loop()
-                    loop.run_until_complete(
-                        self.process_query(f"Generate a {strategy} backtest for {symbol}")
-                    )
-                except RuntimeError:
-                    asyncio.run(
-                        self.process_query(f"Generate a {strategy} backtest for {symbol}")
-                    )
-        
-        elif command == "/lean":
-            self._handle_lean_command(args)
-        
+                chat.write_error("No response")
+        except Exception as e:
+            tool_display.clear()
+            chat.write_error(str(e))
+        finally:
+            indicator.set_active(False)
+            self.is_processing = False
+            self.query_one("#prompt-input", Input).focus()
+    
+    def action_clear(self):
+        chat = self.query_one("#chat-log", ChatLog)
+        chat.clear()
+        self.conversation = []
+        chat.write_system("Cleared")
+    
+    def action_models(self):
+        self._show_models(self.query_one("#chat-log", ChatLog))
+    
+    def action_help_toggle(self):
+        """Toggle quick help panel."""
+        help_panel = self.query_one("#help-panel", Static)
+        if self.show_help:
+            help_panel.remove_class("visible")
+            help_panel.update("")
         else:
-            console.print(f"\n  [red]Unknown command:[/red] {command}. Type /help for commands.\n")
-        
-        return True
+            help_panel.add_class("visible")
+            help_panel.update(Text.from_markup(
+                "[bold]Quick Commands:[/bold] /help /clear /keys /models /status /backtest  "
+                "[bold]Shortcuts:[/bold] Tab=autocomplete Ctrl+L=clear Ctrl+M=models"
+            ))
+        self.show_help = not self.show_help
     
-    async def run(self):
-        """Run the interactive loop."""
-        print_banner(self._get_model_display())
-        
-        while True:
-            try:
-                # Professional prompt
-                prompt_line = f"[bold bright_yellow]σ[/bold bright_yellow] [dim]›[/dim] "
-                query = console.input(prompt_line).strip()
-                
-                if not query:
-                    continue
-                
-                # Handle commands
-                if query.startswith("/"):
-                    if not self.handle_command(query):
-                        console.print("\n  [dim]Goodbye! May your trades be ever profitable.[/dim] 📈\n")
-                        break
-                    continue
-                
-                # Process query
-                await self.process_query(query)
-                
-            except KeyboardInterrupt:
-                console.print("\n")
-                continue
-            except EOFError:
-                console.print("\n  [dim]Goodbye! May your trades be ever profitable.[/dim] 📈\n")
-                break
-            except Exception as e:
-                console.print(f"\n  [red]Error:[/red] {str(e)}\n")
-
-
-def main():
-    """Main entry point."""
-    import argparse
-    
-    parser = argparse.ArgumentParser(
-        prog="sigma",
-        description="Sigma - Institutional-Grade Financial Research Agent",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Examples:
-  sigma                    Start interactive mode
-  sigma --setup            Run setup wizard
-  sigma "Analyze AAPL"     Direct query mode
-  sigma --version          Show version
-
-Inside Sigma:
-  /help                    Show all commands
-  /model openai            Switch to OpenAI
-  /lean run TSLA macd      Run backtest
-        """
-    )
-    
-    parser.add_argument(
-        "query",
-        nargs="?",
-        help="Direct query to analyze (optional)"
-    )
-    parser.add_argument(
-        "--setup",
-        action="store_true",
-        help="Run the setup wizard"
-    )
-    parser.add_argument(
-        "--reset",
-        action="store_true",
-        help="Reset configuration and run setup"
-    )
-    parser.add_argument(
-        "--version", "-v",
-        action="version",
-        version=f"Sigma {VERSION}"
-    )
-    parser.add_argument(
-        "--model", "-m",
-        choices=["openai", "anthropic", "google", "groq", "xai", "ollama"],
-        help="Override default AI model"
-    )
-    
-    args = parser.parse_args()
-    
-    # Handle setup
-    from sigma.setup import ensure_setup, run_setup, is_setup_complete, CONFIG_DIR
-    import shutil
-    
-    if args.reset:
-        if CONFIG_DIR.exists():
-            shutil.rmtree(CONFIG_DIR)
-        run_setup(force=True)
-    elif args.setup:
-        run_setup(force=True)
-    else:
-        # Ensure setup is done
-        ensure_setup()
-    
-    # Create UI with optional model override
-    ui = SigmaUI()
-    if args.model:
-        try:
-            ui.provider = LLMProvider(args.model)
-            ui.agent = None  # Force agent reload
-        except ValueError:
-            pass
-    
-    # Handle direct query or interactive mode
-    if args.query:
-        # Direct query mode
-        async def run_query():
-            print_banner(ui._get_model_display())
-            await ui.process_query(args.query)
-        
-        try:
-            asyncio.run(run_query())
-        except KeyboardInterrupt:
-            console.print("\n")
-    else:
-        # Interactive mode
-        try:
-            asyncio.run(ui.run())
-        except KeyboardInterrupt:
-            console.print("\n  [dim]Goodbye! May your trades be ever profitable.[/dim]\n")
+    def action_cancel(self):
+        if self.is_processing:
+            self.is_processing = False
+            tool_display = self.query_one("#tool-calls-display", ToolCallDisplay)
+            tool_display.clear()
+
+
+def launch():
+    """Launch Sigma."""
+    SigmaApp().run()
 
 
 if __name__ == "__main__":
-    main()
+    launch()