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

sigma/backtest/__init__.py

@@ -0,0 +1,2 @@
+from .service import SERVICE, BacktestService
+from .simple_engine import run_backtest, get_available_strategies

sigma/backtest/service.py

@@ -0,0 +1,116 @@
+import asyncio
+import json
+import os
+import shlex
+import subprocess
+from typing import AsyncIterator, Dict, Any, Optional
+import shutil
+
+class BacktestService:
+    def __init__(self, data_dir: str = "~/.sigma/lean_data"):
+        self.data_dir = os.path.expanduser(data_dir)
+        self.lean_cli = shutil.which("lean") or "lean"
+        
+    async def run_lean(self, algorithm_file: str, project_dir: str) -> AsyncIterator[Dict[str, Any]]:
+        """Run LEAN backtest and stream results."""
+        
+        # Validate project structure
+        # lean backtest "Project Name"
+        
+        # We assume the project is already "init-ed" or valid for LEAN.
+        # But for ad-hoc strategies, we might need a temp project.
+        
+        project_name = os.path.basename(project_dir)
+        parent_dir = os.path.dirname(project_dir)
+        
+        cmd = [
+            self.lean_cli, "backtest", project_name,
+            "--output", "backtest-result",
+            "--verbose"
+        ]
+        
+        # LEAN runs in CWD usually or expects config.
+        # We should run execution in the parent dir of the project so "lean backtest Project" works.
+        
+        process = await asyncio.create_subprocess_exec(
+            *cmd,
+            cwd=parent_dir,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE
+        )
+        
+        # Stream output
+        yield {"type": "status", "message": "Starting LEAN engine..."}
+        
+        if process.stdout:
+            while True:
+                line = await process.stdout.readline()
+                if not line:
+                    break
+                    
+                line_str = line.decode().strip()
+                if not line_str: continue
+                
+                # Parse typical LEAN logs if possible
+                if "Error" in line_str:
+                     yield {"type": "error", "message": line_str}
+                else:
+                     yield {"type": "log", "message": line_str}
+                 
+                # Trying to detect progress or stats in logs
+                # LEAN logs: "STATISTICS:: ..."
+            
+        await process.wait()
+        
+        if process.returncode != 0:
+            err_msg = "Unknown error"
+            if process.stderr:
+                stderr_data = await process.stderr.read()
+                err_msg = stderr_data.decode()
+            yield {"type": "error", "message": f"LEAN failed: {err_msg}"}
+            return
+
+        # Parse results
+        json_file = os.path.join(project_dir, "backtest-result", f"{project_name}.json") # Filename varies usually? 
+        # Actually lean backtest creates a file in the output dir with a name.
+        # We need to find the latest json in that dir.
+        
+        result_dir = os.path.join(project_dir, "backtest-result")
+        if os.path.exists(result_dir):
+            files = [f for f in os.listdir(result_dir) if f.endswith(".json")]
+            if files:
+                # Get newest
+                latest = max([os.path.join(result_dir, f) for f in files], key=os.path.getctime)
+                try:
+                    with open(latest, 'r') as f:
+                        data = json.load(f)
+                    yield {"type": "result", "data": data}
+                except Exception as e:
+                    yield {"type": "error", "message": f"Failed to parse results: {e}"}
+            else:
+                 yield {"type": "error", "message": "No result JSON found."}
+        else:
+             yield {"type": "error", "message": "No result directory found."}
+
+    async def create_project(self, name: str, code: str) -> str:
+        """Create a LEAN project with the given code."""
+        # Typically ~/.sigma/lean_projects/Name
+        projects_dir = os.path.expanduser("~/.sigma/lean_projects")
+        os.makedirs(projects_dir, exist_ok=True)
+        
+        project_path = os.path.join(projects_dir, name)
+        os.makedirs(project_path, exist_ok=True)
+        
+        # content
+        # main.py
+        with open(os.path.join(project_path, "main.py"), "w") as f:
+            f.write(code)
+            
+        # config.json needed? 
+        # lean init usually creates `lean.json` in root.
+        # We assume the user has a workspace or we set one up in ~/.sigma/lean_data?
+        # The service should ensure a workspace exists.
+        
+        return project_path
+
+SERVICE = BacktestService()

