SIA/sia/config.py

from dataclasses import dataclass
from dotenv import load_dotenv
from pathlib import Path
from typing import Optional
import argparse
import os

@dataclass
class Config:
    def __init__(self):
        load_dotenv()
        parser = argparse.ArgumentParser(description='SIA - Self Improving Agent')
        
        # Core configuration
        parser.add_argument(
            '--system-prompt',
            type=Path,
            default=os.getenv('SIA_SYSTEM_PROMPT', '/root/sia/system_prompt.md'),
            help='Path to the system prompt file (default: /root/sia/system_prompt.md, env: SIA_SYSTEM_PROMPT)'
        )
        parser.add_argument(
            '--action-schema',
            type=Path,
            default=os.getenv('SIA_ACTION_SCHEMA', '/root/sia/action_schema.xsd'),
            help='Path to the action schema file (default: /root/sia/action_schema.xsd, env: SIA_ACTION_SCHEMA)'
        )
        parser.add_argument(
            '--iterations-dir',
            type=Path,
            default=os.getenv('SIA_ITERATIONS_DIR', '/root/data/iterations'),
            help='Path to the directory for storing iterations (default: /root/data/iterations, env: SIA_ITERATIONS_DIR)'
        )
        parser.add_argument(
            '--work-dir',
            type=Path,
            default=os.getenv('SIA_WORK_DIR', '/root/desktop'),
            help='Path to the working directory (default: /root/desktop, env: SIA_WORK_DIR)'
        )

        # Web server configuration
        parser.add_argument(
            '--server',
            action='store_true',
            default=self._parse_bool_env('SIA_SERVER_ENABLED', False),
            help='Enable web server for debugging and human feedback (env: SIA_SERVER_ENABLED)'
        )
        parser.add_argument(
            '--host',
            type=str,
            default=os.getenv('SIA_SERVER_HOST', '0.0.0.0'),
            help='Web server host (default: 0.0.0.0, env: SIA_SERVER_HOST)'
        )
        parser.add_argument(
            '--port',
            type=int,
            default=int(os.getenv('SIA_SERVER_PORT', '8080')),
            help='Web server port (default: 8080, env: SIA_SERVER_PORT)'
        )
        parser.add_argument(
            '--static-files',
            type=Path,
            default=self._parse_optional_path('SIA_STATIC_FILES', '/root/static/'),
            help='Path to static web files (default: /root/static/, env: SIA_STATIC_FILES)'
        )

        # Local LLM configuration
        parser.add_argument(
            '--local-enable',
            action='store_true',
            default=self._parse_bool_env('SIA_LOCAL_ENABLED', False),
            help='Enable local LLM engine (env: SIA_LOCAL_ENABLED)'
        )
        parser.add_argument(
            '--local-model',
            type=str,
            default=os.getenv('SIA_LOCAL_MODEL', '/root/models/current'),
            help='Path to local model directory (default: /root/models/current, env: SIA_LOCAL_MODEL)'
        )
        parser.add_argument(
            '--local-temperature',
            type=float,
            default=float(os.getenv('SIA_LOCAL_TEMPERATURE', '0.7')),
            help='Local LLM temperature (default: 0.7, env: SIA_LOCAL_TEMPERATURE)'
        )
        parser.add_argument(
            '--local-token-limit',
            type=int,
            default=int(os.getenv('SIA_LOCAL_TOKEN_LIMIT', '2048')),
            help='Local LLM token limit (env: SIA_LOCAL_TOKEN_LIMIT)'
        )
        parser.add_argument(
            '--local-api-key',
            type=str,
            default=os.getenv('SIA_LOCAL_API_KEY'),
            help='API key for local models (env: SIA_LOCAL_API_KEY)'
        )

        # OpenAI configuration
        parser.add_argument(
            '--openai-enable',
            action='store_true',
            default=self._parse_bool_env('SIA_OPENAI_ENABLED', False),
            help='Enable OpenAI LLM engine (env: SIA_OPENAI_ENABLED)'
        )
        parser.add_argument(
            '--openai-model',
            type=str,
            default=os.getenv('SIA_OPENAI_MODEL', 'gpt-3.5-turbo'),
            help='OpenAI model name (default: gpt-3.5-turbo, env: SIA_OPENAI_MODEL)'
        )
        parser.add_argument(
            '--openai-temperature',
            type=float,
            default=float(os.getenv('SIA_OPENAI_TEMPERATURE', '0.7')),
            help='OpenAI temperature (default: 0.7, env: SIA_OPENAI_TEMPERATURE)'
        )
        parser.add_argument(
            '--openai-token-limit',
            type=int,
            default=int(os.getenv('SIA_OPENAI_TOKEN_LIMIT', '4096')),
            help='OpenAI token limit (env: SIA_OPENAI_TOKEN_LIMIT)'
        )
        parser.add_argument(
            '--openai-api-key',
            type=str,
            default=os.getenv('SIA_OPENAI_API_KEY'),
            help='OpenAI API key (env: SIA_OPENAI_API_KEY)'
        )

        # Hugging Face configuration
        parser.add_argument(
            '--hf-enable',
            action='store_true',
            default=self._parse_bool_env('SIA_HF_ENABLED', False),
            help='Enable Hugging Face LLM engine (env: SIA_HF_ENABLED)'
        )
        parser.add_argument(
            '--hf-model',
            type=str,
            default=os.getenv('SIA_HF_MODEL'),
            help='Hugging Face model name (env: SIA_HF_MODEL)'
        )
        parser.add_argument(
            '--hf-temperature',
            type=float,
            default=float(os.getenv('SIA_HF_TEMPERATURE', '0.7')),
            help='Hugging Face temperature (default: 0.7, env: SIA_HF_TEMPERATURE)'
        )
        parser.add_argument(
            '--hf-api-key',
            type=str,
            default=os.getenv('SIA_HF_API_KEY'),
            help='Hugging Face API key (env: SIA_HF_API_KEY)'
        )

        # Mistral configuration
        parser.add_argument(
            '--mistral-enable',
            action='store_true',
            default=self._parse_bool_env('SIA_MISTRAL_ENABLED', False),
            help='Enable Mistral LLM engine (env: SIA_MISTRAL_ENABLED)'
        )
        parser.add_argument(
            '--mistral-model',
            type=str,
            default=os.getenv('SIA_MISTRAL_MODEL'),
            help='Mistral model name (env: SIA_MISTRAL_MODEL)'
        )
        parser.add_argument(
            '--mistral-temperature',
            type=float,
            default=float(os.getenv('SIA_MISTRAL_TEMPERATURE', '0.7')),
            help='Mistral temperature (default: 0.7, env: SIA_MISTRAL_TEMPERATURE)'
        )
        parser.add_argument(
            '--mistral-token-limit',
            type=int,
            default=int(os.getenv('SIA_MISTRAL_TOKEN_LIMIT', '4096')),
            help='Mistral token limit (env: SIA_MISTRAL_TOKEN_LIMIT)'
        )
        parser.add_argument(
            '--mistral-api-key',
            type=str,
            default=os.getenv('SIA_MISTRAL_API_KEY'),
            help='Mistral API key (env: SIA_MISTRAL_API_KEY)'
        )
        parser.add_argument(
            '--deepseek-enable',
            action='store_true',
            default=self._parse_bool_env('SIA_DEEPSEEK_ENABLED', False),
            help='Enable DeepSeek LLM engine (env: SIA_DEEPSEEK_ENABLED)'
        )
        parser.add_argument(
            '--deepseek-model',
            type=str,
            default=os.getenv('SIA_DEEPSEEK_MODEL', '/root/models/current'),
            help='Path to fine-tuned DeepSeek model (env: SIA_DEEPSEEK_MODEL)'
        )
        parser.add_argument(
            '--deepseek-temperature',
            type=float,
            default=float(os.getenv('SIA_DEEPSEEK_TEMPERATURE', '0.6')),
            help='DeepSeek temperature (default: 0.6, env: SIA_DEEPSEEK_TEMPERATURE)'
        )
        parser.add_argument(
            '--deepseek-token-limit',
            type=int,
            default=int(os.getenv('SIA_DEEPSEEK_TOKEN_LIMIT', '0')),
            help='DeepSeek token limit (0 for model default, env: SIA_DEEPSEEK_TOKEN_LIMIT)'
        )

        self.args = parser.parse_args()

    def _parse_bool_env(self, env_var: str, default: bool) -> bool:
        val = os.getenv(env_var)
        if val is None:
            return default
        return val.lower() in ('true', '1', 'yes', 'on')
    
    def _parse_optional_path(self, env_var: str, default: Optional[Path]) -> Optional[Path]:
        val = os.getenv(env_var)
        if val is None:
            return default
        return Path(val)

    # Core properties
    @property
    def system_prompt(self) -> Path:
        return self.args.system_prompt
    
    @property
    def action_schema(self) -> Path:
        return self.args.action_schema
    
    @property
    def iterations_dir(self) -> Path:
        return self.args.iterations_dir
    
    @property
    def work_dir(self) -> Path:
        return self.args.work_dir

    # Server properties
    @property
    def server(self) -> bool:
        return self.args.server

    @property
    def host(self) -> str:
        return self.args.host
    
    @property
    def port(self) -> int:
        return self.args.port
    
    @property
    def static_files(self) -> Path:
        return self.args.static_files

    # Local LLM properties
    @property
    def local_enabled(self) -> bool:
        return self.args.local_enable

    @property
    def local_model(self) -> str:
        return self.args.local_model

    @property
    def local_temperature(self) -> float:
        return self.args.local_temperature

    @property
    def local_token_limit(self) -> int:
        return self.args.local_token_limit
    
    @property
    def local_api_key(self) -> Optional[str]:
        return self.args.local_api_key

    # OpenAI properties
    @property
    def openai_enabled(self) -> bool:
        return self.args.openai_enable

    @property
    def openai_model(self) -> str:
        return self.args.openai_model

    @property
    def openai_temperature(self) -> float:
        return self.args.openai_temperature

    @property
    def openai_token_limit(self) -> int:
        return self.args.openai_token_limit

    @property
    def openai_api_key(self) -> Optional[str]:
        return self.args.openai_api_key

    # Hugging Face properties
    @property
    def hf_enabled(self) -> bool:
        return self.args.hf_enable

    @property
    def hf_model(self) -> str:
        return self.args.hf_model

    @property
    def hf_temperature(self) -> float:
        return self.args.hf_temperature

    @property
    def hf_api_key(self) -> Optional[str]:
        return self.args.hf_api_key

    # Mistral properties
    @property
    def mistral_enabled(self) -> bool:
        return self.args.mistral_enable

    @property
    def mistral_model(self) -> str:
        return self.args.mistral_model

    @property
    def mistral_temperature(self) -> float:
        return self.args.mistral_temperature

    @property
    def mistral_token_limit(self) -> int:
        return self.args.mistral_token_limit

    @property
    def mistral_api_key(self) -> Optional[str]:
        return self.args.mistral_api_key

    @property
    def deepseek_enabled(self) -> bool:
        return self.args.deepseek_enable

    @property
    def deepseek_model(self) -> str:
        return self.args.deepseek_model

    @property
    def deepseek_temperature(self) -> float:
        return self.args.deepseek_temperature

    @property
    def deepseek_token_limit(self) -> Optional[int]:
        # Return None if 0 to use model default
        return self.args.deepseek_token_limit if self.args.deepseek_token_limit > 0 else None