Update config_provider.py

config_provider.py

@@ -1,21 +1,21 @@
 """
-Flare – ConfigProvider
+Flare – ConfigProvider (with Provider Abstraction and Multi-language Support)
 """
 
 from __future__ import annotations
 import json, os, threading
 from pathlib import Path
 from typing import Any, Dict, List, Optional
+from datetime import datetime
 import commentjson
-from datetime import datetime, timezone
 
 from pydantic import BaseModel, Field, HttpUrl, ValidationError
 from utils import log
 from encryption_utils import decrypt
 
-# ============== Provider Configs ==============
+# ===================== New Provider Classes =====================
 class ProviderConfig(BaseModel):
-    """Configuration for available providers (LLM, TTS, STT)"""
+    """Provider definition with requirements"""
     type: str = Field(..., pattern=r"^(llm|tts|stt)$")
     name: str
     display_name: str
@@ -25,38 +25,42 @@ class ProviderConfig(BaseModel):
     description: Optional[str] = None
 
 class ProviderSettings(BaseModel):
-    """Provider-specific settings"""
+    """Runtime provider settings"""
     name: str
     api_key: Optional[str] = None
     endpoint: Optional[str] = None
     settings: Dict[str, Any] = Field(default_factory=dict)
 
-# ============== Parameter Collection ==============
-class ParameterCollectionConfig(BaseModel):
-    """Configuration for parameter collection behavior"""
-    max_params_per_question: int = Field(2, ge=1, le=5)
-    retry_unanswered: bool = True
-    collection_prompt: str = ""
-    
-    class Config:
-        extra = "allow"
+class LocalizedCaption(BaseModel):
+    """Multi-language caption support"""
+    locale_code: str
+    caption: str
+
+class LocalizedExample(BaseModel):
+    """Multi-language example support"""
+    locale_code: str
+    example: str
 
-# ============== Global Config ==============
+# ===================== Global Configuration =====================
 class GlobalConfig(BaseModel):
-    # Provider configurations
+    # Provider settings (replaces work_mode, cloud_token, spark_endpoint)
     llm_provider: ProviderSettings
-    tts_provider: ProviderSettings
-    stt_provider: ProviderSettings
+    tts_provider: ProviderSettings = ProviderSettings(name="no_tts")
+    stt_provider: ProviderSettings = ProviderSettings(name="no_stt")
     
     # Available providers
-    providers: List[ProviderConfig] = Field(default_factory=list)
+    providers: List[ProviderConfig] = []
     
-    # Users
+    # User management
     users: List["UserConfig"] = []
     
+    # Helper methods for providers
     def get_provider_config(self, provider_type: str, provider_name: str) -> Optional[ProviderConfig]:
-        """Get configuration for a specific provider"""
-        return next((p for p in self.providers if p.type == provider_type and p.name == provider_name), None)
+        """Get provider configuration by type and name"""
+        return next(
+            (p for p in self.providers if p.type == provider_type and p.name == provider_name),
+            None
+        )
     
     def get_providers_by_type(self, provider_type: str) -> List[ProviderConfig]:
         """Get all providers of a specific type"""
@@ -64,31 +68,31 @@ class GlobalConfig(BaseModel):
     
     def get_plain_api_key(self, provider_type: str) -> Optional[str]:
         """Get decrypted API key for a provider type"""
-        provider = getattr(self, f"{provider_type}_provider", None)
-        if not provider or not provider.api_key:
-            return None
-            
-        raw_key = provider.api_key
-        # If it starts with enc:, decrypt it
-        if raw_key.startswith("enc:"):
-            log(f"🔓 Decrypting {provider_type} API key...")
-            decrypted = decrypt(raw_key)
-            log(f"🔓 {provider_type} key decrypted: {'***' + decrypted[-4:] if decrypted else 'None'}")
-            return decrypted
-        
-        log(f"🔑 {provider_type} key/path: {'***' + raw_key[-4:] if raw_key else 'None'}")
-        return raw_key
+        provider_map = {
+            "llm": self.llm_provider,
+            "tts": self.tts_provider,
+            "stt": self.stt_provider
+        }
+        provider = provider_map.get(provider_type)
+        if provider and provider.api_key:
+            return decrypt(provider.api_key) if provider.api_key else None
+        return None
     
-    class Config:
-        extra = "allow"
+    # Backward compatibility helpers
+    def is_cloud_mode(self) -> bool:
+        """Check if running in cloud mode (HuggingFace)"""
+        return bool(os.environ.get("SPACE_ID"))
+    
+    def is_gpt_mode(self) -> bool:
+        """Check if using GPT provider"""
+        return self.llm_provider.name.startswith("gpt4o")
 
