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

sigma/cli.py

@@ -1,4 +1,4 @@
-"""CLI entry point for Sigma v3.2.0."""
+"""CLI entry point for Sigma v3.3.0."""
 
 import argparse
 import json
@@ -10,10 +10,13 @@ from rich.table import Table
 from rich.panel import Panel
 
 from .app import launch
-from .config import get_settings, save_api_key, save_setting, AVAILABLE_MODELS, LLMProvider
+from .config import (
+    get_settings, save_api_key, save_setting, AVAILABLE_MODELS, LLMProvider,
+    is_first_run, mark_first_run_complete, detect_lean_installation, detect_ollama
+)
 
 
-__version__ = "3.2.0"
+__version__ = "3.3.0"
 
 console = Console()
 
@@ -28,7 +31,7 @@ def show_banner():
 [bold white]███████║██║╚██████╔╝██║ ╚═╝ ██║██║  ██║[/bold white]
 [bold white]╚══════╝╚═╝ ╚═════╝ ╚═╝     ╚═╝╚═╝  ╚═╝[/bold white]
 
-[dim]v3.2.0[/dim] [bold cyan]σ[/bold cyan] [bold]Finance Research Agent[/bold]
+[dim]v3.3.0[/dim] [bold cyan]σ[/bold cyan] [bold]Finance Research Agent[/bold]
 """
     console.print(banner)
 
@@ -37,7 +40,7 @@ def main():
     """Main CLI entry point."""
     parser = argparse.ArgumentParser(
         prog="sigma",
-        description="Sigma v3.2.0 - Finance Research Agent",
+        description="Sigma v3.3.0 - Finance Research Agent",
         formatter_class=argparse.RawDescriptionHelpFormatter,
         epilog="""
 Examples:
@@ -126,7 +129,35 @@ Examples:
     
     if args.setup:
         from .setup import run_setup
-        return 0 if run_setup() else 1
+        result = run_setup()
+        if result:
+            mark_first_run_complete()
+            # After manual setup, ask if user wants to launch
+            from rich.prompt import Confirm
+            if Confirm.ask("\n[bold cyan]σ[/bold cyan] Launch Sigma now?", default=True):
+                launch()
+        return 0 if result else 1
+    
+    # Auto-launch setup on first run, then start interactive
+    if is_first_run():
+        console.print("\n[bold cyan]σ[/bold cyan] [bold]Welcome to Sigma![/bold]")
+        console.print("[dim]First time setup detected. Launching setup wizard...[/dim]\n")
+        from .setup import run_setup
+        result = run_setup()
+        mark_first_run_complete()  # Always mark complete to not ask again
+        
+        if result:
+            console.print("\n[bold green]✓ Setup complete![/bold green]")
+            console.print("[dim]Launching Sigma...[/dim]\n")
+            import time
+            time.sleep(1)  # Brief pause for user to see message
+            launch()
+            return 0
+        else:
+            console.print("\n[yellow]Setup skipped.[/yellow] You can run [bold]sigma --setup[/bold] later.")
+            console.print("[dim]Launching Sigma anyway...[/dim]\n")
+            launch()
+            return 0
     
     if args.list_models:
         console.print("\n[bold]Available Models by Provider:[/bold]\n")

sigma/config.py

@@ -1,15 +1,17 @@
-"""Configuration management for Sigma v3.2.0."""
+"""Configuration management for Sigma v3.3.0."""
 
 import os
+import shutil
+import subprocess
 from enum import Enum
 from pathlib import Path
-from typing import Optional
+from typing import Optional, Tuple
 
 from pydantic import Field
 from pydantic_settings import BaseSettings
 
 
-__version__ = "3.2.0"
+__version__ = "3.3.0"
 
 
 class LLMProvider(str, Enum):
