sourcebot 0.1.0__py3-none-any.whl

sourcebot/config/base.py

@@ -0,0 +1,13 @@
+# src/sourcebot/config/base.py
+from pydantic import BaseModel, ConfigDict
+from typing import Any, Dict
+
+
+class Base(BaseModel):
+    """Basic configuration class"""
+    model_config = ConfigDict(
+        extra = "forbid",  
+        validate_assignment = True, 
+        arbitrary_types_allowed = False,  
+        populate_by_name = True,  
+    )

sourcebot/config/config_manager.py

@@ -0,0 +1,367 @@
+# sourcebot/config/config_manager.py
+import json
+import os
+from pathlib import Path
+from typing import Optional, Dict, Any, Union
+from datetime import datetime
+
+from .exceptions import ConfigError
+from .global_config import GlobalConfig
+from .workspace_config import WorkspaceConfig, ModelConfig
+from .provider_config import ProvidersConfig
+
+
+class ConfigManager:
+    """
+    Configuration Manager - Separate global configuration and workspace configuration
+    """
+    
+    def __init__(self, app_name: str = "sourcebot"):
+        """
+        Initialize Configuration Manager
+
+        Args:
+            app_name: Application Name
+        """
+        self.app_name = app_name
+        self.app_root_path = Path.home() / f".{app_name}"
+        self.global_config_path = self.app_root_path / "config.json"
+        self.workspace_config_name = f"{app_name}.workspace.json"
+        
+        self.app_root_path.mkdir(parents=True, exist_ok=True)
+        
+        self._global_config: Optional[GlobalConfig] = None
+        self._workspace_config: Optional[WorkspaceConfig] = None
+        self._current_workspace_path: Optional[Path] = None
+    
+    # Global Configuration Management
+    
+    def init_global_config(self, force: bool = False) -> GlobalConfig:
+        """
+        Initialize global configuration (only once)
+
+        Args:
+            force: Whether to force re-initialization
+
+        Returns:
+            Global configuration object
+        """
+        if not force and self.global_config_path.exists():
+            return self.load_global_config()
+        
+        config = GlobalConfig()
+        
+        self.save_global_config(config)
+        print(f"✅ Global configuration has been initialized: {self.global_config_path}")
+        
+        self._global_config = config
+        return config
+    
+    def load_global_config(self) -> GlobalConfig:
+        """
+        Load global configuration
+
+        Returns:
+            Global configuration object
+        """
+        if self._global_config is not None:
+            return self._global_config
+        
+        if not self.global_config_path.exists():
+            return self.init_global_config()
+        
+        try:
+            with open(self.global_config_path, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+            
+            config = GlobalConfig.model_validate(data)
+            self._global_config = config
+            return config
+            
+        except Exception as e:
+            raise ConfigError(f"Failed to load global configuration: {e}")
+    
+    def save_global_config(self, config: Optional[GlobalConfig] = None):
+        """
+        Save global configuration
+
+        Args:
+            config: Configuration object; saves cached configuration when None is selected.
+        """
+        config = config or self._global_config
+        if config is None:
+            raise ConfigError("No global configuration can be saved")
+        
+        config.update_timestamp()
+        
+        try:
+            self.global_config_path.parent.mkdir(parents=True, exist_ok=True)
+            
+            with open(self.global_config_path, 'w', encoding='utf-8') as f:
+                json.dump(config.model_dump(exclude_none=True), f, indent=2, ensure_ascii=False)
+            
+            self._global_config = config
+            print(f"✅ Global configuration has been saved")
+            
+        except Exception as e:
+            raise ConfigError(f"Failed to save global configuration: {e}")
+    
+    # Provider Configuration Management
+    
+    def set_provider_config(self, provider: str, api_key: str, api_base: Optional[str] = None, **kwargs):
+        """
+        Configure Provider
+
+        Args:
+            Provider: Provider name
+            API_key: API key
+            API_base: API base URL
+            **Kwargs: Other configurations
+        """
+        global_config = self.load_global_config()
+        
+        provider_config = getattr(global_config.providers, provider, None)
+        if provider_config is None:
+            raise ConfigError(f"Unsupported providers: {provider}")
+        
+        provider_config.api_key = api_key
+        if api_base:
+            provider_config.api_base = api_base
+        for key, value in kwargs.items():
+            if hasattr(provider_config, key):
+                setattr(provider_config, key, value)
+        
+        self.save_global_config(global_config)
+        print(f"✅ {provider} configuration has been updated")
+    
+    def get_provider_config(self, provider: str):
+        """Get provider configuration"""
+        global_config = self.load_global_config()
+        return getattr(global_config.providers, provider, None)
+    
+    def list_providers(self, only_configured: bool = False) -> Dict[str, Any]:
+        """List all providers"""
+        global_config = self.load_global_config()
+        
+        if only_configured:
+            return {name: config for name, config in global_config.providers if config.is_configured()}
+        else:
+            return {name: config for name, config in global_config.providers}
+    
+    # Workspace Configuration Management
+    
+    def find_workspace_config(self, start_path: Optional[Path] = None) -> Optional[Path]:
+        """
+        Locate workspace configuration file
+
+        Args:
+            start_path: Starting path
+
+        Returns:
+            Configuration file path
+        """
+        if start_path is None:
+            start_path = Path.cwd()
+        
+        start_path = start_path.absolute()
+        
+        current = start_path
+        while current != current.parent:
+            config_file = current / self.workspace_config_name
+            if config_file.exists():
+                return config_file
+            current = current.parent
+        
+        return None
+    
+    def load_workspace_config(self, workspace_path: Optional[Path] = None) -> Optional[WorkspaceConfig]:
+        """
+        Load workspace configuration
+
+        Args:
+            workspace_path: Workspace path
+        Returns:
+            Workspace configuration object; returns None if not found.
+        """
+        config_path = self.find_workspace_config(workspace_path)
+        if not config_path:
+            return None
+        
+        try:
+            with open(config_path, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+            
+            config = WorkspaceConfig.model_validate(data)
+            self._workspace_config = config
+            self._current_workspace_path = config_path.parent
+            return config
+            
+        except Exception as e:
+            raise ConfigError(f"Failed to load workspace configuration: {e}")
+    
+    def init_workspace_config(self, project_name: str, project_path: Optional[Path] = None,
+                              default_model: Optional[str] = None) -> WorkspaceConfig:
+        """
+        Initialize workspace configuration
+
+        Args:
+            project_name: Project name
+            project_path: Project path
+            default_model: Default model name
+        Returns:
+            Workspace configuration object
+        """
+        if project_path is None:
+            project_path = Path.cwd()
+        else:
+            project_path = Path(project_path).expanduser().resolve()
+        
+        project_path.mkdir(parents=True, exist_ok=True)
+        config_path = project_path / self.workspace_config_name
+        if config_path.exists():
+            response = input(f"The workspace configuration already exists: {config_path}\nShould it be overwritten? (y/N): ")
+            if response.lower() != 'y':
+                return self.load_workspace_config(project_path)
+        
+        config = WorkspaceConfig(
+            project_name=project_name,
+            project_root=str(project_path)
+        )
+        
+        if default_model:
+            global_config = self.load_global_config()
+            config.add_model(
+                name="default",
+                provider=global_config.default_provider,
+                model=default_model
+            )
+            config.default_model = "default"
+        
+        self.save_workspace_config(config, project_path)
+        
+        self._workspace_config = config
+        self._current_workspace_path = project_path
+        
+        return config
+    
+    def save_workspace_config(self, config: WorkspaceConfig, project_path: Optional[Path] = None):
+        """
+        Save workspace configuration
+        Args:
+            config: Workspace configuration
+            project_path: Project path
+        """
+        if project_path is None:
+            project_path = Path(config.project_root)
+        else:
+            project_path = Path(project_path).expanduser().resolve()
+        
+        project_path.mkdir(parents=True, exist_ok=True)
+        
+        config_path = project_path / self.workspace_config_name
+        
+        try:
+            with open(config_path, 'w', encoding='utf-8') as f:
+                json.dump(config.model_dump(exclude_none=True), f, indent=2, ensure_ascii=False)
+            
+            print(f"✅ Workspace configuration has been saved: {config_path}")
+            
+        except Exception as e:
+            raise ConfigError(f"Failed to save workspace configuration: {e}")
+    
+    # Model Configuration Management
+    
+    def add_model_to_workspace(self, name: str, provider: str, model: str,
+                               workspace_path: Optional[Path] = None, **kwargs):
+        """
+        Add a model to the workspace configuration
+
+        Args:
+            name: Model name
+            provider: Provider name
+            model: Model name
+            workspace_path: Workspace path
+            **kwargs: Other model parameters
+        """
+        global_config = self.load_global_config()
+        provider_config = getattr(global_config.providers, provider, None)
+        if not provider_config or not provider_config.is_configured():
+            print(f"Warning: Provider {provider} has not set the API key in the global configuration.")
+        
+        workspace_config = self.load_workspace_config(workspace_path)
+        if not workspace_config:
+            if workspace_path is None:
+                workspace_path = Path.cwd()
+            workspace_config = self.init_workspace_config(
+                project_name=workspace_path.name,
+                project_path=workspace_path
+            )
+        
+        workspace_config.add_model(name, provider, model, **kwargs)
+        
+        if workspace_config.default_model == "default" and name != "default":
+            workspace_config.default_model = name
+        
+        self.save_workspace_config(workspace_config)
+        print(f"✅ The model {name} ({provider}/{model}) has been added to the workspace.") 
+        
+    
+    def get_model_for_workspace(self, model_name: Optional[str] = None,
+                                workspace_path: Optional[Path] = None) -> Dict[str, Any]:
+        """
+        Retrieves the workspace model configuration (including the global API key)
+        Args:
+            model_name: Model name; default model is used if None
+            workspace_path: Workspace path
+        Returns:
+            A dictionary containing the complete configuration (model parameters + API key, etc.)
+        """
+
+        workspace_config = self.load_workspace_config(workspace_path)
+        if not workspace_config:
+            raise ConfigError("Workspace configuration not found, please initialize first.")
+        
+        model_config = workspace_config.get_model_config(model_name)
+        if not model_config:
+            raise ConfigError(f"The model does not exist: {model_name or workspace_config.default_model}")
+        
+        global_config = self.load_global_config()
+        provider_config = global_config.get_provider_config(model_config.provider)
+        
+        if not provider_config or not provider_config.is_configured():
+            raise ConfigError(f"The provider {model_config.provider} does not have an API key configured.")
+        
+        result = {
+            "provider": model_config.provider,
+            "model": model_config.model,
+            "api_key": provider_config.api_key,
+            "api_base": provider_config.api_base,
+            "temperature": model_config.temperature,
+            "max_tokens": model_config.max_tokens,
+            "top_p": model_config.top_p,
+        }
+        
+        if provider_config.extra_headers:
+            result["extra_headers"] = provider_config.extra_headers
+        
+        return result
+    
+    # Tools and Methods
+    
+    @property
+    def current_workspace(self) -> Optional[WorkspaceConfig]:
+        """Get current workspace configuration"""
+        if self._workspace_config is None:
+            self._workspace_config = self.load_workspace_config()
+        return self._workspace_config
+    
+    @property
+    def in_workspace(self) -> bool:
+        return self.current_workspace is not None
+    
+    def get_workspace_path(self) -> Optional[Path]:
+        """Get the current workspace path"""
+        if self._current_workspace_path:
+            return self._current_workspace_path
+        config_path = self.find_workspace_config()
+        return config_path.parent if config_path else None

sourcebot/config/exceptions.py

@@ -0,0 +1,4 @@
+# sourcebot/config/exceptions.py
+class ConfigError(Exception):
+    """config error"""
+    pass

sourcebot/config/global_config.py

@@ -0,0 +1,55 @@
+# sourcebot/config/global_config.py
+from pathlib import Path
+from pydantic import Field
+from typing import Optional, Dict, Any
+from datetime import datetime
+
+from .base import Base
+from .provider_config import ProvidersConfig
+
+
+class GlobalConfig(Base):
+    """Global configuration - initialized only once, saved in ~/.sourcebot/config.json"""
+    
+    version: str = Field(default="1.0.0", description="Configuration version")
+    created_at: str = Field(default_factory=lambda: datetime.now().isoformat(), description="Creation time")
+    updated_at: str = Field(default_factory=lambda: datetime.now().isoformat(), description="Update time")
+    
+    providers: ProvidersConfig = Field(default_factory=ProvidersConfig, description="LLM provider configuration")
+    
+    default_provider: str = Field(default="dashscope", description="Default provider")
+    default_model: str = Field(default="qwen3.5-plus", description="Default model")
+    
+    cache_dir: str = Field(default=str(Path.home() / ".cache" / "sourcebot"), description="Cache directory")
+    log_level: str = Field(default="info", description="Log levels")
+    
+    def update_timestamp(self):
+        """Update timestamp"""
+        self.updated_at = datetime.now().isoformat()
+    
+    def get_provider_config(self, provider_name: str) -> Optional[Any]:
+        """Get the configuration of the specified provider"""
+        return getattr(self.providers, provider_name, None)
+    
+    def is_provider_configured(self, provider_name: str) -> bool:
+        """Check if the provider has been configured"""
+        provider = self.get_provider_config(provider_name)
+        return provider is not None and provider.is_configured()
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "version": "1.0.0",
+                "default_provider": "openai",
+                "default_model": "gpt-4",
+                "providers": {
+                    "openai": {
+                        "api_key": "sk-...",
+                        "api_base": "https://api.openai.com/v1"
+                    },
+                    "anthropic": {
+                        "api_key": "sk-ant-..."
+                    }
+                }
+            }
+        }