-# ============== User Config ==============
+# ===================== Other Config Classes =====================
 class UserConfig(BaseModel):
     username: str
     password_hash: str
     salt: str
 
-# ============== Retry / Proxy ==============
 class RetryConfig(BaseModel):
     retry_count: int = Field(3, alias="max_attempts")
     backoff_seconds: int = 2
@@ -98,7 +102,6 @@ class ProxyConfig(BaseModel):
     enabled: bool = True
     url: HttpUrl
 
-# ============== API & Auth ==============
 class APIAuthConfig(BaseModel):
     enabled: bool = False
     token_endpoint: Optional[HttpUrl] = None
@@ -122,24 +125,21 @@ class APIConfig(BaseModel):
     proxy: Optional[str | ProxyConfig] = None
     auth: Optional[APIAuthConfig] = None
     response_prompt: Optional[str] = None
+    response_mappings: List[Dict[str, Any]] = []
+    deleted: bool = False
+    last_update_date: Optional[str] = None
+    last_update_user: Optional[str] = None
+    created_date: Optional[str] = None
+    created_by: Optional[str] = None
 
     class Config:
         extra = "allow"
         populate_by_name = True
 
-# ============== Localized Content ==============
-class LocalizedCaption(BaseModel):
-    locale_code: str
-    caption: str
-
-class LocalizedExample(BaseModel):
-    locale_code: str
-    example: str
-
-# ============== Intent / Param ==============
+# ===================== Intent / Parameter =====================
 class ParameterConfig(BaseModel):
     name: str
-    caption: List[LocalizedCaption]  # Multi-language captions
+    caption: List[LocalizedCaption] = []  # Multi-language captions
     type: str = Field(..., pattern=r"^(int|float|bool|str|string|date)$")
     required: bool = True
     variable_name: str
@@ -147,6 +147,13 @@ class ParameterConfig(BaseModel):
     validation_regex: Optional[str] = None
     invalid_prompt: Optional[str] = None
     type_error_prompt: Optional[str] = None
+
+    def canonical_type(self) -> str:
+        if self.type == "string":
+            return "str"
+        elif self.type == "date":
+            return "str"  # Store dates as strings in ISO format
+        return self.type
     
     def get_caption_for_locale(self, locale_code: str, default_locale: str = "tr") -> str:
         """Get caption for specific locale with fallback"""
@@ -155,24 +162,24 @@ class ParameterConfig(BaseModel):
         if caption:
             return caption
         
+        # Try language code only (e.g., "tr" from "tr-TR")
+        lang_code = locale_code.split("-")[0]
+        caption = next((c.caption for c in self.caption if c.locale_code.startswith(lang_code)), None)
+        if caption:
+            return caption
+        
         # Try default locale
-        caption = next((c.caption for c in self.caption if c.locale_code == default_locale), None)
+        caption = next((c.caption for c in self.caption if c.locale_code.startswith(default_locale)), None)
         if caption:
             return caption
         
-        # Return first available or parameter name
+        # Return first available or name
         return self.caption[0].caption if self.caption else self.name
 
-    def canonical_type(self) -> str:
-        if self.type == "string":
-            return "str"
-        elif self.type == "date":
-            return "str"  # Store dates as strings in ISO format
-        return self.type
-
 class IntentConfig(BaseModel):
     name: str
     caption: Optional[str] = ""
+    # Removed locale field - will use project's locale settings
     dependencies: List[str] = []
     examples: List[LocalizedExample] = []  # Multi-language examples
     detection_prompt: Optional[str] = None
@@ -180,15 +187,27 @@ class IntentConfig(BaseModel):
     action: str
     fallback_timeout_prompt: Optional[str] = None
     fallback_error_prompt: Optional[str] = None
-    
-    def get_examples_for_locale(self, locale_code: str) -> List[str]:
-        """Get examples for specific locale"""
-        return [ex.example for ex in self.examples if ex.locale_code == locale_code]
 
     class Config:
         extra = "allow"
+    
+    def get_examples_for_locale(self, locale_code: str) -> List[str]:
+        """Get examples for specific locale"""
+        # Try exact match
+        examples = [e.example for e in self.examples if e.locale_code == locale_code]
+        if examples:
+            return examples
+        
+        # Try language code only
+        lang_code = locale_code.split("-")[0]
+        examples = [e.example for e in self.examples if e.locale_code.startswith(lang_code)]
+        if examples:
+            return examples
+        
+        # Return all examples if no locale match
+        return [e.example for e in self.examples]
 
-# ============== Version / Project ==============
+# ===================== Version / Project =====================
 class LLMConfig(BaseModel):
     repo_id: str
     generation_config: Dict[str, Any] = {}
@@ -197,11 +216,20 @@ class LLMConfig(BaseModel):
 
 class VersionConfig(BaseModel):
     id: int = Field(..., alias="version_number")