@@ -35,6 +37,167 @@ AVAILABLE_MODELS = {
 # Config directory
 CONFIG_DIR = Path.home() / ".sigma"
 CONFIG_FILE = CONFIG_DIR / "config.env"
+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()
+
+
+def mark_first_run_complete() -> None:
+    """Mark that the first run setup has been completed."""
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    FIRST_RUN_MARKER.touch()
+
+
+def detect_lean_installation() -> Tuple[bool, Optional[str], Optional[str]]:
+    """
+    Auto-detect LEAN/QuantConnect installation.
+    Returns: (is_installed, cli_path, lean_directory)
+    """
+    lean_cli_path = None
+    lean_directory = None
+    
+    # Check if lean CLI is available in PATH
+    lean_cli = shutil.which("lean")
+    if lean_cli:
+        lean_cli_path = lean_cli
+    
+    # Check common installation paths for LEAN directory
+    common_paths = [
+        Path.home() / "Lean",
+        Path.home() / ".lean",
+        Path.home() / "QuantConnect" / "Lean",
+        Path("/opt/lean"),
+        Path.home() / "Projects" / "Lean",
+        Path.home() / ".local" / "share" / "lean",
+    ]
+    
+    for path in common_paths:
+        if path.exists():
+            # Check for LEAN directory structure
+            if (path / "Launcher").exists() or (path / "Algorithm.Python").exists() or (path / "lean.json").exists():
+                lean_directory = str(path)
+                break
+    
+    # Check if lean is installed via pip (check both pip and pip3)
+    if not lean_cli_path:
+        for pip_cmd in ["pip3", "pip"]:
+            try:
+                result = subprocess.run(
+                    [pip_cmd, "show", "lean"],
+                    capture_output=True,
+                    text=True,
+                    timeout=10
+                )
+                if result.returncode == 0:
+                    # Parse location from pip show output
+                    for line in result.stdout.split("\n"):
+                        if line.startswith("Location:"):
+                            # lean is installed via pip
+                            lean_cli_path = "lean"
+                            break
+                    if lean_cli_path:
+                        break
+            except (subprocess.TimeoutExpired, FileNotFoundError, Exception):
+                continue
+    
+    # Also check if lean command works directly
+    if not lean_cli_path:
+        try:
+            result = subprocess.run(
+                ["lean", "--version"],
+                capture_output=True,
+                text=True,
+                timeout=5
+            )
+            if result.returncode == 0:
+                lean_cli_path = "lean"
+        except (FileNotFoundError, subprocess.TimeoutExpired, Exception):
+            pass
+    
+    is_installed = lean_cli_path is not None or lean_directory is not None
+    return is_installed, lean_cli_path, lean_directory
+
+
+async def install_lean_cli() -> Tuple[bool, str]:
+    """
+    Install LEAN CLI via pip.
+    Returns: (success, message)
+    """
+    import asyncio
+    
+    try:
+        # Try pip3 first, then pip
+        for pip_cmd in ["pip3", "pip"]:
+            try:
+                process = await asyncio.create_subprocess_exec(
+                    pip_cmd, "install", "lean",
+                    stdout=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.PIPE
+                )
+                stdout, stderr = await asyncio.wait_for(process.communicate(), timeout=120)
+                
+                if process.returncode == 0:
+                    return True, "LEAN CLI installed successfully!"
+            except (FileNotFoundError, asyncio.TimeoutError):
+                continue
+        
+        return False, "Failed to install LEAN CLI. Please install manually: pip install lean"
+    except Exception as e:
+        return False, f"Installation error: {str(e)}"
+
+
+def install_lean_cli_sync() -> Tuple[bool, str]:
+    """
+    Install LEAN CLI via pip (synchronous version).
+    Returns: (success, message)
+    """
+    try:
+        # Try pip3 first, then pip
+        for pip_cmd in ["pip3", "pip"]:
+            try:
+                result = subprocess.run(
+                    [pip_cmd, "install", "lean"],
+                    capture_output=True,
+                    text=True,
+                    timeout=120
+                )
+                
+                if result.returncode == 0:
+                    return True, "LEAN CLI installed successfully!"
+            except (FileNotFoundError, subprocess.TimeoutExpired):
+                continue
+        
+        return False, "Failed to install LEAN CLI. Please install manually: pip install lean"
+    except Exception as e:
+        return False, f"Installation error: {str(e)}"
+
+
+def detect_ollama() -> Tuple[bool, Optional[str]]:
+    """
+    Auto-detect Ollama installation and available models.
+    Returns: (is_running, host_url)
+    """
+    import urllib.request
+    import urllib.error
+    
+    hosts_to_check = [
+        "http://localhost:11434",
+        "http://127.0.0.1:11434",
+    ]
+    
+    for host in hosts_to_check:
+        try:
+            req = urllib.request.Request(f"{host}/api/tags", method="GET")
+            with urllib.request.urlopen(req, timeout=2) as resp:
+                if resp.status == 200:
+                    return True, host
+        except (urllib.error.URLError, OSError):
+            continue
+    
+    return False, None
 
 
 class Settings(BaseSettings):
@@ -62,6 +225,11 @@ class Settings(BaseSettings):
     # Ollama settings
     ollama_host: str = "http://localhost:11434"
     
+    # LEAN settings
+    lean_cli_path: Optional[str] = Field(default=None, alias="LEAN_CLI_PATH")
+    lean_directory: Optional[str] = Field(default=None, alias="LEAN_DIRECTORY")
+    lean_enabled: bool = Field(default=False, alias="LEAN_ENABLED")
+    
     # Data API keys
     alpha_vantage_api_key: str = "6ER128DD3NQUPTVC"  # Built-in free key
     exa_api_key: Optional[str] = None
@@ -183,6 +351,9 @@ def save_setting(key: str, value: str) -> None:
         "output_dir": "OUTPUT_DIR",
         "cache_enabled": "CACHE_ENABLED",
         "lean_cli_path": "LEAN_CLI_PATH",
+        "lean_directory": "LEAN_DIRECTORY",
+        "lean_enabled": "LEAN_ENABLED",
+        "ollama_host": "OLLAMA_HOST",
     }
     
     config_key = setting_map.get(key, key.upper())