sourcebot/config/provider_config.py

@@ -0,0 +1,62 @@
+# src/sourcebot/config/provider_config.py
+from pydantic import Field
+from typing import Optional, Dict
+from .base import Base
+
+
+class ProviderConfig(Base):
+    """LLM provider configuration."""
+    
+    api_key: str = Field(default="", description="API key")
+    api_base: str = Field(default="", description="API base URL")
+    temperature: float = 0.7
+    extra_headers: Optional[Dict[str, str]] = Field(default=None, description="Custom request headers")
+    timeout: Optional[int] = Field(default=None, description="Timeout (seconds)")
+    max_retries: int = Field(default=3, description="Maximum number of retries")
+    
+    def is_configured(self) -> bool:
+        """Check if it is configured"""
+        return bool(self.api_key)
+
+
+class ProvidersConfig(Base):
+    """Configuration for LLM providers."""
+    
+    custom: ProviderConfig = Field(default_factory=ProviderConfig, description="Custom OpenAI compatible endpoints")
+    anthropic: ProviderConfig = Field(default_factory=ProviderConfig, description="Anthropic Claude")
+    openai: ProviderConfig = Field(default_factory=ProviderConfig, description="OpenAI")
+    openrouter: ProviderConfig = Field(default_factory=ProviderConfig, description="OpenRouter")
+    
+
+    deepseek: ProviderConfig = Field(default_factory=ProviderConfig, description="DeepSeek")
+    zhipu: ProviderConfig = Field(default_factory=ProviderConfig, description="zhipu")
+    dashscope: ProviderConfig = Field(default_factory=ProviderConfig, description="dashscope")
+    moonshot: ProviderConfig = Field(default_factory=ProviderConfig, description="Moonshot AI")
+    minimax: ProviderConfig = Field(default_factory=ProviderConfig, description="MiniMax")
+    
+    aihubmix: ProviderConfig = Field(default_factory=ProviderConfig, description="AiHubMix API gateway")
+    siliconflow: ProviderConfig = Field(default_factory=ProviderConfig, description="SiliconFlow")
+    volcengine: ProviderConfig = Field(default_factory=ProviderConfig, description="volcengine")
+    
+ 
+    groq: ProviderConfig = Field(default_factory=ProviderConfig, description="Groq")
+    vllm: ProviderConfig = Field(default_factory=ProviderConfig, description="vLLM")
+    gemini: ProviderConfig = Field(default_factory=ProviderConfig, description="Google Gemini")
+    
+    # OAuth
+    openai_codex: ProviderConfig = Field(default_factory=ProviderConfig, description="OpenAI Codex (OAuth)")
+    github_copilot: ProviderConfig = Field(default_factory=ProviderConfig, description="Github Copilot (OAuth)")
+    
+    def get_provider(self, name: str) -> ProviderConfig:
+        """Retrieve provider configuration for a specified name"""
+        return getattr(self, name, None)
+    
+    def list_configured(self) -> list[str]:
+        """List all configured providers"""
+        return [name for name, provider in self if provider.is_configured()]
+    
+    def __iter__(self):
+        """Iterate through all providers"""
+        for field_name in self.model_fields:
+            if field_name not in ['model_config']:
+                yield field_name, getattr(self, field_name)