+    no: Optional[int] = None
     caption: Optional[str] = ""
+    description: Optional[str] = ""
     published: bool = False
+    deleted: bool = False
+    created_date: Optional[str] = None
+    created_by: Optional[str] = None
+    last_update_date: Optional[str] = None
+    last_update_user: Optional[str] = None
+    publish_date: Optional[str] = None
+    published_by: Optional[str] = None
     general_prompt: str
-    llm: Optional["LLMConfig"] = None  # Optional based on provider
-    intents: List["IntentConfig"]
+    llm: LLMConfig
+    intents: List[IntentConfig]
 
     class Config:
         extra = "allow"
@@ -211,20 +239,47 @@ class ProjectConfig(BaseModel):
     id: Optional[int] = None
     name: str
     caption: Optional[str] = ""
+    icon: Optional[str] = "folder"
+    description: Optional[str] = ""
     enabled: bool = True
-    default_locale: str = "tr"  # Changed from default_language
-    supported_locales: List[str] = ["tr"]  # Changed from supported_languages
     last_version_number: Optional[int] = None
+    version_id_counter: int = 1
     versions: List[VersionConfig]
+    # Language settings - changed from default_language/supported_languages
+    default_locale: str = "tr"
+    supported_locales: List[str] = ["tr"]
+    timezone: Optional[str] = "Europe/Istanbul"
+    region: Optional[str] = "tr-TR"
+    deleted: bool = False
+    created_date: Optional[str] = None
+    created_by: Optional[str] = None
+    last_update_date: Optional[str] = None
+    last_update_user: Optional[str] = None
 
     class Config:
         extra = "allow"
 
-# ============== Service Config ==============
+# ===================== Activity Log =====================
+class ActivityLogEntry(BaseModel):
+    timestamp: str
+    username: str
+    action: str
+    entity_type: str
+    entity_id: Optional[int] = None
+    entity_name: Optional[str] = None
+    details: Optional[str] = None
+
+# ===================== Service Config =====================
 class ServiceConfig(BaseModel):
     global_config: GlobalConfig = Field(..., alias="config")
     projects: List[ProjectConfig]
     apis: List[APIConfig]
+    activity_log: List[ActivityLogEntry] = []
+    
+    # Config level fields
+    project_id_counter: int = 1
+    last_update_date: Optional[str] = None
+    last_update_user: Optional[str] = None
 
     # runtime helpers (skip validation)
     _api_by_name: Dict[str, APIConfig] = {}
@@ -232,14 +287,50 @@ class ServiceConfig(BaseModel):
     def build_index(self):
         self._api_by_name = {a.name: a for a in self.apis}
 
-    def get_api(self, name: str) -> APIConfig | None:
+    def get_api(self, name: str) -> Optional[APIConfig]:
         return self._api_by_name.get(name)
+    
+    def to_jsonc_dict(self) -> dict:
+        """Convert to dict for saving to JSONC file"""
+        data = self.model_dump(by_alias=True, exclude={'_api_by_name'})
+        
+        # Convert API configs
+        for api in data.get('apis', []):
+            # Convert headers and body_template to JSON strings if needed
+            if 'headers' in api and isinstance(api['headers'], dict) and api['headers']:
+                api['headers'] = json.dumps(api['headers'], ensure_ascii=False)
+            if 'body_template' in api and isinstance(api['body_template'], dict) and api['body_template']:
+                api['body_template'] = json.dumps(api['body_template'], ensure_ascii=False)
+            
+            # Convert auth configs
+            if 'auth' in api and api['auth']:
+                if 'token_request_body' in api['auth'] and isinstance(api['auth']['token_request_body'], dict):
+                    api['auth']['body_template'] = api['auth']['token_request_body']
+                    del api['auth']['token_request_body']
+                if 'token_refresh_body' in api['auth'] and isinstance(api['auth']['token_refresh_body'], dict):
+                    api['auth']['token_refresh_body'] = json.dumps(api['auth']['token_refresh_body'], ensure_ascii=False)
+        
+        return data
+    
+    def save(self):
+        """Save configuration to file"""
+        config_path = Path(__file__).parent / "service_config.jsonc"
+        data = self.to_jsonc_dict()
+        
+        # Pretty print with indentation
+        json_str = json.dumps(data, ensure_ascii=False, indent=2)
+        
+        with open(config_path, 'w', encoding='utf-8') as f:
+            f.write(json_str)
+        
+        log("✅ Configuration saved to service_config.jsonc")
 
-# ============== Provider Singleton ==============
+# ===================== Provider Singleton =====================
 class ConfigProvider:
     _instance: Optional[ServiceConfig] = None
     _CONFIG_PATH = Path(__file__).parent / "service_config.jsonc"
     _lock = threading.Lock()