sigma/charts.py

@@ -234,8 +234,8 @@ def create_technical_chart(
                 go.Scatter(x=data.index, y=rsi, name="RSI", line=dict(color=SIGMA_THEME["accent"])),
                 row=row, col=1
             )
-            fig.add_hline(y=70, line_dash="dash", line_color=SIGMA_THEME["negative"], row=row, col=1)
-            fig.add_hline(y=30, line_dash="dash", line_color=SIGMA_THEME["positive"], row=row, col=1)
+            fig.add_hline(y=70, line_dash="dash", line_color=SIGMA_THEME["negative"], row=row, col=1)  # type: ignore
+            fig.add_hline(y=30, line_dash="dash", line_color=SIGMA_THEME["positive"], row=row, col=1)  # type: ignore
             fig.update_yaxes(range=[0, 100], row=row, col=1)
             row += 1
         

sigma/cli.py

@@ -1,4 +1,4 @@
-"""CLI entry point for Sigma v3.4.0."""
+"""CLI entry point for Sigma v3.5.0."""
 
 import argparse
 import json
@@ -17,7 +17,7 @@ from .config import (
 )
 
 
-__version__ = "3.4.0"
+__version__ = "3.5.0"
 
 console = Console()
 
@@ -32,7 +32,7 @@ def show_banner():
 [bold #3b82f6]███████║██║╚██████╔╝██║ ╚═╝ ██║██║  ██║[/bold #3b82f6]
 [bold #1d4ed8]╚══════╝╚═╝ ╚═════╝ ╚═╝     ╚═╝╚═╝  ╚═╝[/bold #1d4ed8]
 
-[dim]v3.4.0[/dim] [bold cyan]σ[/bold cyan] [bold]Finance Research Agent[/bold]
+[dim]v3.5.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.4.0 - Finance Research Agent",
+        description="Sigma v3.5.0 - Finance Research Agent",
         formatter_class=argparse.RawDescriptionHelpFormatter,
         epilog="""
 Examples:
@@ -129,7 +129,7 @@ Examples:
         return 0
     
     if args.setup:
-        from .setup import run_setup
+        from .setup_agent import run_setup
         result = run_setup()
         if result:
             mark_first_run_complete()
@@ -143,12 +143,12 @@ Examples:
     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
+        from .setup_agent import run_setup
         result = run_setup()
         mark_first_run_complete()  # Always mark complete to not ask again
         
         if result:
-            console.print("\n[bold green][ok] Setup complete![/bold green]")
+            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
@@ -238,15 +238,15 @@ Examples:
 def handle_ask(query: str) -> int:
     """Handle ask command."""
     import asyncio
-    from .llm import get_llm
-    from .tools import TOOLS, execute_tool
+    from .llm import get_router
+    from .tools import get_tools_for_llm, execute_tool
     
     settings = get_settings()
     
-    console.print(f"\n[dim]Using {settings.default_provider.value} / {settings.default_model}[/dim]\n")
+    console.print(f"\n[dim]Using model: {settings.default_model}[/dim]\n")
     
     try:
-        llm = get_llm(settings.default_provider, settings.default_model)
+        router = get_router(settings)
         
         async def run_query():
             """Run the query asynchronously."""
@@ -260,13 +260,15 @@ def handle_ask(query: str) -> int:
                 console.print(f"[dim]Executing: {name}[/dim]")
                 return execute_tool(name, args)
             
-            response = await llm.generate(messages, TOOLS, handle_tool)
+            # Using stream=False for CLI quick question to get full text at once
+            response = await router.chat(messages, tools=get_tools_for_llm(), on_tool_call=handle_tool, stream=False)
             return response
         
         with console.status("[bold blue]σ analyzing...[/bold blue]"):
             response = asyncio.run(run_query())
         
-        console.print(Panel(response, title="[bold cyan]σ Sigma[/bold cyan]"))
+        from rich.markdown import Markdown
+        console.print(Panel(Markdown(str(response)), title="[bold cyan]σ Sigma[/bold cyan]"))
         return 0
     
     except Exception as e:

sigma/comparison.py

@@ -219,7 +219,7 @@ class ComparisonEngine:
             
             # Momentum score (recent performance relative to history)
             if len(returns) > 252:
-                recent_return = (1 + returns.iloc[-63:]).prod() - 1  # 3 months
+                recent_return = float((1 + returns.iloc[-63:]).prod()) - 1  # 3 months  # type: ignore
                 historical_vol = returns.iloc[:-63].std()
                 momentum_score = recent_return / (historical_vol * np.sqrt(63)) if historical_vol > 0 else 0
             else:
@@ -236,7 +236,7 @@ class ComparisonEngine:
             if len(returns) > 252:
                 monthly_returns = returns.resample('M').apply(lambda x: (1 + x).prod() - 1)
                 if len(monthly_returns) > 2:
-                    trend_persistence = monthly_returns.autocorr(lag=1)
+                    trend_persistence = monthly_returns.autocorr(lag=1)  # type: ignore
                 else:
                     trend_persistence = 0
             else:

sigma/config.py

@@ -1,4 +1,4 @@
-"""Configuration management for Sigma v3.4.0."""
+"""Configuration management for Sigma v3.5.0."""
 
 import os
 import shutil
@@ -11,7 +11,7 @@ from pydantic import Field
 from pydantic_settings import BaseSettings
 
 
-__version__ = "3.4.0"
+__version__ = "3.5.0"
 
 
 class ErrorCode(IntEnum):
@@ -65,6 +65,7 @@ class SigmaError(Exception):
 
 class LLMProvider(str, Enum):
     """Supported LLM providers."""
+    SIGMA_CLOUD = "sigma_cloud"  # Hack Club / Default
     GOOGLE = "google"
     OPENAI = "openai"
     ANTHROPIC = "anthropic"
@@ -73,16 +74,24 @@ class LLMProvider(str, Enum):
     OLLAMA = "ollama"
 
 
-# Available models per provider (Feb 2026 - LATEST MODELS ONLY)
+# Available models per provider (Feb 2026 - REAL API NAMES)
 AVAILABLE_MODELS = {
+    "sigma_cloud": [
+        "moonshotai/kimi-k2.5", # Default via Hack Club
+        "gpt-4o",
+        "claude-3-5-sonnet-20240620"
+    ],
     "google": [
-        "gemini-3-flash",        # Latest fast model
-        "gemini-3-pro",          # Latest capable model
+        "gemini-3-flash-preview",     # Fast multimodal, Pro-level at Flash speed
+        "gemini-3-pro-preview",       # Multimodal reasoning (1M tokens)
+        "gemini-3-pro-image-preview", # Image+text focus (65K tokens)
     ],
     "openai": [
-        "gpt-5",                 # Latest flagship
-        "gpt-5-mini",            # Latest efficient
-        "o3",                    # Latest reasoning
+        "gpt-5",                 # Flagship general/agentic, multimodal (256K)
+        "gpt-5-mini",            # Cost-efficient variant (256K)
+        "gpt-5.2",               # Enterprise knowledge work, advanced reasoning
+        "gpt-5-nano",            # Ultra-cheap/lightweight
+        "o3",                    # Advanced reasoning
         "o3-mini",               # Fast reasoning
     ],
     "anthropic": [
@@ -309,18 +318,20 @@ class Settings(BaseSettings):
     """Application settings."""
     
     # Provider settings
-    default_provider: LLMProvider = LLMProvider.GOOGLE
-    default_model: str = Field(default="gemini-3-flash", alias="DEFAULT_MODEL")
+    default_provider: LLMProvider = LLMProvider.SIGMA_CLOUD
+    default_model: str = Field(default="gpt-4o", alias="DEFAULT_MODEL")
     
     # LLM API Keys
+    sigma_cloud_api_key: Optional[str] = Field(default=None, alias="SIGMA_CLOUD_API_KEY")
     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 - LATEST MODELS ONLY (Feb 2026)
-    google_model: str = "gemini-3-flash"
+    # Model settings - REAL API NAMES (Feb 2026)
+    sigma_cloud_model: str = "moonshotai/kimi-k2.5"  # Should map to OpenAI-compatible endpoint
+    google_model: str = "gemini-3-flash-preview"
     openai_model: str = "gpt-5"
     anthropic_model: str = "claude-sonnet-4-20250514"
     groq_model: str = "llama-3.3-70b-versatile"
@@ -348,6 +359,7 @@ class Settings(BaseSettings):
     def get_api_key(self, provider: LLMProvider) -> Optional[str]:
         """Get API key for a provider."""
         key_map = {
+            LLMProvider.SIGMA_CLOUD: self.sigma_cloud_api_key,
             LLMProvider.GOOGLE: self.google_api_key,
             LLMProvider.OPENAI: self.openai_api_key,
             LLMProvider.ANTHROPIC: self.anthropic_api_key,
@@ -360,6 +372,7 @@ class Settings(BaseSettings):
     def get_model(self, provider: LLMProvider) -> str:
         """Get model for a provider."""
         model_map = {
+            LLMProvider.SIGMA_CLOUD: self.sigma_cloud_model,
             LLMProvider.GOOGLE: self.google_model,
             LLMProvider.OPENAI: self.openai_model,
             LLMProvider.ANTHROPIC: self.anthropic_model,

sigma/core/command_router.py

@@ -0,0 +1,93 @@
+from typing import Any, Dict, List, Optional
+from pydantic import BaseModel
+
+from .intent import IntentParser
+from ..utils.extraction import extract_tickers, extract_timeframe
+
+class Request(BaseModel):
+    action: str
+    tickers: List[str]
+    timeframe: str
+    output_mode: str = "report" # report, memo, quant, summary, etc.
+    original_query: str
+    is_command: bool = False
+    details: Dict[str, Any] = {}
+
+class CommandRouter:
+    def __init__(self):
+        self.intent_parser = IntentParser()
+        
+    def parse(self, query: str) -> Request:
+        stripped = query.strip()
+        
+        # Explicit commands
+        if stripped.startswith("/"):
+            parts = stripped.split(maxsplit=1)
+            cmd = parts[0][1:].lower() # remove /
+            args = parts[1] if len(parts) > 1 else ""
+            
+            # Map commands to standard request structures
+            if cmd == "backtest":
+                 tickers = extract_tickers(args)
+                 return Request(
+                     action="backtest",
+                     tickers=tickers,
+                     timeframe="default",
+                     output_mode="quant",
+                     original_query=query,
+                     is_command=True
+                 )
+            elif cmd == "chart":
+                 tickers = extract_tickers(args)
+                 return Request(
+                     action="chart",
+                     tickers=tickers,
+                     timeframe="default",
+                     output_mode="chart",
+                     original_query=query,
+                     is_command=True
+                 )
+            elif cmd == "model":
+                 # Handled by UI/Engine specifically to switch model?
+                 return Request(
+                     action="config_model",
+                     tickers=[],
+                     timeframe="",
+                     output_mode="system",
+                     original_query=query,
+                     is_command=True,
+                     details={"model": args.strip()}
+                 )
+            elif cmd == "setup":
+                 return Request(action="setup", tickers=[], timeframe="", output_mode="system", original_query=query, is_command=True)
+                 
+        # Natural Language
+        tickers = extract_tickers(query)
+        tf_desc, start, end = extract_timeframe(query)
+        
+        # Simple heuristic for output mode
+        output_mode = "report"
+        if "memo" in query.lower(): output_mode = "memo"
+        if "summary" in query.lower(): output_mode = "summary"
+        if "backtest" in query.lower() or "quant" in query.lower(): output_mode = "quant"
+        
+        # Use existing IntentParser for heavier lifting if needed
+        # But Request object normalizes it for Engine
+        # Here we just do extraction logic
+        
+        # Intent parser might give us plan, but we want a unified Request struct first?
+        # Actually Engine uses IntentParser.
+        # Let's wrap IntentParsing into "action" determination.
+        
+        plan = self.intent_parser.parse(query)
+        action = plan.deliverable if plan else "analysis"
+        
+        return Request(
+            action=action,
+            tickers=tickers,
+            timeframe=tf_desc,
+            output_mode=output_mode,
+            original_query=query,
+            is_command=False,
+            details={"plan": plan}
+        )

sigma/llm/__init__.py

@@ -0,0 +1,3 @@
+from .router import LLMRouter, get_router
+from .registry import REGISTRY
+from .providers.base import BaseLLM

sigma/llm/providers/anthropic_provider.py

@@ -0,0 +1,196 @@
+import json
+from typing import Any, Callable, Dict, List, Optional, Union, AsyncIterator
+import logging
+
+from .base import BaseLLM
+
+logger = logging.getLogger(__name__)
+
+class AnthropicProvider(BaseLLM):
+    """Anthropic Claude client."""
+    
+    provider_name = "anthropic"
+    
+    def __init__(self, api_key: str, rate_limiter=None, base_url: Optional[str] = None):
+        super().__init__(rate_limiter)
+        from anthropic import AsyncAnthropic
+        self.client = AsyncAnthropic(api_key=api_key, base_url=base_url)
+    
+    async def generate(
+        self,
+        messages: List[Dict[str, str]],
+        model: str,
+        tools: Optional[List[Dict[str, Any]]] = None,
+        on_tool_call: Optional[Callable] = None,
+        stream: bool = True,
+        json_mode: bool = False,
+    ) -> Union[str, AsyncIterator[str]]:
+        await self._wait_for_rate_limit()
+        
+        # Format messages for Anthropic (separate system message)
+        system_prompt = ""
+        filtered_messages = []
+        for msg in messages:
+            if msg["role"] == "system":
+                system_prompt = msg["content"]
+            else:
+                filtered_messages.append(msg)
+                
+        kwargs = {
+            "model": model,
+            "max_tokens": 4096,
+            "messages": filtered_messages,
+            "system": system_prompt,
+        }
+        
+        if tools:
+            kwargs["tools"] = tools
+        
+        if stream:
+            return self._stream_response(kwargs, on_tool_call, tools, messages) # Pass original messages for recursion
+        else:
+            return await self._block_response(kwargs, on_tool_call, tools, messages)
+
+    async def _block_response(self, kwargs, on_tool_call, tools, messages):
+        response = await self.client.messages.create(**kwargs)
+        
+        # Check for tool usage
+        if response.stop_reason == "tool_use" and on_tool_call:
+            tool_results = []
+            assistant_content = []
+            
+            # Construct assistant message parts
+            for block in response.content:
+                if block.type == "text":
+                    assistant_content.append({"type": "text", "text": block.text})
+                elif block.type == "tool_use":
+                    assistant_content.append({
+                        "type": "tool_use",
+                        "id": block.id,
+                        "name": block.name,
+                        "input": block.input
+                    })
+                    
+                    # Execute tool
+                    try:
+                        result = await on_tool_call(block.name, block.input)
+                    except Exception as e:
+                        result = {"error": str(e)}
+                        
+                    tool_results.append({
+                        "type": "tool_result",
+                        "tool_use_id": block.id,
+                        "content": json.dumps(result, default=str)
+                    })
+            
+            # Append exchange to history
+            new_messages = messages + [
+                {"role": "assistant", "content": assistant_content},
+                {"role": "user", "content": tool_results}
+            ]
+            
+            # Recurse
+            # Re-format for next call
+            next_kwargs = kwargs.copy()
+            next_system = ""
+            next_filtered = []
+            for msg in new_messages:
+                if isinstance(msg.get("content"), str): # Basic text message
+                    if msg["role"] == "system":
+                        next_system = msg["content"]
+                    else:
+                        next_filtered.append(msg)
+                else: # Complex content
+                    next_filtered.append(msg)
+            
+            next_kwargs["messages"] = next_filtered
+            next_kwargs["system"] = next_system
+            
+            return await self._block_response(next_kwargs, on_tool_call, tools, new_messages)
+
+        return response.content[0].text if response.content else ""
+
+    async def _stream_response(self, kwargs, on_tool_call, tools, messages) -> AsyncIterator[str]:
+        async with self.client.messages.stream(**kwargs) as stream:
+            current_tool_use: Dict[str, Any] = {}
+            current_text = ""
+            tool_uses = []
+            
+            async for event in stream:
+                if event.type == "content_block_delta":
+                    if event.delta.type == "text_delta":
+                        yield event.delta.text
+                        current_text += event.delta.text
+                    elif event.delta.type == "input_json_delta":
+                        # Accumulate JSON
+                        current_tool_use["input_json"] = current_tool_use.get("input_json", "") + event.delta.partial_json
+                
+                elif event.type == "content_block_start":
+                    if event.content_block.type == "tool_use":
+                        current_tool_use = {
+                            "name": event.content_block.name,
+                            "id": event.content_block.id,
+                            "input_json": ""
+                        }
+                
+                elif event.type == "content_block_stop":
+                    if current_tool_use:
+                        try:
+                            current_tool_use["input"] = json.loads(current_tool_use["input_json"])
+                        except:
+                            current_tool_use["input"] = {}
+                        tool_uses.append(current_tool_use)
+                        current_tool_use = {}
+                
+                elif event.type == "message_stop":
+                    pass
+
+        # If tools were used, execute and recurse
+        if tool_uses and on_tool_call:
+            # Reconstruct assistant message
+            assistant_content = []
+            if current_text:
+                assistant_content.append({"type": "text", "text": current_text})
+            
+            tool_results = []
+            for tu in tool_uses:
+                assistant_content.append({
+                    "type": "tool_use",
+                    "id": tu["id"],
+                    "name": tu["name"],
+                    "input": tu["input"]
+                })
+                try:
+                    res = await on_tool_call(tu["name"], tu["input"])
+                except Exception as e:
+                    res = {"error": str(e)}
+                
+                tool_results.append({
+                    "type": "tool_result",
+                    "tool_use_id": tu["id"],
+                    "content": json.dumps(res, default=str)
+                })
+
+            new_messages = messages + [
+                {"role": "assistant", "content": assistant_content},
+                {"role": "user", "content": tool_results}
+            ]
+            
+            # Prepare next call
+            next_kwargs = kwargs.copy()
+            next_system = ""
+            next_filtered = []
+            for msg in new_messages:
+                if isinstance(msg.get("content"), str):
+                    if msg["role"] == "system":
+                        next_system = msg["content"]
+                    else:
+                        next_filtered.append(msg)
+                else:
+                    next_filtered.append(msg)
+            
+            next_kwargs["messages"] = next_filtered
+            next_kwargs["system"] = next_system
+            
+            async for chunk in self._stream_response(next_kwargs, on_tool_call, tools, new_messages):
+                yield chunk

sigma/llm/providers/base.py

@@ -0,0 +1,29 @@
+from abc import ABC, abstractmethod
+from typing import Any, Callable, Dict, List, Optional, Union
+from ..rate_limit import RateLimiter
+
+class BaseLLM(ABC):
+    """Base class for LLM clients."""
+    
+    provider_name: str = "base"
+    
+    def __init__(self, rate_limiter: Optional[RateLimiter] = None):
+        self.rate_limiter = rate_limiter
+        
+    @abstractmethod
+    async def generate(
+        self,
+        messages: List[Dict[str, str]],
+        model: str,
+        tools: Optional[List[Dict[str, Any]]] = None,
+        on_tool_call: Optional[Callable] = None,
+        stream: bool = True,
+        json_mode: bool = False,
+    ) -> Union[str, Any]:
+        """Generate a response."""
+        pass
+    
+    async def _wait_for_rate_limit(self):
+        """Apply rate limiting."""
+        if self.rate_limiter:
+            await self.rate_limiter.wait()