sourcebot/config/workspace_config.py

@@ -0,0 +1,106 @@
+# sourcebot/config/workspace_config.py
+from pathlib import Path
+from pydantic import Field, field_validator
+from typing import Optional, List, Dict, Any
+from datetime import datetime
+
+from .base import Base
+
+
+class ModelConfig(Base):
+    """Model configuration"""
+    provider: str = Field(..., description="Provider name")
+    model: str = Field(..., description="Model name")
+    temperature: float = Field(default=0.7, ge=0.0, le=2.0, description="Temperature")
+    max_tokens: int = Field(default=2000, gt=0, description="Maximum tokens")
+    top_p: float = Field(default=1.0, ge=0.0, le=1.0, description="Top-p")
+    
+    @field_validator('provider')
+    def validate_provider(cls, v):
+        """Validate provider name"""
+        # Only basic validation here, specific availability is determined by global configuration
+        if not v or not isinstance(v, str):
+            raise ValueError("Provider name must be a non-empty string")
+        return v.lower()
+
+
+class WorkspaceConfig(Base):
+    """Workspace configuration - saved independently for each project"""
+    
+    # Project information
+    project_name: str = Field(..., description="Project name")
+    project_root: str = Field(..., description="Project root directory")
+    project_rules: str = Field("", description="Project rules keywords")
+    project_skill: str = Field("", description="Project skill keywords")
+    docker_image: str = Field("python:3.11-slim", description="docker image")
+    created_at: str = Field(default_factory=lambda: datetime.now().isoformat(), description="Creation time")
+    
+    # Model configuration
+    models: Dict[str, ModelConfig] = Field(
+        default_factory=lambda: {
+        "main_agent": ModelConfig(
+            provider = "dashscope",
+            model = "qwen3.5-plus",
+            temperature = 0.7,
+            max_tokens = 2000,  
+            top_p = 1.0
+        ),
+        "sub_agent": ModelConfig(
+            provider = "dashscope",
+            model = "qwen3.5-plus",
+            temperature = 0.7,
+            max_tokens = 2000,
+            top_p = 1.0
+        )
+        },
+
+    )
+    
+    # Workspace settings
+    context_files: List[str] = Field(default_factory=list, description="Context file patterns")
+    ignore_patterns: List[str] = Field(
+        default_factory=lambda: ["**/__pycache__", "**/.git", "**/.idea", "**/*.pyc"],
+        description="Ignore file patterns"
+    )
+    max_file_size: int = Field(default=10 * 1024 * 1024, description="Maximum file size (bytes)")
+    
+    # Custom settings
+    settings: Dict[str, Any] = Field(default_factory=dict, description="Custom settings")
+    
+    def get_model_config(self, model_name: Optional[str] = None) -> Optional[ModelConfig]:
+        """Get model configuration"""
+        if model_name is None:
+            model_name = self.default_model
+        return self.models.get(model_name)
+    
+    def add_model(self, name: str, provider: str, model: str, **kwargs):
+        """Add model configuration"""
+        self.models[name] = ModelConfig(provider=provider, model=model, **kwargs)
+    
+    @property
+    def root_path(self) -> Path:
+        """Get project root directory path"""
+        return Path(self.project_root).expanduser().resolve()
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "project_name": "my-ai-project",
+                "project_root": "/home/user/projects/my-ai-project",
+                "project_rules": "python", 
+                "project_skill": "python",
+                "docker_image": "python:3.11-slim",
+                "models": {
+                    "gpt4": {
+                        "provider": "openai",
+                        "model": "gpt-4",
+                        "temperature": 0.7
+                    },
+                    "claude": { # TODO: Anthropic compatible
+                        "provider": "anthropic",
+                        "model": "claude-3-opus-20240229",
+                        "temperature": 0.5
+                    }
+                }
+            }
+        }

sourcebot/context/__init__.py

@@ -0,0 +1,5 @@
+from sourcebot.context.context_builder import ContextBuilder
+from sourcebot.context.identity import get_identity
+from sourcebot.context.message_builder import MessageBuilder
+# from sourcebot.context.rules_loader import RulesLoader
+__all__ = ["ContextBuilder", "get_identity", "MessageBuilder"]