+    _environment_checked = False
 
     @classmethod
     def get(cls) -> ServiceConfig:
@@ -250,6 +341,10 @@ class ConfigProvider:
                 if cls._instance is None:
                     cls._instance = cls._load()
                     cls._instance.build_index()
+                    # Environment kontrolünü sadece ilk yüklemede yap
+                    if not cls._environment_checked:
+                        cls._check_environment_setup()
+                        cls._environment_checked = True
         return cls._instance
 
     @classmethod
@@ -260,21 +355,6 @@ class ConfigProvider:
             cls._instance = None
             return cls.get()
     
-    @classmethod
-    def update_config(cls, config_dict: dict):
-        """Update the current configuration with new values"""
-        if cls._instance is None:
-            cls.get()
-        
-        # Update global config
-        if 'config' in config_dict:
-            for key, value in config_dict['config'].items():
-                if hasattr(cls._instance.global_config, key):
-                    setattr(cls._instance.global_config, key, value)
-        
-        # Save to file
-        cls._instance.save()
-
     @classmethod
     def _load(cls) -> ServiceConfig:
         """Load configuration from service_config.jsonc"""
@@ -291,134 +371,532 @@ class ConfigProvider:
             if 'config' not in config_data:
                 config_data['config'] = {}
             
-            config_section = config_data['config']
-            
-            # Set defaults for missing fields if needed
-            if 'llm_provider' not in config_section:
-                config_section['llm_provider'] = {
-                    "name": "spark",
-                    "api_key": None,
-                    "endpoint": "http://localhost:7861",
-                    "settings": {}
-                }
-            
-            if 'tts_provider' not in config_section:
-                config_section['tts_provider'] = {
-                    "name": "no_tts",
-                    "api_key": None,
-                    "endpoint": None,
-                    "settings": {}
-                }
-                
-            if 'stt_provider' not in config_section:
-                config_section['stt_provider'] = {
-                    "name": "no_stt",
-                    "api_key": None,
-                    "endpoint": None,
-                    "settings": {}
-                }
-            
-            if 'providers' not in config_section:
-                config_section['providers'] = []
-            
-            config_section.setdefault('users', [])
-            
-            # Convert string body/headers to dict if needed
-            for api in config_data.get('apis', []):
-                if isinstance(api.get('headers'), str):
-                    try:
-                        api['headers'] = json.loads(api['headers'])
-                    except:
-                        api['headers'] = {}
-                
-                if isinstance(api.get('body_template'), str):
-                    try:
-                        api['body_template'] = json.loads(api['body_template'])
-                    except:
-                        api['body_template'] = {}
-                
-                # Handle auth section
-                if api.get('auth'):
-                    auth = api['auth']
-                    if isinstance(auth.get('token_request_body'), str):
+            # Parse API configs specially
+            if 'apis' in config_data:
+                for api in config_data['apis']:
+                    # Parse JSON string fields
+                    if 'headers' in api and isinstance(api['headers'], str):
                         try:
-                            auth['token_request_body'] = json.loads(auth['token_request_body'])
+                            api['headers'] = json.loads(api['headers'])
                         except:
-                            auth['token_request_body'] = {}
-                    if isinstance(auth.get('token_refresh_body'), str):
+                            api['headers'] = {}
+                    
+                    if 'body_template' in api and isinstance(api['body_template'], str):
                         try:
-                            auth['token_refresh_body'] = json.loads(auth['token_refresh_body'])
+                            api['body_template'] = json.loads(api['body_template'])
                         except:
-                            auth['token_refresh_body'] = {}
+                            api['body_template'] = {}
+                    
+                    # Parse auth configs
+                    if 'auth' in api and api['auth']:
+                        if 'body_template' in api['auth'] and isinstance(api['auth']['body_template'], str):
+                            try:
+                                api['auth']['token_request_body'] = json.loads(api['auth']['body_template'])
+                            except:
+                                api['auth']['token_request_body'] = {}
             
-            # Parse and validate
+            # Load and validate
             cfg = ServiceConfig.model_validate(config_data)
-            
             log("✅ Configuration loaded successfully")
             return cfg
             
-        except FileNotFoundError:
-            log(f"❌ Config file not found: {cls._CONFIG_PATH}")
-            raise
-        except (commentjson.JSONLibraryException, ValidationError) as e:
-            log(f"❌ Config parsing/validation error: {e}")
-            raise
         except Exception as e:
-            log(f"❌ Unexpected error loading config: {e}")
+            log(f"❌ Error loading config: {e}")
             raise
     
-    # ============== Environment Methods ==============
     @classmethod
