sigma-terminal 3.3.1__py3-none-any.whl → 3.4.0__py3-none-any.whl

sigma/charts.py

@@ -355,44 +355,62 @@ def _calculate_macd(prices: pd.Series, fast: int = 12, slow: int = 26, signal: i
 
 
 def _apply_layout(fig: go.Figure, title: str, has_volume: bool):
-    """Apply Sigma theme to chart."""
+    """Apply Sigma theme to chart with publication-grade styling."""
     fig.update_layout(
         title=dict(
-            text=title,
-            font=dict(size=18, color=SIGMA_THEME["text_color"]),
+            text=f"<b>{title}</b>",
+            font=dict(size=20, color=SIGMA_THEME["text_color"], family="SF Pro Display, -apple-system, sans-serif"),
             x=0.5,
+            xanchor="center",
         ),
         paper_bgcolor=SIGMA_THEME["paper_color"],
         plot_bgcolor=SIGMA_THEME["bg_color"],
-        font=dict(color=SIGMA_THEME["text_color"], family="SF Mono, Menlo, monospace"),
+        font=dict(color=SIGMA_THEME["text_color"], family="SF Pro Display, -apple-system, sans-serif", size=12),
         xaxis=dict(
             gridcolor=SIGMA_THEME["grid_color"],
             showgrid=True,
+            gridwidth=1,
             zeroline=False,
+            showline=True,
+            linewidth=1,
+            linecolor=SIGMA_THEME["grid_color"],
+            tickfont=dict(size=11),
         ),
         yaxis=dict(
             gridcolor=SIGMA_THEME["grid_color"],
             showgrid=True,
+            gridwidth=1,
             zeroline=False,
+            showline=True,
+            linewidth=1,
+            linecolor=SIGMA_THEME["grid_color"],
             title_text="Price ($)",
+            tickfont=dict(size=11),
+            tickformat="$,.2f",
         ),
         legend=dict(
             bgcolor="rgba(0,0,0,0)",
-            font=dict(color=SIGMA_THEME["text_color"]),
+            font=dict(color=SIGMA_THEME["text_color"], size=11),
             orientation="h",
             yanchor="bottom",
             y=1.02,
             xanchor="right",
             x=1,
         ),
-        margin=dict(l=60, r=40, t=80, b=40),
+        margin=dict(l=70, r=50, t=90, b=50),
         xaxis_rangeslider_visible=False,
         hovermode="x unified",
+        hoverlabel=dict(
+            bgcolor=SIGMA_THEME["bg_color"],
+            font_size=12,
+            font_family="SF Mono, Menlo, monospace",
+            bordercolor=SIGMA_THEME["accent"],
+        ),
     )
 
 
 def _save_chart(fig: go.Figure, name: str) -> str:
-    """Save chart to file and return path."""
+    """Save chart to file with maximum quality and return path."""
     
     # Create charts directory
     charts_dir = os.path.expanduser("~/.sigma/charts")
@@ -402,6 +420,13 @@ def _save_chart(fig: go.Figure, name: str) -> str:
     filename = f"{name}_{timestamp}.png"
     filepath = os.path.join(charts_dir, filename)
     
-    fig.write_image(filepath, width=1200, height=800, scale=2)
+    # High quality export settings
+    fig.write_image(
+        filepath, 
+        width=1600,      # Higher resolution 
+        height=1000,     # Better aspect ratio
+        scale=3,         # 3x scaling for retina/high-DPI
+        engine="kaleido"
+    )
     
     return filepath

sigma/cli.py

@@ -1,4 +1,4 @@
-"""CLI entry point for Sigma v3.3.1."""
+"""CLI entry point for Sigma v3.4.0."""
 
 import argparse
 import json
@@ -17,7 +17,7 @@ from .config import (
 )
 
 
-__version__ = "3.3.1"
+__version__ = "3.4.0"
 
 console = Console()
 
@@ -25,14 +25,14 @@ console = Console()
 def show_banner():
     """Show the Sigma banner."""
     banner = """
-[bold white]███████╗██╗ ██████╗ ███╗   ███╗ █████╗ [/bold white]
-[bold white]██╔════╝██║██╔════╝ ████╗ ████║██╔══██╗[/bold white]
-[bold white]███████╗██║██║  ███╗██╔████╔██║███████║[/bold white]
-[bold white]╚════██║██║██║   ██║██║╚██╔╝██║██╔══██║[/bold white]
-[bold white]███████║██║╚██████╔╝██║ ╚═╝ ██║██║  ██║[/bold white]
-[bold white]╚══════╝╚═╝ ╚═════╝ ╚═╝     ╚═╝╚═╝  ╚═╝[/bold white]
+[bold #3b82f6]███████╗██╗ ██████╗ ███╗   ███╗ █████╗ [/bold #3b82f6]
+[bold #60a5fa]██╔════╝██║██╔════╝ ████╗ ████║██╔══██╗[/bold #60a5fa]
+[bold #93c5fd]███████╗██║██║  ███╗██╔████╔██║███████║[/bold #93c5fd]
+[bold #60a5fa]╚════██║██║██║   ██║██║╚██╔╝██║██╔══██║[/bold #60a5fa]
+[bold #3b82f6]███████║██║╚██████╔╝██║ ╚═╝ ██║██║  ██║[/bold #3b82f6]
+[bold #1d4ed8]╚══════╝╚═╝ ╚═════╝ ╚═╝     ╚═╝╚═╝  ╚═╝[/bold #1d4ed8]
 
-[dim]v3.3.1[/dim] [bold cyan]σ[/bold cyan] [bold]Finance Research Agent[/bold]
+[dim]v3.4.0[/dim] [bold cyan]σ[/bold cyan] [bold]Finance Research Agent[/bold]
 """
     console.print(banner)
 
@@ -41,7 +41,7 @@ def main():
     """Main CLI entry point."""
     parser = argparse.ArgumentParser(
         prog="sigma",
-        description="Sigma v3.3.1 - Finance Research Agent",
+        description="Sigma v3.4.0 - Finance Research Agent",
         formatter_class=argparse.RawDescriptionHelpFormatter,
         epilog="""
 Examples:
@@ -148,7 +148,7 @@ Examples:
         mark_first_run_complete()  # Always mark complete to not ask again
         
         if result:
-            console.print("\n[bold green]✓ Setup complete![/bold green]")
+            console.print("\n[bold green][ok] Setup complete![/bold green]")
             console.print("[dim]Launching Sigma...[/dim]\n")
             import time
             time.sleep(1)  # Brief pause for user to see message

sigma/config.py

@@ -1,9 +1,9 @@
-"""Configuration management for Sigma v3.3.1."""
+"""Configuration management for Sigma v3.4.0."""
 
 import os
 import shutil
 import subprocess
-from enum import Enum
+from enum import Enum, IntEnum
 from pathlib import Path
 from typing import Optional, Tuple
 
@@ -11,7 +11,56 @@ from pydantic import Field
 from pydantic_settings import BaseSettings
 
 
-__version__ = "3.3.1"
+__version__ = "3.4.0"
+
+
+class ErrorCode(IntEnum):
+    """Error codes for consistent error handling."""
+    # General errors (1000-1099)
+    UNKNOWN_ERROR = 1000
+    INVALID_INPUT = 1001
+    TIMEOUT = 1002
+    
+    # API Key errors (1100-1199)
+    API_KEY_MISSING = 1100
+    API_KEY_INVALID = 1101
+    API_KEY_EXPIRED = 1102
+    API_KEY_RATE_LIMITED = 1103
+    
+    # Provider errors (1200-1299)
+    PROVIDER_UNAVAILABLE = 1200
+    PROVIDER_ERROR = 1201
+    MODEL_NOT_FOUND = 1202
+    MODEL_DEPRECATED = 1203
+    
+    # Data errors (1300-1399)
+    SYMBOL_NOT_FOUND = 1300
+    DATA_UNAVAILABLE = 1301
+    MARKET_CLOSED = 1302
+    RATE_LIMIT_EXCEEDED = 1303
+    
+    # Network errors (1400-1499)
+    CONNECTION_ERROR = 1400
+    REQUEST_FAILED = 1401
+    RESPONSE_INVALID = 1402
+
+
+class SigmaError(Exception):
+    """Custom exception with error codes."""
+    
+    def __init__(self, code: ErrorCode, message: str, details: Optional[dict] = None):
+        self.code = code
+        self.message = message
+        self.details = details or {}
+        super().__init__(f"[E{code}] {message}")
+    
+    def to_dict(self) -> dict:
+        return {
+            "error_code": int(self.code),
+            "error_name": self.code.name,
+            "message": self.message,
+            "details": self.details
+        }
 
 
 class LLMProvider(str, Enum):
@@ -24,14 +73,38 @@ class LLMProvider(str, Enum):
     OLLAMA = "ollama"
 
 
-# Available models per provider
+# Available models per provider (Feb 2026 - LATEST MODELS ONLY)
 AVAILABLE_MODELS = {
-    "google": ["gemini-2.0-flash", "gemini-1.5-flash", "gemini-1.5-pro"],
-    "openai": ["gpt-4o", "gpt-4o-mini", "gpt-4-turbo", "o1-preview", "o1-mini"],
-    "anthropic": ["claude-sonnet-4-20250514", "claude-3-5-sonnet-20241022", "claude-3-opus-20240229"],
-    "groq": ["llama-3.3-70b-versatile", "llama-3.1-8b-instant", "mixtral-8x7b-32768"],
-    "xai": ["grok-2", "grok-2-mini"],
-    "ollama": ["llama3.2", "llama3.1", "mistral", "codellama", "phi3"],
+    "google": [
+        "gemini-3-flash",        # Latest fast model
+        "gemini-3-pro",          # Latest capable model
+    ],
+    "openai": [
+        "gpt-5",                 # Latest flagship
+        "gpt-5-mini",            # Latest efficient
+        "o3",                    # Latest reasoning
+        "o3-mini",               # Fast reasoning
+    ],
+    "anthropic": [
+        "claude-sonnet-4-20250514",    # Latest Sonnet
+        "claude-opus-4-20250514",      # Latest Opus
+    ],
+    "groq": [
+        "llama-3.3-70b-versatile",   # Most capable free
+        "llama-3.3-8b-instant",      # Fast free
+        "mixtral-8x7b-32768",        # Good balance free
+    ],
+    "xai": [
+        "grok-3",                # Latest full capability
+        "grok-3-mini",           # Latest fast variant
+    ],
+    "ollama": [
+        "llama3.3",              # Latest local LLM
+        "llama3.2",
+        "mistral",
+        "phi4",                  # Latest Phi
+        "qwen2.5",               # Latest Qwen
+    ],
 }
 
 # Config directory
@@ -41,8 +114,40 @@ FIRST_RUN_MARKER = CONFIG_DIR / ".first_run_complete"
 
 
 def is_first_run() -> bool:
-    """Check if this is the first run of the application."""
-    return not FIRST_RUN_MARKER.exists()
+    """
+    Check if this is the first run of the application.
+    
+    Returns False (not first run) if:
+    - The first run marker exists, OR
+    - A config file exists with at least one API key configured
+    
+    This ensures users who upgrade from older versions or manually
+    configure their ~/.sigma/config.env don't see the setup wizard.
+    """
+    # Check for explicit marker
+    if FIRST_RUN_MARKER.exists():
+        return False
+    
+    # Check if config file exists and has API keys
+    if CONFIG_FILE.exists():
+        try:
+            content = CONFIG_FILE.read_text()
+            # Check if any API key is set (not empty)
+            api_keys = ["GOOGLE_API_KEY", "OPENAI_API_KEY", "ANTHROPIC_API_KEY", 
+                       "GROQ_API_KEY", "XAI_API_KEY"]
+            for key in api_keys:
+                # Look for KEY=value where value is not empty
+                for line in content.splitlines():
+                    if line.startswith(f"{key}="):
+                        value = line.split("=", 1)[1].strip()
+                        if value and value not in ('""', "''", ""):
+                            # Found a configured API key - not first run
+                            mark_first_run_complete()  # Create marker for future
+                            return False
+        except Exception:
+            pass
+    
+    return True
 
 
 def mark_first_run_complete() -> None:
@@ -205,22 +310,22 @@ class Settings(BaseSettings):
     
     # Provider settings
     default_provider: LLMProvider = LLMProvider.GOOGLE
-    default_model: str = Field(default="gemini-2.0-flash", alias="DEFAULT_MODEL")
+    default_model: str = Field(default="gemini-3-flash", alias="DEFAULT_MODEL")
     
-    # API Keys
+    # LLM API Keys
     google_api_key: Optional[str] = Field(default=None, alias="GOOGLE_API_KEY")
     openai_api_key: Optional[str] = Field(default=None, alias="OPENAI_API_KEY")
     anthropic_api_key: Optional[str] = Field(default=None, alias="ANTHROPIC_API_KEY")
     groq_api_key: Optional[str] = Field(default=None, alias="GROQ_API_KEY")
     xai_api_key: Optional[str] = Field(default=None, alias="XAI_API_KEY")
     
-    # Model settings
-    google_model: str = "gemini-2.0-flash"
-    openai_model: str = "gpt-4o"
+    # Model settings - LATEST MODELS ONLY (Feb 2026)
+    google_model: str = "gemini-3-flash"
+    openai_model: str = "gpt-5"
     anthropic_model: str = "claude-sonnet-4-20250514"
     groq_model: str = "llama-3.3-70b-versatile"
-    xai_model: str = "grok-2"
-    ollama_model: str = "llama3.2"
+    xai_model: str = "grok-3"
+    ollama_model: str = "llama3.3"
     
     # Ollama settings
     ollama_host: str = "http://localhost:11434"
@@ -232,6 +337,7 @@ class Settings(BaseSettings):
     
     # Data API keys
     alpha_vantage_api_key: str = Field(default="6ER128DD3NQUPTVC", alias="ALPHA_VANTAGE_API_KEY")
+    polygon_api_key: Optional[str] = Field(default=None, alias="POLYGON_API_KEY")
     exa_api_key: Optional[str] = Field(default=None, alias="EXA_API_KEY")
     
     class Config:
@@ -287,38 +393,70 @@ def get_settings() -> Settings:
     return Settings()
 
 
-def save_api_key(provider: str, key: str) -> None:
-    """Save an API key to the config file."""
+def save_api_key(provider: str, key: str) -> bool:
+    """Save an API key to the config file. Returns True on success."""
     CONFIG_DIR.mkdir(parents=True, exist_ok=True)
     
     # Read existing config
     config = {}
     if CONFIG_FILE.exists():
-        with open(CONFIG_FILE) as f:
-            for line in f:
-                line = line.strip()
-                if "=" in line and not line.startswith("#"):
-                    k, v = line.split("=", 1)
-                    config[k] = v
+        try:
+            with open(CONFIG_FILE) as f:
+                for line in f:
+                    line = line.strip()
+                    if "=" in line and not line.startswith("#"):
+                        k, v = line.split("=", 1)
+                        config[k] = v
+        except IOError:
+            pass
     
-    # Update key
+    # Map provider names to config keys (LLM + Data providers)
     key_map = {
+        # LLM providers
         "google": "GOOGLE_API_KEY",
         "openai": "OPENAI_API_KEY",
         "anthropic": "ANTHROPIC_API_KEY",
         "groq": "GROQ_API_KEY",
         "xai": "XAI_API_KEY",
+        # Data providers
+        "polygon": "POLYGON_API_KEY",
+        "alphavantage": "ALPHA_VANTAGE_API_KEY",
+        "exa": "EXA_API_KEY",
     }
     
     env_key = key_map.get(provider.lower())
-    if env_key:
-        config[env_key] = key
+    if not env_key:
+        return False
+    
+    config[env_key] = key
     
     # Write back
-    with open(CONFIG_FILE, "w") as f:
-        f.write("# Sigma Configuration\n\n")
-        for k, v in sorted(config.items()):
-            f.write(f"{k}={v}\n")
+    try:
+        with open(CONFIG_FILE, "w") as f:
+            f.write("# Sigma Configuration\n")
+            f.write(f"# Updated: {__import__('datetime').datetime.now().isoformat()}\n\n")
+            
+            # Group by type for readability
+            llm_keys = ["GOOGLE_API_KEY", "OPENAI_API_KEY", "ANTHROPIC_API_KEY", "GROQ_API_KEY", "XAI_API_KEY"]
+            data_keys = ["POLYGON_API_KEY", "ALPHA_VANTAGE_API_KEY", "EXA_API_KEY"]
+            
+            f.write("# LLM Provider Keys\n")
+            for k in llm_keys:
+                if k in config:
+                    f.write(f"{k}={config[k]}\n")
+            
+            f.write("\n# Data Provider Keys\n")
+            for k in data_keys:
+                if k in config:
+                    f.write(f"{k}={config[k]}\n")
+            
+            f.write("\n# Other Settings\n")
+            for k, v in sorted(config.items()):
+                if k not in llm_keys and k not in data_keys:
+                    f.write(f"{k}={v}\n")
+        return True
+    except IOError:
+        return False
 
 
 def get_api_key(provider: str) -> Optional[str]:

sigma/llm.py

@@ -7,7 +7,7 @@ import time
 from abc import ABC, abstractmethod
 from typing import Any, AsyncIterator, Callable, Optional
 
-from sigma.config import LLMProvider, get_settings
+from sigma.config import LLMProvider, get_settings, ErrorCode, SigmaError
 
 
 # Rate limiting configuration
@@ -601,6 +601,123 @@ class OllamaLLM(BaseLLM):
         return "\n".join(lines)
 
 
+class XaiLLM(BaseLLM):
+    """xAI Grok client (uses OpenAI-compatible API)."""
+    
+    provider_name = "xai"
+    
+    def __init__(self, api_key: str, model: str):
+        from openai import AsyncOpenAI
+        self.client = AsyncOpenAI(
+            api_key=api_key,
+            base_url="https://api.x.ai/v1"
+        )
+        self.model = model
+    
+    async def generate(
+        self,
+        messages: list[dict],
+        tools: Optional[list[dict]] = None,
+        on_tool_call: Optional[Callable] = None,
+    ) -> str:
+        await self._rate_limit()
+        
+        try:
+            kwargs = {
+                "model": self.model,
+                "messages": messages,
+            }
+            
+            if tools:
+                kwargs["tools"] = tools
+                kwargs["tool_choice"] = "auto"
+            
+            response = await self.client.chat.completions.create(**kwargs)
+            message = response.choices[0].message
+            
+            # Handle tool calls
+            if message.tool_calls and on_tool_call:
+                tool_results = []
+                for tc in message.tool_calls:
+                    args = json.loads(tc.function.arguments)
+                    result = await on_tool_call(tc.function.name, args)
+                    tool_results.append({
+                        "tool_call_id": tc.id,
+                        "role": "tool",
+                        "content": json.dumps(result)
+                    })
+                
+                # Continue with tool results
+                messages = messages + [message.model_dump()] + tool_results
+                return await self.generate(messages, tools, on_tool_call)
+            
+            return message.content or ""
+            
+        except Exception as e:
+            error_str = str(e)
+            if "401" in error_str or "invalid_api_key" in error_str:
+                raise SigmaError(
+                    ErrorCode.API_KEY_INVALID,
+                    "xAI API key is invalid",
+                    {"provider": "xai"}
+                )
+            elif "429" in error_str or "rate_limit" in error_str:
+                raise SigmaError(
+                    ErrorCode.API_KEY_RATE_LIMITED,
+                    "xAI rate limit exceeded. Please wait.",
+                    {"provider": "xai"}
+                )
+            raise
+
+
+def _parse_api_error(error: Exception, provider: str) -> SigmaError:
+    """Parse API errors into SigmaError with proper codes."""
+    error_str = str(error).lower()
+    
+    if "401" in error_str or "invalid_api_key" in error_str or "api key not valid" in error_str:
+        return SigmaError(
+            ErrorCode.API_KEY_INVALID,
+            f"{provider.title()} API key is invalid. Check your key at /keys",
+            {"provider": provider, "original_error": str(error)[:200]}
+        )
+    elif "403" in error_str or "forbidden" in error_str:
+        return SigmaError(
+            ErrorCode.API_KEY_INVALID,
+            f"{provider.title()} API key doesn't have access to this model",
+            {"provider": provider}
+        )
+    elif "429" in error_str or "rate_limit" in error_str or "quota" in error_str:
+        return SigmaError(
+            ErrorCode.API_KEY_RATE_LIMITED,
+            f"{provider.title()} rate limit exceeded. Wait a moment.",
+            {"provider": provider}
+        )
+    elif "404" in error_str or "not found" in error_str or "does not exist" in error_str:
+        return SigmaError(
+            ErrorCode.MODEL_NOT_FOUND,
+            f"Model not found. Try /models to see available options.",
+            {"provider": provider}
+        )
+    elif "timeout" in error_str:
+        return SigmaError(
+            ErrorCode.TIMEOUT,
+            "Request timed out. Try a simpler query.",
+            {"provider": provider}
+        )
+    elif "connection" in error_str:
+        return SigmaError(
+            ErrorCode.CONNECTION_ERROR,
+            f"Cannot connect to {provider.title()}. Check internet.",
+            {"provider": provider}
+        )
+    else:
+        return SigmaError(
+            ErrorCode.PROVIDER_ERROR,
+            f"{provider.title()} error: {str(error)[:150]}",
+            {"provider": provider, "original_error": str(error)[:300]}
+        )
+
+
 def get_llm(provider: LLMProvider, model: Optional[str] = None) -> BaseLLM:
     """Get LLM client for a provider."""
     settings = get_settings()
@@ -611,29 +728,59 @@ def get_llm(provider: LLMProvider, model: Optional[str] = None) -> BaseLLM:
     if provider == LLMProvider.GOOGLE:
         api_key = settings.google_api_key
         if not api_key:
-            raise ValueError("Google API key not configured")
+            raise SigmaError(
+                ErrorCode.API_KEY_MISSING,
+                "Google API key not configured. Use /keys to set up.",
+                {"provider": "google", "hint": "Get key at: https://aistudio.google.com/apikey"}
+            )
         return GoogleLLM(api_key, model)
     
     elif provider == LLMProvider.OPENAI:
         api_key = settings.openai_api_key
         if not api_key:
-            raise ValueError("OpenAI API key not configured")
+            raise SigmaError(
+                ErrorCode.API_KEY_MISSING,
+                "OpenAI API key not configured. Use /keys to set up.",
+                {"provider": "openai", "hint": "Get key at: https://platform.openai.com/api-keys"}
+            )
         return OpenAILLM(api_key, model)
     
     elif provider == LLMProvider.ANTHROPIC:
         api_key = settings.anthropic_api_key
         if not api_key:
-            raise ValueError("Anthropic API key not configured")
+            raise SigmaError(
+                ErrorCode.API_KEY_MISSING,
+                "Anthropic API key not configured. Use /keys to set up.",
+                {"provider": "anthropic", "hint": "Get key at: https://console.anthropic.com/settings/keys"}
+            )
         return AnthropicLLM(api_key, model)
     
     elif provider == LLMProvider.GROQ:
         api_key = settings.groq_api_key
         if not api_key:
-            raise ValueError("Groq API key not configured")
+            raise SigmaError(
+                ErrorCode.API_KEY_MISSING,
+                "Groq API key not configured. Use /keys to set up.",
+                {"provider": "groq", "hint": "Get key at: https://console.groq.com/keys"}
+            )
         return GroqLLM(api_key, model)
     
+    elif provider == LLMProvider.XAI:
+        api_key = settings.xai_api_key
+        if not api_key:
+            raise SigmaError(
+                ErrorCode.API_KEY_MISSING,
+                "xAI API key not configured. Use /keys to set up.",
+                {"provider": "xai", "hint": "Get key at: https://console.x.ai"}
+            )
+        return XaiLLM(api_key, model)
+    
     elif provider == LLMProvider.OLLAMA:
         return OllamaLLM(settings.ollama_host, model)
     
     else:
-        raise ValueError(f"Unsupported provider: {provider}")
+        raise SigmaError(
+            ErrorCode.PROVIDER_UNAVAILABLE,
+            f"Unsupported provider: {provider}",
+            {"provider": str(provider)}
+        )