Update config_provider.py

config_provider.py

@@ -1,854 +1,848 @@
-"""
-Thread-Safe Configuration Provider for Flare Platform
-"""
-import threading
-import os
-import json
-import commentjson
-from typing import Optional, Dict, List, Any
-from datetime import datetime
-from pathlib import Path
-import tempfile
-import shutil
-from utils import get_current_timestamp, normalize_timestamp, timestamps_equal
-
-from config_models import (
-    ServiceConfig, GlobalConfig, ProjectConfig, VersionConfig, 
-    IntentConfig, APIConfig, ActivityLogEntry, ParameterConfig,
-    LLMConfiguration, GenerationConfig
-)
-from logger import log_info, log_error, log_warning, log_debug, LogTimer
-from exceptions import (
-    RaceConditionError, ConfigurationError, ResourceNotFoundError,
-    DuplicateResourceError, ValidationError
-)
-from encryption_utils import encrypt, decrypt
-
-class ConfigProvider:
-    """Thread-safe singleton configuration provider"""
-    
-    _instance: Optional[ServiceConfig] = None
-    _lock = threading.RLock()  # Reentrant lock for nested calls
-    _file_lock = threading.Lock()  # Separate lock for file operations
-    _CONFIG_PATH = Path(__file__).parent / "service_config.jsonc"
-
-    @staticmethod
-    def _normalize_date(date_str: Optional[str]) -> str:
-        """Normalize date string for comparison"""
-        if not date_str:
-            return ""
-        return date_str.replace(' ', 'T').replace('+00:00', 'Z').replace('.000Z', 'Z')
-
-    @classmethod
-    def get(cls) -> ServiceConfig:
-        """Get cached configuration - thread-safe"""
-        if cls._instance is None:
-            with cls._lock:
-                # Double-checked locking pattern
-                if cls._instance is None:
-                    with LogTimer("config_load"):
-                        cls._instance = cls._load()
-                        cls._instance.build_index()
-                        log_info("Configuration loaded successfully")
-        return cls._instance
+import { Component, Inject, OnInit } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { FormBuilder, FormGroup, Validators, ReactiveFormsModule, FormArray, FormsModule } from '@angular/forms';  
+import { MatDialogRef, MAT_DIALOG_DATA, MatDialogModule, MatDialog } from '@angular/material/dialog';
+import { MatTabsModule } from '@angular/material/tabs';
+import { MatFormFieldModule } from '@angular/material/form-field';
+import { MatInputModule } from '@angular/material/input';
+import { MatSelectModule } from '@angular/material/select';
+import { MatCheckboxModule } from '@angular/material/checkbox';
+import { MatButtonModule } from '@angular/material/button';
+import { MatIconModule } from '@angular/material/icon';
+import { MatSnackBar, MatSnackBarModule } from '@angular/material/snack-bar';
+import { MatTableModule } from '@angular/material/table';
+import { MatChipsModule } from '@angular/material/chips';
+import { MatExpansionModule } from '@angular/material/expansion';
+import { MatDividerModule } from '@angular/material/divider';
+import { MatProgressBarModule } from '@angular/material/progress-bar';
+import { MatListModule } from '@angular/material/list';
+import { MatProgressSpinnerModule } from '@angular/material/progress-spinner';
+import { MatBadgeModule } from '@angular/material/badge';
+import { ApiService, Project, Version } from '../../services/api.service';
+import { LocaleManagerService } from '../../services/locale-manager.service';
+import ConfirmDialogComponent from '../confirm-dialog/confirm-dialog.component';
+
+// Interfaces for multi-language support
+interface LocalizedExample {
+  locale_code: string;
+  example: string;
+}
+
+interface LocalizedCaption {
+  locale_code: string;
+  caption: string;
+}
+
+interface Locale {
+  code: string;
+  name: string;
+}
+
+@Component({
+  selector: 'app-version-edit-dialog',
+  standalone: true,
+  imports: [
+    CommonModule,
+    ReactiveFormsModule,
+    FormsModule,
+    MatDialogModule,
+    MatTabsModule,
+    MatFormFieldModule,
+    MatInputModule,
+    MatSelectModule,
+    MatCheckboxModule,
+    MatButtonModule,
+    MatIconModule,
+    MatSnackBarModule,
+    MatTableModule,
+    MatChipsModule,
+    MatExpansionModule,
+    MatDividerModule,
+    MatProgressBarModule,
+    MatListModule,
+    MatProgressSpinnerModule,
+    MatBadgeModule
+  ],
+  templateUrl: './version-edit-dialog.component.html',
+  styleUrls: ['./version-edit-dialog.component.scss']
+})
+export default class VersionEditDialogComponent implements OnInit {
+  project: Project;
+  versions: Version[] = [];
+  selectedVersion: Version | null = null;
+  versionForm!: FormGroup;
+  
+  loading = false;
+  saving = false;
+  publishing = false;
+  creating = false;
+  isDirty = false;
+  testing = false;
+  
+  selectedTabIndex = 0;
+  testUserMessage = '';
+  testResult: any = null;
+  
+  // Multi-language support
+  selectedExampleLocale: string = 'tr';
+  availableLocales: Locale[] = [];
+
+  constructor(
+    private fb: FormBuilder,
+    private apiService: ApiService,
+    private localeService: LocaleManagerService,
+    private snackBar: MatSnackBar,
+    private dialog: MatDialog,
+    public dialogRef: MatDialogRef<VersionEditDialogComponent>,
+    @Inject(MAT_DIALOG_DATA) public data: any
+  ) {
+    this.project = data.project;
+    this.versions = [...this.project.versions].sort((a, b) => b.no - a.no);
+    this.selectedExampleLocale = this.project.default_locale || 'tr';
+  }
+
+  ngOnInit() {
+    this.initializeForm();
+    this.loadAvailableLocales();
     
-    @classmethod
-    def reload(cls) -> ServiceConfig:
-        """Force reload configuration from file"""
-        with cls._lock:
-            log_info("Reloading configuration...")
-            cls._instance = None
-            return cls.get()
+    // Select the latest unpublished version or the latest version
+    const unpublished = this.versions.find(v => !v.published);
+    this.selectedVersion = unpublished || this.versions[0] || null;
     
-    @classmethod
-    def _load(cls) -> ServiceConfig:
-        """Load configuration from file"""
-        try:
-            if not cls._CONFIG_PATH.exists():
-                raise ConfigurationError(
-                    f"Config file not found: {cls._CONFIG_PATH}",
-                    config_key="service_config.jsonc"
-                )
-            
-            with open(cls._CONFIG_PATH, 'r', encoding='utf-8') as f:
-                config_data = commentjson.load(f)
-            
-            # Debug: İlk project'in tarihini kontrol et
-            if 'projects' in config_data and len(config_data['projects']) > 0:
-                first_project = config_data['projects'][0]
-                log_debug(f"🔍 Raw project data - last_update_date: {first_project.get('last_update_date')}")
-            
-            # Ensure required fields
-            if 'config' not in config_data:
-                config_data['config'] = {}
-            
-            # Parse API configs (handle JSON strings)
-            if 'apis' in config_data:
-                cls._parse_api_configs(config_data['apis'])
-            
-            # Validate and create model
-            cfg = ServiceConfig.model_validate(config_data)
-            
-            # Debug: Model'e dönüştükten sonra kontrol et
-            if cfg.projects and len(cfg.projects) > 0:
-                log_debug(f"🔍 Parsed project - last_update_date: {cfg.projects[0].last_update_date}")
-                log_debug(f"🔍 Type: {type(cfg.projects[0].last_update_date)}")
-            
-            log_debug(
-                "Configuration loaded",
-                projects=len(cfg.projects),
-                apis=len(cfg.apis),
-                users=len(cfg.global_config.users)
-            )
-            
-            return cfg
-        
-        except Exception as e:
-            log_error(f"Error loading config", error=str(e), path=str(cls._CONFIG_PATH))
-            raise ConfigurationError(f"Failed to load configuration: {e}")
-    
-    @classmethod
-    def _parse_api_configs(cls, apis: List[Dict[str, Any]]) -> None:
-        """Parse JSON string fields in API configs"""
-        for api in apis:
-            # Parse headers
-            if 'headers' in api and isinstance(api['headers'], str):
-                try:
-                    api['headers'] = json.loads(api['headers'])
-                except json.JSONDecodeError:
-                    api['headers'] = {}
-            
-            # Parse body_template
-            if 'body_template' in api and isinstance(api['body_template'], str):
-                try:
-                    api['body_template'] = json.loads(api['body_template'])
-                except json.JSONDecodeError:
-                    api['body_template'] = {}
-            
-            # Parse auth configs
-            if 'auth' in api and api['auth']:
-                cls._parse_auth_config(api['auth'])
+    if (this.selectedVersion) {
+      this.loadVersion(this.selectedVersion);
+    }
+
+    this.versionForm.valueChanges.subscribe(() => {
+      this.isDirty = true;
+    });
+  }
+
+  initializeForm() {
+    this.versionForm = this.fb.group({
+      no: [{value: '', disabled: true}],
+      caption: ['', Validators.required],
+      published: [{value: false, disabled: true}],
+      general_prompt: ['', Validators.required],
+      welcome_prompt: [''],  // Added welcome_prompt field
+      llm: this.fb.group({
+        repo_id: ['', Validators.required],
+        generation_config: this.fb.group({
+          max_new_tokens: [256, [Validators.required, Validators.min(1), Validators.max(2048)]],
+          temperature: [0.2, [Validators.required, Validators.min(0), Validators.max(2)]],
+          top_p: [0.8, [Validators.required, Validators.min(0), Validators.max(1)]],
+          repetition_penalty: [1.1, [Validators.required, Validators.min(1), Validators.max(2)]]
+        }),
+        use_fine_tune: [false],
+        fine_tune_zip: ['']
+      }),
+      intents: this.fb.array([]),
+      last_update_date: ['']
+    });
+
+    // Watch for fine-tune toggle
+    this.versionForm.get('llm.use_fine_tune')?.valueChanges.subscribe(useFineTune => {
+      const fineTuneControl = this.versionForm.get('llm.fine_tune_zip');
+      if (useFineTune) {
+        fineTuneControl?.setValidators([Validators.required]);
+      } else {
+        fineTuneControl?.clearValidators();
+        fineTuneControl?.setValue('');
+      }
+      fineTuneControl?.updateValueAndValidity();
+    });
+  }
+
+  async loadAvailableLocales() {
+    // Get supported locales from project
+    const supportedCodes = [
+      this.project.default_locale,
+      ...(this.project.supported_locales || [])
+    ].filter(Boolean);
+
+    // Get locale details
+    for (const code of supportedCodes) {
+      if (!code) continue; // Skip undefined/null values
+      
+      try {
+        const localeInfo = await this.localeService.getLocaleDetails(code).toPromise();
+        if (localeInfo) {
+          this.availableLocales.push({
+            code: localeInfo.code,
+            name: localeInfo.name
+          });
+        }
+      } catch (error) {
+        // Use fallback for known locales
+        const fallbackNames: { [key: string]: string } = {
+          'tr': 'Türkçe',
+          'en': 'English',
+          'de': 'Deutsch',
+          'fr': 'Français',
+          'es': 'Español'
+        };
+        if (code && fallbackNames[code]) {
+          this.availableLocales.push({
+            code: code,
+            name: fallbackNames[code]
+          });
+        }
+      }
+    }
+  }
+
+  getAvailableLocales(): Locale[] {
+    return this.availableLocales;
+  }
+
+  getLocaleName(localeCode: string): string {
+    const locale = this.availableLocales.find(l => l.code === localeCode);
+    return locale?.name || localeCode;
+  }
+
+  loadVersion(version: Version) {
+    this.selectedVersion = version;
     
-    @classmethod
-    def _parse_auth_config(cls, auth: Dict[str, Any]) -> None:
-        """Parse auth configuration"""
-        # Parse token_request_body
-        if 'token_request_body' in auth and isinstance(auth['token_request_body'], str):
-            try:
-                auth['token_request_body'] = json.loads(auth['token_request_body'])
-            except json.JSONDecodeError:
-                auth['token_request_body'] = {}
+    // Form değerlerini set et
+    this.versionForm.patchValue({
+      no: version.no,
+      caption: version.caption || '',
+      published: version.published || false,
+      general_prompt: (version as any).general_prompt || '',
+      welcome_prompt: (version as any).welcome_prompt || '',  // Added welcome_prompt
+      last_update_date: version.last_update_date || ''
+    });
+  
+    // LLM config'i ayrı set et
+    if ((version as any).llm) {
+      this.versionForm.patchValue({
+        llm: {
+          repo_id: (version as any).llm.repo_id || '',
+          generation_config: (version as any).llm.generation_config || {
+            max_new_tokens: 512,
+            temperature: 0.7,
+            top_p: 0.95,
+            repetition_penalty: 1.1
+          },
+          use_fine_tune: (version as any).llm.use_fine_tune || false,
+          fine_tune_zip: (version as any).llm.fine_tune_zip || ''
+        }
+      });
+    }
+  
+    // Clear and rebuild intents
+    this.intents.clear();
+    ((version as any).intents || []).forEach((intent: any) => {
+      this.intents.push(this.createIntentFormGroup(intent));
+    });
+
+    this.isDirty = false;
+  }
+  
+  async loadVersions() {
+    this.loading = true;
+    try {
+      const project = await this.apiService.getProject(this.project.id).toPromise();
+      if (project) {
+        this.project = project;
+        this.versions = [...project.versions].sort((a, b) => b.no - a.no);
         
-        # Parse token_refresh_body
-        if 'token_refresh_body' in auth and isinstance(auth['token_refresh_body'], str):
-            try:
-                auth['token_refresh_body'] = json.loads(auth['token_refresh_body'])
-            except json.JSONDecodeError:
-                auth['token_refresh_body'] = {}
+        // Re-select current version if it still exists
+        if (this.selectedVersion) {
+          const currentVersion = this.versions.find(v => v.no === this.selectedVersion!.no);
+          if (currentVersion) {
+            this.loadVersion(currentVersion);
+          } else if (this.versions.length > 0) {
+            this.loadVersion(this.versions[0]);
+          }
+        } else if (this.versions.length > 0) {
+          this.loadVersion(this.versions[0]);
+        }
+      }
+    } catch (error) {
+      this.snackBar.open('Failed to reload versions', 'Close', { duration: 3000 });
+    } finally {
+      this.loading = false;
+    }
+  }
+
+  createIntentFormGroup(intent: any = {}): FormGroup {
+    const group = this.fb.group({
+      name: [intent.name || '', [Validators.required, Validators.pattern(/^[a-zA-Z0-9-]+$/)]],
+      caption: [intent.caption || ''],
+      detection_prompt: [intent.detection_prompt || '', Validators.required],
+      examples: [intent.examples || []], // Store as array, not FormArray
+      parameters: this.fb.array([]),
+      action: [intent.action || '', Validators.required],
+      fallback_timeout_prompt: [intent.fallback_timeout_prompt || ''],
+      fallback_error_prompt: [intent.fallback_error_prompt || '']
+    });
+  
+    // Parameters'ı ayrı olarak ekle
+    if (intent.parameters && Array.isArray(intent.parameters)) {
+      const parametersArray = group.get('parameters') as FormArray;
+      intent.parameters.forEach((param: any) => {
+        parametersArray.push(this.createParameterFormGroup(param));
+      });
+    }
+  
+    return group;
+  }
+
+  createParameterFormGroup(param: any = {}): FormGroup {
+    return this.fb.group({
+      name: [param.name || '', [Validators.required, Validators.pattern(/^[a-zA-Z0-9_]+$/)]],
+      caption: [param.caption || []],
+      type: [param.type || 'str', Validators.required],
+      required: [param.required !== false],
+      variable_name: [param.variable_name || '', Validators.required],
+      extraction_prompt: [param.extraction_prompt || ''],
+      validation_regex: [param.validation_regex || ''],
+      invalid_prompt: [param.invalid_prompt || ''],
+      type_error_prompt: [param.type_error_prompt || '']
+    });
+  }
+
+  get intents() {
+    return this.versionForm.get('intents') as FormArray;
+  }
+
+  getIntentParameters(intentIndex: number): FormArray {
+    return this.intents.at(intentIndex).get('parameters') as FormArray;
+  }
+
+  // LocalizedExample support methods
+  getLocalizedExamples(examples: any[], locale: string): LocalizedExample[] {
+    if (!examples || !Array.isArray(examples)) return [];
     
-    @classmethod
-    def save(cls, config: ServiceConfig, username: str) -> None:
-        """Thread-safe configuration save with optimistic locking"""
-        with cls._file_lock:
-            try:
-                # Load current config for race condition check
-                try:
-                    current_config = cls._load()
-                    
-                    # Check for race condition
-                    if config.last_update_date and current_config.last_update_date:
-                        if not timestamps_equal(config.last_update_date, current_config.last_update_date):
-                            raise RaceConditionError(
-                                "Configuration was modified by another user",
-                                current_user=username,
-                                last_update_user=current_config.last_update_user,
-                                last_update_date=current_config.last_update_date,
-                                entity_type="configuration"
-                            )
-                except ConfigurationError as e:
-                    # Eğer mevcut config yüklenemiyorsa, race condition kontrolünü atla
-                    log_warning(f"Could not load current config for race condition check: {e}")
-                    current_config = None
-                
-                # Update metadata
-                config.last_update_date = get_current_timestamp()
-                config.last_update_user = username
-                
-                # Convert to JSON - Pydantic v2 kullanımı
-                data = config.model_dump(mode='json')
-                json_str = json.dumps(data, ensure_ascii=False, indent=2)
-                
-                # Backup current file if exists
-                backup_path = None
-                if cls._CONFIG_PATH.exists():
-                    backup_path = cls._CONFIG_PATH.with_suffix('.backup')
-                    shutil.copy2(str(cls._CONFIG_PATH), str(backup_path))
-                    log_debug(f"Created backup at {backup_path}")
-                
-                try:
-                    # Write to temporary file first
-                    temp_path = cls._CONFIG_PATH.with_suffix('.tmp')
-                    with open(temp_path, 'w', encoding='utf-8') as f:
-                        f.write(json_str)
-                    
-                    # Validate the temp file by trying to load it
-                    with open(temp_path, 'r', encoding='utf-8') as f:
-                        test_data = commentjson.load(f)
-                        ServiceConfig.model_validate(test_data)
-                    
-                    # If validation passes, replace the original
-                    shutil.move(str(temp_path), str(cls._CONFIG_PATH))
-                    
-                    # Delete backup if save successful
-                    if backup_path and backup_path.exists():
-                        backup_path.unlink()
-                        
-                except Exception as e:
-                    # Restore from backup if something went wrong
-                    if backup_path and backup_path.exists():
-                        shutil.move(str(backup_path), str(cls._CONFIG_PATH))
-                        log_error(f"Restored configuration from backup due to error: {e}")
-                    raise
-                
-                # Update cached instance
-                with cls._lock:
-                    cls._instance = config
-                
-                log_info(
-                    "Configuration saved successfully",
-                    user=username,
-                    last_update=config.last_update_date
-                )
-                
-            except Exception as e:
-                log_error("Failed to save configuration", error=str(e), user=username)
-                raise
+    // Check if examples are in new format
+    if (examples.length > 0 && typeof examples[0] === 'object' && 'locale_code' in examples[0]) {
+      return examples.filter(ex => ex.locale_code === locale);
+    }
     
-    # ===================== Environment Methods =====================
+    // Old format - convert to new
+    if (typeof examples[0] === 'string') {
+      return examples.map(ex => ({ locale_code: locale, example: ex }));
+    }
     
-    @classmethod
-    def update_environment(cls, update_data: dict, username: str) -> None:
-        """Update environment configuration"""
-        with cls._lock:
-            config = cls.get()
-            
-            # Update providers
-            if 'llm_provider' in update_data:
-                config.global_config.llm_provider = update_data['llm_provider']
-            
-            if 'tts_provider' in update_data:
-                config.global_config.tts_provider = update_data['tts_provider']
-            
-            if 'stt_provider' in update_data:
-                config.global_config.stt_provider = update_data['stt_provider']
-            
-            # Log activity
-            cls._add_activity(
-                config, username, "UPDATE_ENVIRONMENT",
-                "environment", None, None,
-                f"Updated providers"
-            )
-            
-            # Save
-            cls.save(config, username)
+    return [];
+  }
+
+  getParameterCaptionDisplay(captions: LocalizedCaption[]): string {
+    if (!captions || !Array.isArray(captions) || captions.length === 0) {
+      return '(No caption)';
+    }
     
-    # ===================== Project Methods =====================
+    // Try to find caption for selected locale
+    const selectedCaption = captions.find(c => c.locale_code === this.selectedExampleLocale);
+    if (selectedCaption) return selectedCaption.caption;
     
-    @classmethod
-    def get_project(cls, project_id: int) -> Optional[ProjectConfig]:
-        """Get project by ID"""
-        config = cls.get()
-        return next((p for p in config.projects if p.id == project_id), None)
+    // Try default locale
+    const defaultCaption = captions.find(c => c.locale_code === this.project.default_locale);
+    if (defaultCaption) return defaultCaption.caption;
     
-    @classmethod
-    def create_project(cls, project_data: dict, username: str) -> ProjectConfig:
-        """Create new project with initial version"""
-        with cls._lock:
-            config = cls.get()
-            
-            # Check for duplicate name
-            if any(p.name == project_data['name'] for p in config.projects):
-                raise DuplicateResourceError("project", project_data['name'])
-            
-            # Create project
-            project = ProjectConfig(
-                id=config.project_id_counter,
-                created_date=get_current_timestamp(),
-                created_by=username,
-                version_id_counter=1,  # Başlangıç değeri
-                versions=[],  # Boş başla
-                **project_data
-            )
-            
-            # Create initial version with proper models
-            initial_version = VersionConfig(
-                no=1,
-                caption="Initial version",
-                description="Auto-generated initial version",
-                published=False,  # Explicitly set to False
-                deleted=False,
-                general_prompt="You are a helpful assistant.",
-                welcome_prompt=None,
-                llm=LLMConfiguration(
-                    repo_id="ytu-ce-cosmos/Turkish-Llama-8b-Instruct-v0.1",
-                    generation_config=GenerationConfig(
-                        max_new_tokens=512,
-                        temperature=0.7,
-                        top_p=0.9,
-                        repetition_penalty=1.1,
-                        do_sample=True
-                    ),
-                    use_fine_tune=False,
-                    fine_tune_zip=""
-                ),
-                intents=[],
-                created_date=get_current_timestamp(),
-                created_by=username,
-                last_update_date=None,
-                last_update_user=None,
-                publish_date=None,
-                published_by=None   
-            )
-            
-            # Add initial version to project
-            project.versions.append(initial_version)
-            project.version_id_counter = 2  # Next version will be 2
-            
-            # Update config
-            config.projects.append(project)
-            config.project_id_counter += 1
-            
-            # Log activity
-            cls._add_activity(
-                config, username, "CREATE_PROJECT",
-                "project", project.id, project.name,
-                f"Created with initial version"
-            )
-            
-            # Save
-            cls.save(config, username)
-            
-            log_info(
-                "Project created with initial version",
-                project_id=project.id,
-                name=project.name,
-                user=username
-            )
-            
-            return project
-        
-    @classmethod
-    def update_project(cls, project_id: int, update_data: dict, username: str, expected_last_update: Optional[str] = None) -> ProjectConfig:
-        """Update project with optimistic locking"""
-        with cls._lock:
-            config = cls.get()
-            project = cls.get_project(project_id)
-            
-            if not project:
-                raise ResourceNotFoundError("project", project_id)
-            
-            # Check race condition
-            if expected_last_update is not None and expected_last_update != '':
-                if project.last_update_date and not timestamps_equal(expected_last_update, project.last_update_date):
-                    raise RaceConditionError(
-                        f"Project '{project.name}' was modified by another user",
-                        current_user=username,
-                        last_update_user=project.last_update_user,
-                        last_update_date=project.last_update_date,
-                        entity_type="project",
-                        entity_id=project_id
-                    )
-            
-            # Update fields
-            for key, value in update_data.items():
-                if hasattr(project, key) and key not in ['id', 'created_date', 'created_by', 'last_update_date', 'last_update_user']:
-                    setattr(project, key, value)
-            
-            project.last_update_date = get_current_timestamp()
-            project.last_update_user = username
-            
-            # Log activity
-            cls._add_activity(
-                config, username, "UPDATE_PROJECT",
-                "project", project.id, project.name
-            )
-            
-            # Save
-            cls.save(config, username)
-            
-            log_info(
-                "Project updated",
-                project_id=project.id,
-                user=username
-            )
-            
-            return project
+    // Return first available caption
+    return captions[0].caption;
+  }
+
+  addLocalizedExample(intentIndex: number, example: string) {
+    if (!example.trim()) return;
     
-    @classmethod
-    def delete_project(cls, project_id: int, username: str) -> None:
-        """Soft delete project"""
-        with cls._lock:
-            config = cls.get()
-            project = cls.get_project(project_id)
-            
-            if not project:
-                raise ResourceNotFoundError("project", project_id)
-            
-            project.deleted = True
-            project.last_update_date = get_current_timestamp()
-            project.last_update_user = username
-            
-            # Log activity
-            cls._add_activity(
-                config, username, "DELETE_PROJECT",
-                "project", project.id, project.name
-            )
-            
-            # Save
-            cls.save(config, username)
-            
-            log_info(
-                "Project deleted",
-                project_id=project.id,
-                user=username
-            )
+    const intent = this.intents.at(intentIndex);
+    const currentExamples = intent.get('examples')?.value || [];
     
-    @classmethod
-    def toggle_project(cls, project_id: int, username: str) -> bool:
-        """Toggle project enabled status"""
-        with cls._lock:
-            config = cls.get()
-            project = cls.get_project(project_id)
-            
-            if not project:
-                raise ResourceNotFoundError("project", project_id)
-            
-            project.enabled = not project.enabled
-            project.last_update_date = get_current_timestamp()
-            project.last_update_user = username
-            
-            # Log activity
-            cls._add_activity(
-                config, username, "TOGGLE_PROJECT",
-                "project", project.id, project.name,
-                f"{'Enabled' if project.enabled else 'Disabled'}"
-            )
-            
-            # Save
-            cls.save(config, username)
-            
-            log_info(
-                "Project toggled",
-                project_id=project.id,
-                enabled=project.enabled,
-                user=username
-            )
-            
-            return project.enabled
+    // Check if already exists
+    const exists = currentExamples.some((ex: any) => 
+      ex.locale_code === this.selectedExampleLocale && ex.example === example.trim()
+    );
     
-    # ===================== Version Methods =====================
+    if (!exists) {
+      const newExamples = [...currentExamples, {
+        locale_code: this.selectedExampleLocale,
+        example: example.trim()
+      }];
+      intent.patchValue({ examples: newExamples });
+      this.isDirty = true;
+    }
+  }
+
+  removeLocalizedExample(intentIndex: number, exampleToRemove: LocalizedExample) {
+    const intent = this.intents.at(intentIndex);
+    const currentExamples = intent.get('examples')?.value || [];
     
-    @classmethod
-    def create_version(cls, project_id: int, version_data: dict, username: str) -> VersionConfig:
-        """Create new version"""
-        with cls._lock:
-            config = cls.get()
-            project = cls.get_project(project_id)
-            
-            if not project:
-                raise ResourceNotFoundError("project", project_id)
-            
-            # Handle source version copy
-            if 'source_version_no' in version_data and version_data['source_version_no']:
-                source_version = next((v for v in project.versions if v.no == version_data['source_version_no']), None)
-                if source_version:
-                    # Copy from source version
-                    version_dict = source_version.model_dump()
-                    # Remove fields that shouldn't be copied
-                    for field in ['no', 'created_date', 'created_by', 'published', 'publish_date', 
-                                  'published_by', 'last_update_date', 'last_update_user']:
-                        version_dict.pop(field, None)
-                    # Override with provided data
-                    version_dict['caption'] = version_data.get('caption', f"Copy of {source_version.caption}")
-                else:
-                    # Source not found, create blank
-                    version_dict = {
-                        'caption': version_data.get('caption', 'New Version'),
-                        'general_prompt': '',
-                        'welcome_prompt': None,
-                        'llm': {
-                            'repo_id': '',
-                            'generation_config': {
-                                'max_new_tokens': 512,
-                                'temperature': 0.7,
-                                'top_p': 0.95,
-                                'repetition_penalty': 1.1
-                            },
-                            'use_fine_tune': False,
-                            'fine_tune_zip': ''
-                        },
-                        'intents': []
-                    }
-            else:
-                # Create blank version
-                version_dict = {
-                    'caption': version_data.get('caption', 'New Version'),
-                    'general_prompt': '',
-                    'welcome_prompt': None,
-                    'llm': {
-                        'repo_id': '',
-                        'generation_config': {
-                            'max_new_tokens': 512,
-                            'temperature': 0.7,
-                            'top_p': 0.95,
-                            'repetition_penalty': 1.1
-                        },
-                        'use_fine_tune': False,
-                        'fine_tune_zip': ''
-                    },
-                    'intents': []
-                }
-            
-            # Create version
-            version = VersionConfig(
-                no=project.version_id_counter,
-                published=False,  # New versions are always unpublished
-                deleted=False,
-                created_date=get_current_timestamp(),
-                created_by=username,
-                **version_dict
-            )
-            
-            # Update project
-            project.versions.append(version)
-            project.version_id_counter += 1
-            project.last_update_date = get_current_timestamp()
-            project.last_update_user = username
-            
-            # Log activity
-            cls._add_activity(
-                config, username, "CREATE_VERSION",
-                "version", version.no, f"{project.name} v{version.no}",
-                f"Project: {project.name}"
-            )
-            
-            # Save
-            cls.save(config, username)
-            
-            log_info(
-                "Version created",
-                project_id=project.id,
-                version_no=version.no,
-                user=username
-            )
-            
-            return version
+    const newExamples = currentExamples.filter((ex: any) => 
+      !(ex.locale_code === exampleToRemove.locale_code && ex.example === exampleToRemove.example)
+    );
     
-    @classmethod
-    def publish_version(cls, project_id: int, version_no: int, username: str) -> tuple[ProjectConfig, VersionConfig]:
-        """Publish a version"""
-        with cls._lock:
-            config = cls.get()
-            project = cls.get_project(project_id)
-            
-            if not project:
-                raise ResourceNotFoundError("project", project_id)
-            
-            version = next((v for v in project.versions if v.no == version_no), None)
-            if not version:
-                raise ResourceNotFoundError("version", version_no)
-            
-            # Unpublish other versions
-            for v in project.versions:
-                if v.published and v.no != version_no:
-                    v.published = False
-            
-            # Publish this version
-            version.published = True
-            version.publish_date = get_current_timestamp()
-            version.published_by = username
-            
-            # Update project
-            project.last_update_date = get_current_timestamp()
-            project.last_update_user = username
-            
-            # Log activity
-            cls._add_activity(
-                config, username, "PUBLISH_VERSION",
-                "version", version.no, f"{project.name} v{version.no}",
-                f"Published version {version.no}"
-            )
-            
-            # Save
-            cls.save(config, username)
-            
-            log_info(
-                "Version published",
-                project_id=project.id,
-                version_no=version.no,
-                user=username
-            )
-            
-            return project, version
-
-    @classmethod
-    def update_version(cls, project_id: int, version_no: int, update_data: dict, username: str, expected_last_update: Optional[str] = None) -> VersionConfig:
-        """Update version with optimistic locking"""
-        with cls._lock:
-            config = cls.get()
-            project = cls.get_project(project_id)
-            
-            if not project:
-                raise ResourceNotFoundError("project", project_id)
-            
-            version = next((v for v in project.versions if v.no == version_no), None)
-            if not version:
-                raise ResourceNotFoundError("version", version_no)
-            
-            # Published versions cannot be edited
-            if version.published:
-                raise ValidationError("Published versions cannot be modified")
-            
-            # Check race condition
-            if expected_last_update is not None and expected_last_update != '':
-                if version.last_update_date and not timestamps_equal(expected_last_update, version.last_update_date):
-                    raise RaceConditionError(
-                        f"Version '{version.no}' was modified by another user",
-                        current_user=username,
-                        last_update_user=version.last_update_user,
-                        last_update_date=version.last_update_date,
-                        entity_type="version",
-                        entity_id=f"{project_id}:{version_no}"
-                    )                
-            
-            # Update fields
-            for key, value in update_data.items():
-                if hasattr(version, key) and key not in ['no', 'created_date', 'created_by', 'published', 'last_update_date']:
-                    setattr(version, key, value)
-            
-            version.last_update_date = get_current_timestamp()
-            version.last_update_user = username
-            
-            # Update project last update
-            project.last_update_date = get_current_timestamp()
-            project.last_update_user = username
-            
-            # Log activity
-            cls._add_activity(
-                config, username, "UPDATE_VERSION",
-                "version", f"{project.id}:{version.no}", f"{project.name} v{version.no}"
-            )
-            
-            # Save
-            cls.save(config, username)
-            
-            log_info(
-                "Version updated",
-                project_id=project.id,
-                version_no=version.no,
-                user=username
-            )
-            
-            return version
+    intent.patchValue({ examples: newExamples });
+    this.isDirty = true;
+  }
+
+  addParameter(intentIndex: number) {
+    const parameters = this.getIntentParameters(intentIndex);
+    parameters.push(this.createParameterFormGroup());
+    this.isDirty = true;
+  }
+
+  removeParameter(intentIndex: number, paramIndex: number) {
+    const parameters = this.getIntentParameters(intentIndex);
+    parameters.removeAt(paramIndex);
+    this.isDirty = true;
+  }
+
+  // Check if version can be edited
+  get canEdit(): boolean {
+    return !this.selectedVersion?.published;
+  }
+
+  addIntent() {
+    this.intents.push(this.createIntentFormGroup());
+    this.isDirty = true;
+  }
+
+  removeIntent(index: number) {
+    const intent = this.intents.at(index).value;
+    const dialogRef = this.dialog.open(ConfirmDialogComponent, {
+      width: '400px',
+      data: {
+        title: 'Delete Intent',
+        message: `Are you sure you want to delete intent "${intent.name}"?`,
+        confirmText: 'Delete',
+        confirmColor: 'warn'
+      }
+    });
+
+    dialogRef.afterClosed().subscribe(confirmed => {
+      if (confirmed) {
+        this.intents.removeAt(index);
+        this.isDirty = true;
+      }
+    });
+  }
+
+  async editIntent(intentIndex: number) {
+    const { default: IntentEditDialogComponent } = await import('../intent-edit-dialog/intent-edit-dialog.component');
     
-    @classmethod
-    def delete_version(cls, project_id: int, version_no: int, username: str) -> None:
-        """Soft delete version"""
-        with cls._lock:
-            config = cls.get()
-            project = cls.get_project(project_id)
-            
-            if not project:
-                raise ResourceNotFoundError("project", project_id)
-            
-            version = next((v for v in project.versions if v.no == version_no), None)
-            if not version:
-                raise ResourceNotFoundError("version", version_no)
-            
-            if version.published:
-                raise ValidationError("Cannot delete published version")
-            
-            version.deleted = True
-            version.last_update_date = get_current_timestamp()
-            version.last_update_user = username
-            
-            # Update project
-            project.last_update_date = get_current_timestamp()
-            project.last_update_user = username
-            
-            # Log activity
-            cls._add_activity(
-                config, username, "DELETE_VERSION",
-                "version", f"{project.id}:{version.no}", f"{project.name} v{version.no}"
-            )
-            
-            # Save
-            cls.save(config, username)
-            
-            log_info(
-                "Version deleted",
-                project_id=project.id,
-                version_no=version.no,
-                user=username
-            )
+    const intent = this.intents.at(intentIndex);
+    const currentValue = intent.value;
     
-    # ===================== API Methods =====================
+    // Intent verilerini dialog'a gönder
+    const dialogRef = this.dialog.open(IntentEditDialogComponent, {
+      width: '90vw',
+      maxWidth: '1000px',
+      data: { 
+        intent: {
+          ...currentValue,
+          examples: currentValue.examples || [],
+          parameters: currentValue.parameters || []
+        },
+        project: this.project,
+        apis: await this.getAvailableAPIs()
+      }
+    });
+  
+    dialogRef.afterClosed().subscribe(result => {
+      if (result) {
+        // Update intent with result
+        intent.patchValue({
+          name: result.name,
+          caption: result.caption,
+          detection_prompt: result.detection_prompt,
+          examples: result.examples || [],
+          action: result.action,
+          fallback_timeout_prompt: result.fallback_timeout_prompt,
+          fallback_error_prompt: result.fallback_error_prompt
+        });
+  
+        // Update parameters
+        const parametersArray = intent.get('parameters') as FormArray;
+        parametersArray.clear();
+        (result.parameters || []).forEach((param: any) => {
+          parametersArray.push(this.createParameterFormGroup(param));
+        });
+        
+        this.isDirty = true;
+      }
+    });
+  }
+
+  async getAvailableAPIs(): Promise<any[]> {
+    try {
+      return await this.apiService.getAPIs().toPromise() || [];
+    } catch {
+      return [];
+    }
+  }
+
+  async createVersion() {
+    const publishedVersions = this.versions.filter(v => v.published);
     
-    @classmethod
-    def create_api(cls, api_data: dict, username: str) -> APIConfig:
-        """Create new API"""
-        with cls._lock:
-            config = cls.get()
-            
-            # Check for duplicate name
-            if any(a.name == api_data['name'] for a in config.apis):
-                raise DuplicateResourceError("api", api_data['name'])
-            
-            # Create API
-            api = APIConfig(
-                created_date=get_current_timestamp(),
-                created_by=username,
-                **api_data
-            )
-            
-            # Add to config
-            config.apis.append(api)
-            
-            # Rebuild index
-            config.build_index()
-            
-            # Log activity
-            cls._add_activity(
-                config, username, "CREATE_API",
-                "api", api.name, api.name
-            )
-            
-            # Save
-            cls.save(config, username)
-            
-            log_info(
-                "API created",
-                api_name=api.name,
-                user=username
-            )
-            
-            return api
+    const dialogRef = this.dialog.open(ConfirmDialogComponent, {
+      width: '500px',
+      data: {
+        title: 'Create New Version',
+        message: 'Which published version would you like to use as a base for the new version?',
+        showDropdown: true,
+        dropdownOptions: publishedVersions.map(v => ({
+          value: v.no,
+          label: `Version ${v.no} - ${v.caption || 'No description'}`
+        })),
+        dropdownPlaceholder: 'Select published version (or leave empty for blank)',
+        confirmText: 'Create',
+        cancelText: 'Cancel'
+      }
+    });
+  
+    dialogRef.afterClosed().subscribe(async (result) => {
+      if (result?.confirmed) {
+        this.creating = true;
+        try {
+          let newVersionData;
+          
+          if (result.selectedValue) {
+            // Copy from selected version - we need to get the full version data
+            const sourceVersion = this.versions.find(v => v.no === result.selectedValue);
+            if (sourceVersion) {
+              // Load the full version data from the current form if it's the selected version
+              if (sourceVersion.no === this.selectedVersion?.no) {
+                const formValue = this.versionForm.getRawValue();
+                newVersionData = {
+                  ...formValue,
+                  no: undefined,
+                  published: false,
+                  last_update_date: undefined,
+                  caption: `Copy of ${sourceVersion.caption || `version ${sourceVersion.no}`}`
+                };
+              } else {
+                // For other versions, we only have basic info, so create minimal copy
+                newVersionData = {
+                  caption: `Copy of ${sourceVersion.caption || `version ${sourceVersion.no}`}`,
+                  general_prompt: '',
+                  llm: {
+                    repo_id: '',
+                    generation_config: {
+                      max_new_tokens: 512,
+                      temperature: 0.7,
+                      top_p: 0.95,
+                      repetition_penalty: 1.1
+                    },
+                    use_fine_tune: false,
+                    fine_tune_zip: ''
+                  },
+                  intents: []
+                };
+              }
+            }
+          } else {
+            // Create blank version
+            newVersionData = {
+              caption: `Version ${this.versions.length + 1}`,
+              general_prompt: '',
+              llm: {
+                repo_id: '',
+                generation_config: {
+                  max_new_tokens: 512,
+                  temperature: 0.7,
+                  top_p: 0.95,
+                  repetition_penalty: 1.1
+                },
+                use_fine_tune: false,
+                fine_tune_zip: ''
+              },
+              intents: []
+            };
+          }
+  
+          if (newVersionData) {
+            await this.apiService.createVersion(this.project.id, newVersionData).toPromise();
+            await this.loadVersions();
+            this.snackBar.open('Version created successfully!', 'Close', { duration: 3000 });
+          }
+        } catch (error) {
+          this.snackBar.open('Failed to create version', 'Close', { duration: 3000 });
+        } finally {
+          this.creating = false;
+        }
+      }
+    });
+  }
+
+  async saveVersion() {
+    if (!this.selectedVersion || !this.canEdit) {
+      this.snackBar.open('Cannot save published version', 'Close', { duration: 3000 });
+      return;
+    }
     
-    @classmethod
-    def update_api(cls, api_name: str, update_data: dict, username: str, expected_last_update: Optional[str] = None) -> APIConfig:
-        """Update API with optimistic locking"""
-        with cls._lock:
-            config = cls.get()
-            api = config.get_api(api_name)
-            
-            if not api:
-                raise ResourceNotFoundError("api", api_name)
-            
-            # Check race condition
-            if expected_last_update is not None and expected_last_update != '':
-                if api.last_update_date and not timestamps_equal(expected_last_update, api.last_update_date):
-                    raise RaceConditionError(
-                        f"API '{api.name}' was modified by another user",
-                        current_user=username,
-                        last_update_user=api.last_update_user,
-                        last_update_date=api.last_update_date,
-                        entity_type="api",
-                        entity_id=api.name
-                    )                
-                        
-            # Update fields
-            for key, value in update_data.items():
-                if hasattr(api, key) and key not in ['name', 'created_date', 'created_by', 'last_update_date']:
-                    setattr(api, key, value)
-            
-            api.last_update_date = get_current_timestamp()
-            api.last_update_user = username
-            
-            # Rebuild index
-            config.build_index()
-            
-            # Log activity
-            cls._add_activity(
-                config, username, "UPDATE_API",
-                "api", api.name, api.name
-            )
-            
-            # Save
-            cls.save(config, username)
-            
-            log_info(
-                "API updated",
-                api_name=api.name,
-                user=username
-            )
-            
-            return api
+    if (this.versionForm.invalid) {
+      const invalidFields: string[] = [];
+      Object.keys(this.versionForm.controls).forEach(key => {
+        const control = this.versionForm.get(key);
+        if (control && control.invalid) {
+          invalidFields.push(key);
+        }
+      });
+      
+      this.intents.controls.forEach((intent, index) => {
+        if (intent.invalid) {
+          invalidFields.push(`Intent ${index + 1}`);
+        }
+      });
+  
+      this.snackBar.open(`Please fix validation errors in: ${invalidFields.join(', ')}`, 'Close', { 
+        duration: 5000 
+      });
+      return;
+    }
+  
+    const currentVersion = this.selectedVersion!;
+  
+    this.saving = true;
     
-    @classmethod
-    def delete_api(cls, api_name: str, username: str) -> None:
-        """Soft delete API"""
-        with cls._lock:
-            config = cls.get()
-            api = config.get_api(api_name)
-            
-            if not api:
-                raise ResourceNotFoundError("api", api_name)
-            
-            api.deleted = True
-            api.last_update_date = get_current_timestamp()
-            api.last_update_user = username
-            
-            # Rebuild index
-            config.build_index()
-            
-            # Log activity
-            cls._add_activity(
-                config, username, "DELETE_API",
-                "api", api.name, api.name
-            )
-            
-            # Save
-            cls.save(config, username)
-            
-            log_info(
-                "API deleted",
-                api_name=api.name,
-                user=username
-            )
+    try {
+      const formValue = this.versionForm.getRawValue();
+      
+      // updateData'yı backend'in beklediği formatta hazırla
+      const updateData = {
+        caption: formValue.caption,
+        general_prompt: formValue.general_prompt || '',
+        welcome_prompt: formValue.welcome_prompt || '',  // Added welcome_prompt
+        llm: formValue.llm,
+        intents: formValue.intents.map((intent: any) => ({
+          name: intent.name,
+          caption: intent.caption,
+          detection_prompt: intent.detection_prompt,
+          examples: Array.isArray(intent.examples) ? intent.examples : [],
+          parameters: Array.isArray(intent.parameters) ? intent.parameters.map((param: any) => ({
+            name: param.name,
+            caption: param.caption,
+            type: param.type,
+            required: param.required,
+            variable_name: param.variable_name,
+            extraction_prompt: param.extraction_prompt,
+            validation_regex: param.validation_regex,
+            invalid_prompt: param.invalid_prompt,
+            type_error_prompt: param.type_error_prompt
+          })) : [],
+          action: intent.action,
+          fallback_timeout_prompt: intent.fallback_timeout_prompt,
+          fallback_error_prompt: intent.fallback_error_prompt
+        })),
+        last_update_date: currentVersion.last_update_date || ''
+      };
+  
+      console.log('Saving version data:', JSON.stringify(updateData, null, 2));
+  
+      const result = await this.apiService.updateVersion(
+        this.project.id, 
+        currentVersion.no, 
+        updateData
+      ).toPromise();
+  
+      this.snackBar.open('Version saved successfully', 'Close', { duration: 3000 });
+
+      this.isDirty = false;
+      
+      if (result) {
+        this.selectedVersion = result;
+        this.versionForm.patchValue({
+          last_update_date: result.last_update_date
+        });
+      }
+      
+      await this.loadVersions();
+      
+    } catch (error: any) {
+      console.error('Save error:', error);
+      
+      if (error.status === 409) {
+        // Race condition handling
+        await this.handleRaceCondition(currentVersion);
+      } else if (error.status === 400 && error.error?.detail?.includes('Published versions')) {
+        this.snackBar.open('Published versions cannot be modified. Create a new version instead.', 'Close', { 
+          duration: 5000,
+          panelClass: 'error-snackbar'
+        });
+      } else {
+        const errorMessage = error.error?.detail || error.message || 'Failed to save version';
+        this.snackBar.open(errorMessage, 'Close', { 
+          duration: 5000,
+          panelClass: 'error-snackbar'
+        });
+      }
+    } finally {
+      this.saving = false;
+    }
+  }
+  
+  // Race condition handling
+  private async handleRaceCondition(currentVersion: Version) {
+    const formValue = this.versionForm.getRawValue();
     
-    # ===================== Activity Methods =====================
-    @classmethod
-    def _add_activity(
-        cls,
-        config: ServiceConfig,
-        username: str,
-        action: str,
-        entity_type: str,
-        entity_id: Any,
-        entity_name: Optional[str] = None,
-        details: Optional[str] = None
-    ) -> None:
-        """Add activity log entry"""
-        # Activity ID'sini oluştur - mevcut en yüksek ID'yi bul
-        max_id = 0
-        if config.activity_log:
-            max_id = max((entry.id for entry in config.activity_log if entry.id), default=0)
-        
-        activity_id = max_id + 1
-        
-        activity = ActivityLogEntry(
-            id=activity_id,
-            timestamp=get_current_timestamp(),  # utils'ten import etmeyi unutma
-            username=username,
-            action=action,
-            entity_type=entity_type,
-            entity_id=str(entity_id) if entity_id else None,
-            entity_name=entity_name,
-            details=details
-        )
-        
-        config.activity_log.append(activity)
-        
-        # Keep only last 1000 entries
-        if len(config.activity_log) > 1000:
-            config.activity_log = config.activity_log[-1000:]
+    const retryUpdateData = {
+      caption: formValue.caption,
+      general_prompt: formValue.general_prompt || '',
+      llm: formValue.llm,
+      intents: formValue.intents.map((intent: any) => ({
+        name: intent.name,
+        caption: intent.caption,
+        detection_prompt: intent.detection_prompt,
+        examples: Array.isArray(intent.examples) ? intent.examples : [],
+        parameters: Array.isArray(intent.parameters) ? intent.parameters : [],
+        action: intent.action,
+        fallback_timeout_prompt: intent.fallback_timeout_prompt,
+        fallback_error_prompt: intent.fallback_error_prompt
+      })),
+      last_update_date: currentVersion.last_update_date || ''
+    };
+  
+    const dialogRef = this.dialog.open(ConfirmDialogComponent, {
+      width: '500px',
+      data: {
+        title: 'Version Modified',
+        message: 'This version was modified by another user. Do you want to reload and lose your changes, or force save?',
+        confirmText: 'Force Save',
+        cancelText: 'Reload',
+        confirmColor: 'warn'
+      }
+    });
+  
+    dialogRef.afterClosed().subscribe(async (forceSave) => {
+      if (forceSave) {
+        try {
+          await this.apiService.updateVersion(
+            this.project.id, 
+            currentVersion.no, 
+            retryUpdateData,
+            true
+          ).toPromise();
+          this.snackBar.open('Version force saved', 'Close', { duration: 3000 });
+          await this.loadVersions();
+        } catch (err: any) {
+          this.snackBar.open(err.error?.detail || 'Force save failed', 'Close', { 
+            duration: 5000,
+            panelClass: 'error-snackbar'
+          });
+        }
+      } else {
+        await this.loadVersions();
+      }
+    });
+  }  
+  
+  async publishVersion() {
+    if (!this.selectedVersion) return;
+
+    const dialogRef = this.dialog.open(ConfirmDialogComponent, {
+      width: '500px',
+      data: {
+        title: 'Publish Version',
+        message: `Are you sure you want to publish version "${this.selectedVersion.caption}"? This will unpublish all other versions.`,
+        confirmText: 'Publish',
+        confirmColor: 'primary'
+      }
+    });
+
+    dialogRef.afterClosed().subscribe(async (confirmed) => {
+      if (confirmed && this.selectedVersion) {
+        this.publishing = true;
+        try {
+          await this.apiService.publishVersion(
+            this.project.id,
+            this.selectedVersion.no
+          ).toPromise();
+
+          this.snackBar.open('Version published successfully', 'Close', { duration: 3000 });
+          
+          // Reload to get updated data
+          await this.reloadProject();
+          
+        } catch (error: any) {
+          this.snackBar.open(error.error?.detail || 'Failed to publish version', 'Close', { 
+            duration: 5000,
+            panelClass: 'error-snackbar'
+          });
+        } finally {
+          this.publishing = false;
+        }
+      }
+    });
+  }
+
+  async deleteVersion() {
+    if (!this.selectedVersion || this.selectedVersion.published) return;
+
+    const dialogRef = this.dialog.open(ConfirmDialogComponent, {
+      width: '400px',
+      data: {
+        title: 'Delete Version',
+        message: `Are you sure you want to delete version "${this.selectedVersion.caption}"?`,
+        confirmText: 'Delete',
+        confirmColor: 'warn'
+      }
+    });
+
+    dialogRef.afterClosed().subscribe(async (confirmed) => {
+      if (confirmed && this.selectedVersion) {
+        try {
+          await this.apiService.deleteVersion(
+            this.project.id,
+            this.selectedVersion.no
+          ).toPromise();
+
+          this.snackBar.open('Version deleted successfully', 'Close', { duration: 3000 });
+          
+          // Reload and select another version
+          await this.reloadProject();
+          
+          if (this.versions.length > 0) {
+            this.loadVersion(this.versions[0]);
+          } else {
+            this.selectedVersion = null;
+          }
+          
+        } catch (error: any) {
+          this.snackBar.open(error.error?.detail || 'Failed to delete version', 'Close', { 
+            duration: 5000,
+            panelClass: 'error-snackbar'
+          });
+        }
+      }
+    });
+  }
+
+  async testIntentDetection() {
+    if (!this.testUserMessage.trim()) {
+      this.snackBar.open('Please enter a test message', 'Close', { duration: 3000 });
+      return;
+    }
+
+    this.testing = true;
+    this.testResult = null;
+
+    // Simulate intent detection test
+    setTimeout(() => {
+      // This is a mock - in real implementation, this would call the Spark service
+      const intents = this.versionForm.get('intents')?.value || [];
+      
+      // Simple matching for demo
+      let detectedIntent = null;
+      let confidence = 0;
+
+      for (const intent of intents) {
+        // Check examples in all locales
+        const allExamples = intent.examples || [];
+        for (const example of allExamples) {
+          const exampleText = typeof example === 'string' ? example : example.example;
+          if (this.testUserMessage.toLowerCase().includes(exampleText.toLowerCase())) {
+            detectedIntent = intent.name;
+            confidence = 0.95;
+            break;
+          }
+        }
+        if (detectedIntent) break;
+      }
+
+      // Random detection for demo
+      if (!detectedIntent && intents.length > 0) {
+        const randomIntent = intents[Math.floor(Math.random() * intents.length)];
+        detectedIntent