-    def update_environment(cls, env_data: dict, username: str):
+    def _check_environment_setup(cls):
+        """Check if environment is properly configured"""
+        if not cls._instance:
+            return
+            
+        cfg = cls._instance.global_config
+        
+        # Check LLM provider
+        if not cfg.llm_provider or not cfg.llm_provider.name:
+            log("⚠️ WARNING: No LLM provider configured")
+            return
+        
+        provider_config = cfg.get_provider_config("llm", cfg.llm_provider.name)
+        if not provider_config:
+            log(f"⚠️ WARNING: Unknown LLM provider: {cfg.llm_provider.name}")
+            return
+        
+        # Check requirements
+        if provider_config.requires_api_key and not cfg.llm_provider.api_key:
+            log(f"⚠️ WARNING: {provider_config.display_name} requires API key but none configured")
+        
+        if provider_config.requires_endpoint and not cfg.llm_provider.endpoint:
+            log(f"⚠️ WARNING: {provider_config.display_name} requires endpoint but none configured")
+        
+        log(f"✅ LLM Provider: {provider_config.display_name}")
+    
+    # ===================== CRUD Operations =====================
+    @classmethod
+    def add_activity_log(cls, username: str, action: str, entity_type: str, 
+                        entity_id: Optional[int] = None, entity_name: Optional[str] = None,
+                        details: Optional[str] = None):
+        """Add activity log entry"""
+        if cls._instance is None:
+            cls.get()
+        
+        entry = ActivityLogEntry(
+            timestamp=datetime.now().isoformat() + "Z",
+            username=username,
+            action=action,
+            entity_type=entity_type,
+            entity_id=entity_id,
+            entity_name=entity_name,
+            details=details
+        )
+        
+        cls._instance.activity_log.append(entry)
+        
+        # Keep only last 1000 entries
+        if len(cls._instance.activity_log) > 1000:
+            cls._instance.activity_log = cls._instance.activity_log[-1000:]
+    
+    @classmethod
+    def update_environment(cls, update_data: dict, username: str) -> None:
         """Update environment configuration"""
         if cls._instance is None:
             cls.get()
         
-        cfg = cls._instance
-        timestamp = _get_iso_timestamp()
+        config = cls._instance.global_config
+        
+        # Update provider settings
+        if 'llm_provider' in update_data:
+            llm_data = update_data['llm_provider']
+            if 'api_key' in llm_data and llm_data['api_key'] and not llm_data['api_key'].startswith('enc:'):
+                from encryption_utils import encrypt
+                llm_data['api_key'] = encrypt(llm_data['api_key'])
+            config.llm_provider = ProviderSettings(**llm_data)
+        
+        if 'tts_provider' in update_data:
+            tts_data = update_data['tts_provider']
+            if 'api_key' in tts_data and tts_data['api_key'] and not tts_data['api_key'].startswith('enc:'):
+                from encryption_utils import encrypt
+                tts_data['api_key'] = encrypt(tts_data['api_key'])
+            config.tts_provider = ProviderSettings(**tts_data)
+        
+        if 'stt_provider' in update_data:
+            stt_data = update_data['stt_provider']
+            if 'api_key' in stt_data and stt_data['api_key'] and not stt_data['api_key'].startswith('enc:'):
+                from encryption_utils import encrypt
+                stt_data['api_key'] = encrypt(stt_data['api_key'])
+            config.stt_provider = ProviderSettings(**stt_data)
+        
+        # Update metadata
+        cls._instance.last_update_date = datetime.now().isoformat() + "Z"
+        cls._instance.last_update_user = username
+        
+        # Add activity log
+        cls.add_activity_log(username, "UPDATE_ENVIRONMENT", "environment", None, None, 
+                           f"Updated providers: LLM={config.llm_provider.name}, TTS={config.tts_provider.name}, STT={config.stt_provider.name}")
+        
+        # Save
+        cls._instance.save()
+    
+    @classmethod
+    def get_project(cls, project_id: int) -> Optional[ProjectConfig]:
+        """Get project by ID"""
+        if cls._instance is None:
+            cls.get()
+        
+        return next((p for p in cls._instance.projects if p.id == project_id), None)
+    
+    @classmethod
+    def create_project(cls, project_data: dict, username: str) -> ProjectConfig:
+        """Create new project with initial version"""
+        if cls._instance is None:
+            cls.get()
+        
+        # Check name uniqueness
+        if any(p.name == project_data['name'] for p in cls._instance.projects if not p.deleted):
+            raise ValueError(f"Project name '{project_data['name']}' already exists")
+        
+        # Create project
+        new_project = ProjectConfig(
+            id=cls._instance.project_id_counter,
+            name=project_data['name'],
+            caption=project_data.get('caption', ''),
+            icon=project_data.get('icon', 'folder'),
+            description=project_data.get('description', ''),
+            enabled=True,
+            default_locale=project_data.get('default_locale', 'tr'),
+            supported_locales=project_data.get('supported_locales', ['tr']),
+            timezone=project_data.get('timezone', 'Europe/Istanbul'),
+            region=project_data.get('region', 'tr-TR'),
+            version_id_counter=1,
+            versions=[],
+            deleted=False,
+            created_date=datetime.now().isoformat() + "Z",
+            created_by=username,
+            last_update_date=datetime.now().isoformat() + "Z",
+            last_update_user=username
+        )
+        
+        # Create initial version
+        initial_version = VersionConfig(
+            id=1,
+            version_number=1,
+            no=1,
+            caption="Version 1",
+            description="Initial version",
+            published=False,
+            deleted=False,
+            created_date=datetime.now().isoformat() + "Z",
+            created_by=username,
+            last_update_date=datetime.now().isoformat() + "Z",
+            last_update_user=username,
+            general_prompt="You are a helpful assistant.",
+            llm=LLMConfig(
+                repo_id="",
+                generation_config={
+                    "max_new_tokens": 512,
+                    "temperature": 0.7,
+                    "top_p": 0.95
+                }
+            ),
+            intents=[]
+        )
+        
+        new_project.versions.append(initial_version)
+        new_project.last_version_number = 1
+        
+        # Add to config
+        cls._instance.projects.append(new_project)
+        cls._instance.project_id_counter += 1
         