sigma/llm.py

@@ -1,15 +1,68 @@
 """LLM client implementations for all providers."""
 
+import asyncio
 import json
+import re
+import time
 from abc import ABC, abstractmethod
 from typing import Any, AsyncIterator, Callable, Optional
 
 from sigma.config import LLMProvider, get_settings
 
 
+# Rate limiting configuration
+class RateLimiter:
+    """Simple rate limiter to prevent API flooding."""
+    
+    def __init__(self, requests_per_minute: int = 10, min_interval: float = 1.0):
+        self.requests_per_minute = requests_per_minute
+        self.min_interval = min_interval
+        self.last_request_time = 0
+        self.request_count = 0
+        self.window_start = time.time()
+    
+    async def wait(self):
+        """Wait if necessary to respect rate limits."""
+        current_time = time.time()
+        
+        # Reset window if a minute has passed
+        if current_time - self.window_start >= 60:
+            self.window_start = current_time
+            self.request_count = 0
+        
+        # Check if we've hit the rate limit
+        if self.request_count >= self.requests_per_minute:
+            wait_time = 60 - (current_time - self.window_start)
+            if wait_time > 0:
+                await asyncio.sleep(wait_time)
+                self.window_start = time.time()
+                self.request_count = 0
+        
+        # Ensure minimum interval between requests
+        time_since_last = current_time - self.last_request_time
+        if time_since_last < self.min_interval:
+            await asyncio.sleep(self.min_interval - time_since_last)
+        
+        self.last_request_time = time.time()
+        self.request_count += 1
+
+
+# Global rate limiters per provider
+_rate_limiters = {
+    "google": RateLimiter(requests_per_minute=15, min_interval=0.5),
+    "openai": RateLimiter(requests_per_minute=20, min_interval=0.3),
+    "anthropic": RateLimiter(requests_per_minute=15, min_interval=0.5),
+    "groq": RateLimiter(requests_per_minute=30, min_interval=0.2),
+    "xai": RateLimiter(requests_per_minute=10, min_interval=1.0),
+    "ollama": RateLimiter(requests_per_minute=60, min_interval=0.1),  # Local, can be faster
+}
+
+
 class BaseLLM(ABC):
     """Base class for LLM clients."""
     
+    provider_name: str = "base"
+    
     @abstractmethod
     async def generate(
         self,
@@ -19,11 +72,19 @@ class BaseLLM(ABC):
     ) -> str:
         """Generate a response."""
         pass
+    
+    async def _rate_limit(self):
+        """Apply rate limiting."""
+        limiter = _rate_limiters.get(self.provider_name)
+        if limiter:
+            await limiter.wait()
 
 
 class GoogleLLM(BaseLLM):
     """Google Gemini client."""
     
+    provider_name = "google"
+    
     def __init__(self, api_key: str, model: str):
         from google import genai
         self.client = genai.Client(api_key=api_key)
@@ -35,6 +96,7 @@ class GoogleLLM(BaseLLM):
         tools: Optional[list[dict]] = None,
         on_tool_call: Optional[Callable] = None,
     ) -> str:
+        await self._rate_limit()
         from google.genai import types
         
         # Extract system prompt and build contents
@@ -159,6 +221,8 @@ class GoogleLLM(BaseLLM):
 class OpenAILLM(BaseLLM):
     """OpenAI client."""
     
+    provider_name = "openai"
+    
     def __init__(self, api_key: str, model: str):
         from openai import AsyncOpenAI
         self.client = AsyncOpenAI(api_key=api_key)
@@ -170,6 +234,7 @@ class OpenAILLM(BaseLLM):
         tools: Optional[list[dict]] = None,
         on_tool_call: Optional[Callable] = None,
     ) -> str:
+        await self._rate_limit()
         kwargs = {
             "model": self.model,
             "messages": messages,
@@ -204,6 +269,8 @@ class OpenAILLM(BaseLLM):
 class AnthropicLLM(BaseLLM):
     """Anthropic Claude client."""
     
+    provider_name = "anthropic"
+    
     def __init__(self, api_key: str, model: str):
         from anthropic import AsyncAnthropic
         self.client = AsyncAnthropic(api_key=api_key)
@@ -215,6 +282,7 @@ class AnthropicLLM(BaseLLM):
         tools: Optional[list[dict]] = None,
         on_tool_call: Optional[Callable] = None,
     ) -> str:
+        await self._rate_limit()
         # Extract system message
         system = ""
         filtered_messages = []
@@ -277,6 +345,8 @@ class AnthropicLLM(BaseLLM):
 class GroqLLM(BaseLLM):
     """Groq client."""
     
+    provider_name = "groq"
+    
     def __init__(self, api_key: str, model: str):
         from groq import AsyncGroq
         self.client = AsyncGroq(api_key=api_key)
@@ -288,6 +358,7 @@ class GroqLLM(BaseLLM):
         tools: Optional[list[dict]] = None,
         on_tool_call: Optional[Callable] = None,
     ) -> str:
+        await self._rate_limit()
         kwargs = {
             "model": self.model,
             "messages": messages,
@@ -319,7 +390,9 @@ class GroqLLM(BaseLLM):
 
 
 class OllamaLLM(BaseLLM):
-    """Ollama local client."""
+    """Ollama local client with native tool call support."""
+    
+    provider_name = "ollama"
     
     def __init__(self, host: str, model: str):
         self.host = host.rstrip("/")
@@ -331,35 +404,200 @@ class OllamaLLM(BaseLLM):
         tools: Optional[list[dict]] = None,
         on_tool_call: Optional[Callable] = None,
     ) -> str:
+        await self._rate_limit()
         import aiohttp
         
-        # Ollama doesn't support tools natively, so we embed tool info in prompt
+        # Convert tools to Ollama format
+        ollama_tools = None
         if tools:
-            tool_desc = self._format_tools_for_prompt(tools)
-            # Prepend to system message
-            for i, msg in enumerate(messages):
-                if msg["role"] == "system":
-                    messages[i]["content"] = f"{msg['content']}\n\n{tool_desc}"
-                    break
-            else:
-                messages.insert(0, {"role": "system", "content": tool_desc})
+            ollama_tools = []
+            for tool in tools:
+                if tool.get("type") == "function":
+                    f = tool["function"]
+                    ollama_tools.append({
+                        "type": "function",
+                        "function": {
+                            "name": f["name"],
+                            "description": f.get("description", ""),
+                            "parameters": f.get("parameters", {})
+                        }
+                    })
+        
+        request_body = {
+            "model": self.model,
+            "messages": messages,
+            "stream": False
+        }
+        
+        if ollama_tools:
+            request_body["tools"] = ollama_tools
         
         async with aiohttp.ClientSession() as session:
-            async with session.post(
-                f"{self.host}/api/chat",
-                json={"model": self.model, "messages": messages, "stream": False}
-            ) as resp:
-                data = await resp.json()
-                return data.get("message", {}).get("content", "")
+            try:
+                async with session.post(
+                    f"{self.host}/api/chat",
+                    json=request_body,
+                    timeout=aiohttp.ClientTimeout(total=120)
+                ) as resp:
+                    if resp.status != 200:
+                        error_text = await resp.text()
+                        return f"Ollama error: {error_text}"
+                    
+                    data = await resp.json()
+                    message = data.get("message", {})
+                    
+                    # Check for tool calls in response
+                    tool_calls = message.get("tool_calls", [])
+                    
+                    if tool_calls and on_tool_call:
+                        # Process tool calls
+                        updated_messages = messages.copy()
+                        updated_messages.append(message)
+                        
+                        for tc in tool_calls:
+                            func = tc.get("function", {})
+                            tool_name = func.get("name", "")
+                            tool_args = func.get("arguments", {})
+                            
+                            # If arguments is a string, parse it
+                            if isinstance(tool_args, str):
+                                try:
+                                    tool_args = json.loads(tool_args)
+                                except json.JSONDecodeError:
+                                    tool_args = {}
+                            
+                            # Execute the tool
+                            result = await on_tool_call(tool_name, tool_args)
+                            
+                            # Add tool result to messages
+                            updated_messages.append({
+                                "role": "tool",
+                                "content": json.dumps(result) if not isinstance(result, str) else result
+                            })
+                        
+                        # Get final response with tool results
+                        return await self._continue_with_tools(session, updated_messages, ollama_tools, on_tool_call)
+                    
+                    # Check for text-based tool calls (fallback for older models)
+                    content = message.get("content", "")
+                    if "TOOL_CALL:" in content and on_tool_call:
+                        result = await self._parse_text_tool_call(content, on_tool_call)
+                        if result:
+                            return result
+                    
+                    return content
+                    
+            except aiohttp.ClientError as e:
+                return f"Connection error: {e}. Is Ollama running?"
+            except asyncio.TimeoutError:
+                return "Request timed out. Try a simpler query or check Ollama status."
+    
+    async def _continue_with_tools(
+        self,
+        session,
+        messages: list[dict],
+        tools: Optional[list[dict]],
+        on_tool_call: Optional[Callable],
+        depth: int = 0
+    ) -> str:
+        """Continue conversation after tool calls."""
+        import aiohttp
+        
+        if depth > 5:  # Prevent infinite loops
+            return "Maximum tool call depth reached."
+        
+        request_body = {
+            "model": self.model,
+            "messages": messages,
+            "stream": False
+        }
+        if tools:
+            request_body["tools"] = tools
+        
+        async with session.post(
+            f"{self.host}/api/chat",
+            json=request_body,
+            timeout=aiohttp.ClientTimeout(total=120)
+        ) as resp:
+            data = await resp.json()
+            message = data.get("message", {})
+            
+            # Check for more tool calls
+            tool_calls = message.get("tool_calls", [])
+            if tool_calls and on_tool_call:
+                updated_messages = messages.copy()
+                updated_messages.append(message)
+                
+                for tc in tool_calls:
+                    func = tc.get("function", {})
+                    tool_name = func.get("name", "")
+                    tool_args = func.get("arguments", {})
+                    
+                    if isinstance(tool_args, str):
+                        try:
+                            tool_args = json.loads(tool_args)
+                        except json.JSONDecodeError:
+                            tool_args = {}
+                    
+                    result = await on_tool_call(tool_name, tool_args)
+                    updated_messages.append({
+                        "role": "tool",
+                        "content": json.dumps(result) if not isinstance(result, str) else result
+                    })
+                
+                return await self._continue_with_tools(session, updated_messages, tools, on_tool_call, depth + 1)
+            
+            return message.get("content", "")
+    
+    async def _parse_text_tool_call(self, content: str, on_tool_call: Callable) -> Optional[str]:
+        """Parse text-based tool calls for older models."""
+        # Pattern: TOOL_CALL: tool_name({"arg": "value"}) or TOOL_CALL: tool_name(arg=value)
+        pattern = r'TOOL_CALL:\s*(\w+)\s*\(([^)]*)\)'
+        match = re.search(pattern, content)
+        
+        if not match:
+            return None
+        
+        tool_name = match.group(1)
+        args_str = match.group(2).strip()
+        
+        # Try to parse arguments
+        try:
+            if args_str.startswith("{"):
+                args = json.loads(args_str)
+            else:
+                # Parse key=value format
+                args = {}
+                for part in args_str.split(","):
+                    if "=" in part:
+                        k, v = part.split("=", 1)
+                        args[k.strip()] = v.strip().strip('"\'')
+        except:
+            args = {"symbol": args_str} if args_str else {}
+        
+        # Execute tool
+        result = await on_tool_call(tool_name, args)
+        
+        # Format result for response
+        if isinstance(result, dict):
+            result_str = json.dumps(result, indent=2)
+        else:
+            result_str = str(result)
+        
+        # Return combined response
+        return f"Tool result:\n```json\n{result_str}\n```"
     
     def _format_tools_for_prompt(self, tools: list[dict]) -> str:
-        """Format tools as text for prompt injection."""
+        """Format tools as text for prompt injection (legacy fallback)."""
         lines = ["You have access to these tools:"]
         for tool in tools:
             if tool.get("type") == "function":
                 f = tool["function"]
-                lines.append(f"- {f['name']}: {f.get('description', '')}")
+                params = f.get("parameters", {}).get("properties", {})
+                param_str = ", ".join(params.keys()) if params else ""
+                lines.append(f"- {f['name']}({param_str}): {f.get('description', '')}")
         lines.append("\nTo use a tool, respond with: TOOL_CALL: tool_name(args)")
+        lines.append("Example: TOOL_CALL: get_stock_quote(symbol=\"AAPL\")")
         return "\n".join(lines)