-        # Update provider configurations
-        if 'llm_provider' in env_data:
-            cfg.global_config.llm_provider = ProviderSettings(**env_data['llm_provider'])
-        if 'tts_provider' in env_data:
-            cfg.global_config.tts_provider = ProviderSettings(**env_data['tts_provider'])
-        if 'stt_provider' in env_data:
-            cfg.global_config.stt_provider = ProviderSettings(**env_data['stt_provider'])
+        # Add activity log
+        cls.add_activity_log(username, "CREATE_PROJECT", "project", new_project.id, new_project.name)
         
         # Save
-        cls._save()
+        cls._instance.save()
         
-        # Log activity
-        cls._log_activity("UPDATE_ENVIRONMENT", "environment", username=username)
+        return new_project
     
-    # ============== Save Method ==============
     @classmethod
-    def _save(cls):
-        """Save current config to file"""
+    def update_project(cls, project_id: int, update_data: dict, username: str) -> ProjectConfig:
+        """Update project"""
         if cls._instance is None:
-            return
+            cls.get()
         
-        with cls._lock:
-            config_dict = {
-                "config": cls._instance.global_config.model_dump(exclude_none=True),
-                "projects": [p.model_dump(by_alias=True) for p in cls._instance.projects],
-                "apis": [a.model_dump(by_alias=True) for a in cls._instance.apis]
-            }
-            
-            # Write to file
-            with open(cls._CONFIG_PATH, 'w', encoding='utf-8') as f:
-                f.write(commentjson.dumps(config_dict, indent=2, ensure_ascii=False))
-            
-            log("💾 Configuration saved")
+        project = cls.get_project(project_id)
+        if not project:
+            raise ValueError(f"Project not found: {project_id}")
+        
+        if project.deleted:
+            raise ValueError("Cannot update deleted project")
+        
+        # Update fields
+        if 'caption' in update_data:
+            project.caption = update_data['caption']
+        if 'icon' in update_data:
+            project.icon = update_data['icon']
+        if 'description' in update_data:
+            project.description = update_data['description']
+        if 'default_locale' in update_data:
+            project.default_locale = update_data['default_locale']
+        if 'supported_locales' in update_data:
+            project.supported_locales = update_data['supported_locales']
+        if 'timezone' in update_data:
+            project.timezone = update_data['timezone']
+        if 'region' in update_data:
+            project.region = update_data['region']
+        
+        # Update metadata
+        project.last_update_date = datetime.now().isoformat() + "Z"
+        project.last_update_user = username
+        
+        # Add activity log
+        cls.add_activity_log(username, "UPDATE_PROJECT", "project", project.id, project.name)
+        
+        # Save
+        cls._instance.save()
+        
+        return project
     
-    # ============== Activity Logging ==============
     @classmethod
-    def _log_activity(cls, action: str, entity_type: str, entity_id: Any = None, 
-                     entity_name: str = None, username: str = "system", details: str = None):
-        """Log activity - placeholder for future implementation"""
-        log(f"📝 Activity: {action} on {entity_type} by {username}")
-
-# ============== Helper Functions ==============
-def _get_iso_timestamp() -> str:
-    """Get current timestamp in ISO format"""
-    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z"
+    def delete_project(cls, project_id: int, username: str) -> None:
+        """Soft delete project"""
+        if cls._instance is None:
+            cls.get()
+        
+        project = cls.get_project(project_id)
+        if not project:
+            raise ValueError(f"Project not found: {project_id}")
+        
+        project.deleted = True
+        project.last_update_date = datetime.now().isoformat() + "Z"
+        project.last_update_user = username
+        
+        # Add activity log
+        cls.add_activity_log(username, "DELETE_PROJECT", "project", project.id, project.name)
+        
+        # Save
+        cls._instance.save()
+    
+    @classmethod
+    def toggle_project(cls, project_id: int, username: str) -> bool:
+        """Toggle project enabled status"""
+        if cls._instance is None:
+            cls.get()
+        
+        project = cls.get_project(project_id)
+        if not project:
+            raise ValueError(f"Project not found: {project_id}")
+        
+        project.enabled = not project.enabled
+        project.last_update_date = datetime.now().isoformat() + "Z"
+        project.last_update_user = username
+        
+        # Add activity log
+        action = "ENABLE_PROJECT" if project.enabled else "DISABLE_PROJECT"
+        cls.add_activity_log(username, action, "project", project.id, project.name)
+        
+        # Save
+        cls._instance.save()
+        
+        return project.enabled
+    
+    @classmethod
+    def create_api(cls, api_data: dict, username: str) -> APIConfig:
+        """Create new API"""
+        if cls._instance is None:
+            cls.get()
+        
+        # Check name uniqueness
+        if any(a.name == api_data['name'] for a in cls._instance.apis if not a.deleted):
+            raise ValueError(f"API name '{api_data['name']}' already exists")
+        
+        # Create API
+        new_api = APIConfig(
+            name=api_data['name'],
+            url=api_data['url'],
+            method=api_data.get('method', 'GET'),
+            headers=api_data.get('headers', {}),
+            body_template=api_data.get('body_template', {}),
+            timeout_seconds=api_data.get('timeout_seconds', 10),
+            retry=RetryConfig(**api_data.get('retry', {})) if 'retry' in api_data else RetryConfig(),
+            proxy=api_data.get('proxy'),
+            auth=APIAuthConfig(**api_data.get('auth', {})) if api_data.get('auth') else None,
+            response_prompt=api_data.get('response_prompt'),
+            response_mappings=api_data.get('response_mappings', []),
+            deleted=False,
+            created_date=datetime.now().isoformat() + "Z",
+            created_by=username,
+            last_update_date=datetime.now().isoformat() + "Z",
+            last_update_user=username
+        )
+        
+        # Add to config
+        cls._instance.apis.append(new_api)
+        
+        # Rebuild index
+        cls._instance.build_index()
+        
+        # Add activity log
+        cls.add_activity_log(username, "CREATE_API", "api", None, new_api.name)
+        
+        # Save
+        cls._instance.save()
+        
+        return new_api
+    
+    @classmethod
+    def update_api(cls, api_name: str, update_data: dict, username: str) -> APIConfig:
+        """Update API"""
+        if cls._instance is None:
+            cls.get()
+        
+        api = next((a for a in cls._instance.apis if a.name == api_name and not a.deleted), None)
+        if not api:
+            raise ValueError(f"API not found: {api_name}")
+        
+        # Update fields
+        for field in ['url', 'method', 'headers', 'body_template', 'timeout_seconds', 
+                     'proxy', 'response_prompt', 'response_mappings']:
+            if field in update_data:
+                setattr(api, field, update_data[field])
+        
+        # Update retry config
+        if 'retry' in update_data:
+            api.retry = RetryConfig(**update_data['retry'])
+        
+        # Update auth config
+        if 'auth' in update_data:
+            if update_data['auth']:
+                api.auth = APIAuthConfig(**update_data['auth'])
+            else:
+                api.auth = None
+        
+        # Update metadata
+        api.last_update_date = datetime.now().isoformat() + "Z"
+        api.last_update_user = username
+        
+        # Add activity log
+        cls.add_activity_log(username, "UPDATE_API", "api", None, api.name)
+        
+        # Save
+        cls._instance.save()
+        
+        return api
+    
+    @classmethod
+    def delete_api(cls, api_name: str, username: str) -> None:
+        """Soft delete API"""
+        if cls._instance is None:
+            cls.get()
+        
+        api = next((a for a in cls._instance.apis if a.name == api_name and not a.deleted), None)
+        if not api:
+            raise ValueError(f"API not found: {api_name}")
+        
+        # Check if API is used in any intent
+        for project in cls._instance.projects:
+            if getattr(project, 'deleted', False):
+                continue
+                
+            for version in project.versions:
+                if getattr(version, 'deleted', False):
+                    continue
+                
+                for intent in version.intents:
+                    if intent.action == api_name:
+                        raise ValueError(f"API is used in intent '{intent.name}' in project '{project.name}' version {version.no}")
+        
+        api.deleted = True
+        api.last_update_date = datetime.now().isoformat() + "Z"
+        api.last_update_user = username
+        
+        # Add activity log
+        cls.add_activity_log(username, "DELETE_API", "api", None, api_name)
+        
+        # Save
+        cls._instance.save()
+    
+    @classmethod
+    def import_project(cls, project_data: dict, username: str) -> ProjectConfig:
+        """Import project from JSON"""
+        if cls._instance is None:
+            cls.get()
+        
+        # Validate structure
+        if "name" not in project_data:
+            raise ValueError("Invalid project data")
+        
+        # Create new project with imported data
+        imported_data = {
+            "name": project_data["name"],
+            "caption": project_data.get("caption", ""),
+            "icon": project_data.get("icon", "folder"),
+            "description": project_data.get("description", ""),
+            "default_locale": project_data.get("default_locale", "tr"),
+            "supported_locales": project_data.get("supported_locales", ["tr"])
+        }
+        
+        # Create project
+        new_project = cls.create_project(imported_data, username)
+        
+        # Clear default version
+        new_project.versions = []
+        
+        # Import versions
+        for idx, version_data in enumerate(project_data.get("versions", [])):
+            new_version = VersionConfig(
+                id=idx + 1,
+                version_number=idx + 1,
+                no=idx + 1,
+                caption=version_data.get("caption", f"Version {idx + 1}"),
+                description=version_data.get("description", ""),
+                published=False,
+                deleted=False,
+                created_date=datetime.now().isoformat() + "Z",
+                created_by=username,
+                last_update_date=datetime.now().isoformat() + "Z",
+                last_update_user=username,
+                general_prompt=version_data.get("general_prompt", ""),
+                llm=LLMConfig(**version_data.get("llm", {})) if version_data.get("llm") else LLMConfig(
+                    repo_id="",
+                    generation_config={
+                        "max_new_tokens": 512,
+                        "temperature": 0.7,
+                        "top_p": 0.95
+                    }
+                ),
+                intents=[]
+            )
+            
+            # Import intents
+            for intent_data in version_data.get("intents", []):
+                intent = IntentConfig(
+                    name=intent_data.get("name", ""),
+                    caption=intent_data.get("caption", ""),
+                    detection_prompt=intent_data.get("detection_prompt", ""),
+                    action=intent_data.get("action", ""),
+                    fallback_timeout_prompt=intent_data.get("fallback_timeout_prompt"),
+                    fallback_error_prompt=intent_data.get("fallback_error_prompt"),
+                    examples=[],
+                    parameters=[]
+                )
+                
+                # Convert examples
+                if "examples" in intent_data:
+                    if isinstance(intent_data["examples"], list):
+                        for example in intent_data["examples"]:
+                            if isinstance(example, str):
+                                # Old format - use project default locale
+                                intent.examples.append(LocalizedExample(
+                                    locale_code=new_project.default_locale,
+                                    example=example
+                                ))
+                            elif isinstance(example, dict):
+                                # New format
+                                intent.examples.append(LocalizedExample(**example))
+                
+                # Convert parameters
+                for param_data in intent_data.get("parameters", []):
+                    param = ParameterConfig(
+                        name=param_data.get("name", ""),
+                        type=param_data.get("type", "str"),
+                        required=param_data.get("required", True),
+                        variable_name=param_data.get("variable_name", param_data.get("name", "")),
+                        extraction_prompt=param_data.get("extraction_prompt"),
+                        validation_regex=param_data.get("validation_regex"),
+                        invalid_prompt=param_data.get("invalid_prompt"),
+                        type_error_prompt=param_data.get("type_error_prompt"),
+                        caption=[]
+                    )
+                    
+                    # Convert caption
+                    if "caption" in param_data:
+                        if isinstance(param_data["caption"], str):
+                            # Old format
+                            param.caption.append(LocalizedCaption(
+                                locale_code=new_project.default_locale,
+                                caption=param_data["caption"]
+                            ))
+                        elif isinstance(param_data["caption"], list):
+                            # New format
+                            for cap in param_data["caption"]:
+                                param.caption.append(LocalizedCaption(**cap))
+                    
+                    intent.parameters.append(param)
+                
+                new_version.intents.append(intent)
+            
+            new_project.versions.append(new_version)
+            new_project.last_version_number = new_version.id
+        
+        # Update project counter if needed
+        new_project.version_id_counter = len(new_project.versions) + 1
+        
+        # Save
+        cls._instance.save()
+        
+        # Add activity log
+        cls.add_activity_log(username, "IMPORT_PROJECT", "project", new_project.id, new_project.name,
+                           f"Imported with {len(new_project.versions)} versions")
+        
+        return new_project