Update flare-ui/src/app/dialogs/version-edit-dialog/version-edit-dialog.component.ts

flare-ui/src/app/dialogs/version-edit-dialog/version-edit-dialog.component.ts

@@ -17,6 +17,7 @@ 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';
@@ -59,7 +60,8 @@ interface Locale {
     MatDividerModule,
     MatProgressBarModule,
     MatListModule,
-    MatProgressSpinnerModule
+    MatProgressSpinnerModule,
+    MatBadgeModule
   ],
   templateUrl: './version-edit-dialog.component.html',
   styleUrls: ['./version-edit-dialog.component.scss']
@@ -69,13 +71,17 @@ export default class VersionEditDialogComponent implements OnInit {
   versions: Version[] = [];
   selectedVersion: Version | null = null;
   versionForm!: FormGroup;
+  
   loading = false;
   saving = false;
   publishing = false;
+  creating = false;
+  isDirty = false;
   testing = false;
-  testInput = '';
+  
+  selectedTabIndex = 0;
+  testUserMessage = '';
   testResult: any = null;
-  isDirty = false;
   
   // Multi-language support
   selectedExampleLocale: string = 'tr';
@@ -83,46 +89,66 @@ export default class VersionEditDialogComponent implements OnInit {
 
   constructor(
     private fb: FormBuilder,
-    private api: ApiService,
+    private apiService: ApiService,
     private localeService: LocaleManagerService,
     private snackBar: MatSnackBar,
     private dialog: MatDialog,
     public dialogRef: MatDialogRef<VersionEditDialogComponent>,
-    @Inject(MAT_DIALOG_DATA) public data: { project: Project }
+    @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.loadVersions();
     this.loadAvailableLocales();
+    
+    // Select the latest unpublished version or the latest version
+    const unpublished = this.versions.find(v => !v.published);
+    this.selectedVersion = unpublished || this.versions[0] || null;
+    
+    if (this.selectedVersion) {
+      this.loadVersion(this.selectedVersion);
+    }
+
+    this.versionForm.valueChanges.subscribe(() => {
+      this.isDirty = true;
+    });
   }
 
   initializeForm() {
     this.versionForm = this.fb.group({
-      caption: [''],
-      prompt: ['', Validators.required],
-      welcome_prompt: [''],
-      model: ['gpt-3.5-turbo'],
-      generation_config: this.fb.group({
-        max_new_tokens: [512],
-        temperature: [0.7],
-        top_p: [0.9],
-        top_k: [null],
-        do_sample: [true]
+      no: [{value: '', disabled: true}],
+      caption: ['', Validators.required],
+      published: [{value: false, disabled: true}],
+      general_prompt: ['', Validators.required],
+      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: ['']
       }),
-      fine_tune: this.fb.group({
-        enabled: [false],
-        adapter_path: ['']
-      }),
-      intents: this.fb.array([])
+      intents: this.fb.array([]),
+      last_update_date: ['']
     });
 
-    // Mark form as dirty on any change
-    this.versionForm.valueChanges.subscribe(() => {
-      this.isDirty = true;
+    // 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();
     });
   }
 
@@ -130,17 +156,34 @@ export default class VersionEditDialogComponent implements OnInit {
     // Get supported locales from project
     const supportedCodes = [
       this.project.default_locale,
-      ...(this.project.supported_languages || [])
+      ...(this.project.supported_locales || [])
     ].filter(Boolean);
 
     // Get locale details
     for (const code of supportedCodes) {
-      const localeInfo = await this.localeService.getLocaleDetails(code).toPromise();
-      if (localeInfo) {
-        this.availableLocales.push({
-          code: localeInfo.code,
-          name: localeInfo.name
-        });
+      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 (fallbackNames[code]) {
+          this.availableLocales.push({
+            code: code,
+            name: fallbackNames[code]
+          });
+        }
       }
     }
   }
@@ -154,101 +197,105 @@ export default class VersionEditDialogComponent implements OnInit {
     return locale?.name || localeCode;
   }
 
-  loadVersions() {
-    this.loading = true;
-    this.api.getProjectVersions(this.project.id).subscribe({
-      next: (versions) => {
-        this.versions = versions;
-        this.loading = false;
-        
-        // Auto-select if only one version
-        if (versions.length === 1) {
-          this.onVersionChange(versions[0]);
-        }
-      },
-      error: (error) => {
-        console.error('Error loading versions:', error);
-        this.snackBar.open('Failed to load versions', 'Close', { duration: 3000 });
-        this.loading = false;
-      }
-    });
-  }
-
-  onVersionChange(version: Version | null) {
-    if (!version) return;
-    
+  loadVersion(version: Version) {
     this.selectedVersion = version;
-    this.loading = true;
-    this.isDirty = false;
-    
-    this.api.getVersionDetails(this.project.id, version.no).subscribe({
-      next: (details) => {
-        this.populateForm(details);
-        this.loading = false;
-      },
-      error: (error) => {
-        console.error('Error loading version details:', error);
-        this.snackBar.open('Failed to load version details', 'Close', { duration: 3000 });
-        this.loading = false;
-      }
-    });
-  }
-
-  populateForm(version: any) {
-    // Clear existing intents
-    const intentsArray = this.versionForm.get('intents') as FormArray;
-    while (intentsArray.length > 0) {
-      intentsArray.removeAt(0);
-    }
     
-    // Populate basic fields
+    // Form değerlerini set et
     this.versionForm.patchValue({
+      no: version.no,
       caption: version.caption || '',
-      prompt: version.prompt || '',
-      welcome_prompt: version.welcome_prompt || '',
-      model: version.model || 'gpt-3.5-turbo',
-      generation_config: version.generation_config || {},
-      fine_tune: version.fine_tune || { enabled: false }
+      published: version.published || false,
+      general_prompt: (version as any).general_prompt || '',
+      last_update_date: version.last_update_date || ''
     });
-    
-    // Add intents
-    if (version.intents && Array.isArray(version.intents)) {
-      version.intents.forEach((intent: any) => {
-        intentsArray.push(this.createIntentFormGroup(intent));
+  
+    // 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);
+        
+        // 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 {
-    return this.fb.group({
-      name: [intent?.name || '', Validators.required],
-      caption: [intent?.caption || ''],
-      requiresApproval: [intent?.requiresApproval || false],
-      dependencies: [intent?.dependencies || []],
-      examples: [intent?.examples || []],
-      detection_prompt: [intent?.detection_prompt || '', Validators.required],
-      parameters: this.fb.array(
-        (intent?.parameters || []).map((p: any) => this.createParameterFormGroup(p))
-      ),
-      action: [intent?.action || ''],
-      fallback_timeout_prompt: [intent?.fallback_timeout_prompt || ''],
-      fallback_error_prompt: [intent?.fallback_error_prompt || '']
+  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 {
+  createParameterFormGroup(param: any = {}): FormGroup {
     return this.fb.group({
-      name: [param?.name || '', Validators.required],
-      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 || '']
+      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 || '']
     });
   }
 
@@ -415,8 +462,12 @@ export default class VersionEditDialogComponent implements OnInit {
     });
   }
 
-  async getAvailableAPIs() {
-    return this.api.getAPIs().toPromise();
+  async getAvailableAPIs(): Promise<any[]> {
+    try {
+      return await this.apiService.getAPIs().toPromise() || [];
+    } catch {
+      return [];
+    }
   }
 
   async createVersion() {
@@ -440,236 +491,418 @@ export default class VersionEditDialogComponent implements OnInit {
   
     dialogRef.afterClosed().subscribe(async (result) => {
       if (result?.confirmed) {
-        this.loading = true;
+        this.creating = true;
         try {
           let newVersionData;
           
           if (result.selectedValue) {
-            // Copy from selected version
+            // Copy from selected version - we need to get the full version data
             const sourceVersion = this.versions.find(v => v.no === result.selectedValue);
             if (sourceVersion) {
-              const details = await this.api.getVersionDetails(this.project.id, sourceVersion.no).toPromise();
-              newVersionData = {
-                ...details,
-                no: undefined,
-                published: false,
-                last_update_date: undefined,
-                caption: `Copy of version ${sourceVersion.no}`
-              };
+              // 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: 'New Version',
-              prompt: '',
-              welcome_prompt: '',
-              model: 'gpt-3.5-turbo',
-              generation_config: {
-                max_new_tokens: 512,
-                temperature: 0.7,
-                top_p: 0.9,
-                do_sample: true
+              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: []
             };
           }
-          
-          // Create new version
-          const newVersion = await this.api.createVersion(this.project.id, newVersionData).toPromise();
-          
-          // Reload versions and select the new one
-          await this.loadVersions();
-          this.onVersionChange(newVersion);
-          
-          this.snackBar.open('Version created successfully', 'Close', { duration: 3000 });
+  
+          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) {
-          console.error('Error creating version:', error);
           this.snackBar.open('Failed to create version', 'Close', { duration: 3000 });
         } finally {
-          this.loading = false;
+          this.creating = false;
         }
       }
     });
   }
 
-  async copyVersion() {
-    if (!this.selectedVersion) return;
+  async saveVersion() {
+    if (!this.selectedVersion || !this.canEdit) {
+      this.snackBar.open('Cannot save published version', 'Close', { duration: 3000 });
+      return;
+    }
+    
+    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;
+    
+    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 || '',
+        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();
     
+    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: '400px',
+      width: '500px',
       data: {
-        title: 'Copy Version',
-        message: `Create a copy of version ${this.selectedVersion.no}?`,
-        confirmText: 'Copy',
-        cancelText: 'Cancel'
+        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 (confirmed) => {
-      if (confirmed) {
-        this.loading = true;
+  
+    dialogRef.afterClosed().subscribe(async (forceSave) => {
+      if (forceSave) {
         try {
-          const details = await this.api.getVersionDetails(this.project.id, this.selectedVersion!.no).toPromise();
-          const copyData = {
-            ...details,
-            no: undefined,
-            published: false,
-            last_update_date: undefined,
-            caption: `Copy of version ${this.selectedVersion!.no}`
-          };
-          
-          const newVersion = await this.api.createVersion(this.project.id, copyData).toPromise();
-          
+          await this.apiService.updateVersion(
+            this.project.id, 
+            currentVersion.no, 
+            retryUpdateData,
+            true
+          ).toPromise();
+          this.snackBar.open('Version force saved', 'Close', { duration: 3000 });
           await this.loadVersions();
-          this.onVersionChange(newVersion);
-          
-          this.snackBar.open('Version copied successfully', 'Close', { duration: 3000 });
-        } catch (error) {
-          console.error('Error copying version:', error);
-          this.snackBar.open('Failed to copy version', 'Close', { duration: 3000 });
-        } finally {
-          this.loading = false;
+        } catch (err: any) {
+          this.snackBar.open(err.error?.detail || 'Force save failed', 'Close', { 
+            duration: 5000,
+            panelClass: 'error-snackbar'
+          });
         }
+      } else {
+        await this.loadVersions();
       }
     });
-  }
-
-  async compareVersions() {
-    const { default: VersionCompareDialogComponent } = await import('../version-compare-dialog/version-compare-dialog.component');
-    
-    this.dialog.open(VersionCompareDialogComponent, {
-      width: '90vw',
-      maxWidth: '1200px',
-      data: { 
-        versions: this.versions,
-        selectedVersion: this.selectedVersion
-      }
-    });
-  }
+  }  
+  
+  async publishVersion() {
+    if (!this.selectedVersion) return;
 
-  async deleteVersion() {
-    if (!this.selectedVersion || this.selectedVersion.published) return;
-    
     const dialogRef = this.dialog.open(ConfirmDialogComponent, {
-      width: '400px',
+      width: '500px',
       data: {
-        title: 'Delete Version',
-        message: `Are you sure you want to delete version ${this.selectedVersion.no}? This action cannot be undone.`,
-        confirmText: 'Delete',
-        confirmColor: 'warn'
+        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.loading = true;
+      if (confirmed && this.selectedVersion) {
+        this.publishing = true;
         try {
-          await this.api.deleteVersion(this.project.id, this.selectedVersion!.no).toPromise();
+          await this.apiService.publishVersion(
+            this.project.id,
+            this.selectedVersion.no
+          ).toPromise();
+
+          this.snackBar.open('Version published successfully', 'Close', { duration: 3000 });
           
-          this.selectedVersion = null;
-          await this.loadVersions();
+          // Reload to get updated data
+          await this.reloadProject();
           
-          this.snackBar.open('Version deleted successfully', 'Close', { duration: 3000 });
-        } catch (error) {
-          console.error('Error deleting version:', error);
-          this.snackBar.open('Failed to delete version', 'Close', { duration: 3000 });
+        } catch (error: any) {
+          this.snackBar.open(error.error?.detail || 'Failed to publish version', 'Close', { 
+            duration: 5000,
+            panelClass: 'error-snackbar'
+          });
         } finally {
-          this.loading = false;
+          this.publishing = false;
         }
       }
     });
   }
 
-  saveVersion() {
-    if (!this.selectedVersion || !this.canEdit || this.versionForm.invalid) return;
-    
-    this.saving = true;
-    const formValue = this.versionForm.value;
-    
-    this.api.updateVersion(this.project.id, this.selectedVersion.no, formValue).subscribe({
-      next: () => {
-        this.snackBar.open('Version saved successfully', 'Close', { duration: 3000 });
-        this.isDirty = false;
-        this.saving = false;
-      },
-      error: (error) => {
-        console.error('Error saving version:', error);
-        this.snackBar.open('Failed to save version', 'Close', { duration: 3000 });
-        this.saving = false;
-      }
-    });
-  }
+  async deleteVersion() {
+    if (!this.selectedVersion || this.selectedVersion.published) return;
 
-  publishVersion() {
-    if (!this.selectedVersion || this.selectedVersion.published || this.isDirty) return;
-    
     const dialogRef = this.dialog.open(ConfirmDialogComponent, {
-      width: '500px',
+      width: '400px',
       data: {
-        title: 'Publish Version',
-        message: `Publishing version ${this.selectedVersion.no} will make it the active version for all users. Published versions cannot be edited. Continue?`,
-        confirmText: 'Publish',
-        confirmColor: 'accent'
+        title: 'Delete Version',
+        message: `Are you sure you want to delete version "${this.selectedVersion.caption}"?`,
+        confirmText: 'Delete',
+        confirmColor: 'warn'
       }
     });
 
-    dialogRef.afterClosed().subscribe((confirmed) => {
-      if (confirmed) {
-        this.publishing = true;
-        
-        this.api.publishVersion(this.project.id, this.selectedVersion!.no).subscribe({
-          next: () => {
-            this.snackBar.open('Version published successfully', 'Close', { duration: 3000 });
-            this.publishing = false;
-            
-            // Reload to update status
-            this.loadVersions();
-            this.onVersionChange(this.selectedVersion);
-          },
-          error: (error) => {
-            console.error('Error publishing version:', error);
-            this.snackBar.open('Failed to publish version', 'Close', { duration: 3000 });
-            this.publishing = false;
+    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'
+          });
+        }
       }
     });
   }
 
-  testIntentDetection() {
-    if (!this.testInput || !this.selectedVersion) return;
-    
+  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(() => {
-      const intents = this.intents.value;
+      // This is a mock - in real implementation, this would call the Spark service
+      const intents = this.versionForm.get('intents')?.value || [];
       
-      // Simple simulation - in real app, this would call the backend
-      const randomIntent = intents[Math.floor(Math.random() * intents.length)];
-      
-      if (randomIntent && Math.random() > 0.3) {
-        this.testResult = {
-          intent: randomIntent.name,
-          confidence: 0.75 + Math.random() * 0.20,
-          parameters: randomIntent.parameters.map((p: any) => ({
-            name: p.name,
-            extracted: Math.random() > 0.5,
-            value: Math.random() > 0.5 ? 'Sample Value' : null
-          }))
-        };
-      } else {
-        this.testResult = {
-          intent: null,
-          confidence: 0
-        };
+      // 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 = randomIntent.name;
+        confidence = 0.65;
+      }
+
+      this.testResult = {
+        success: true,
+        intent: detectedIntent,
+        confidence: confidence,
+        parameters: detectedIntent ? this.extractTestParameters(detectedIntent) : []
+      };
+
       this.testing = false;
     }, 1500);
   }
 
+  private extractTestParameters(intentName: string): any[] {
+    // Mock parameter extraction
+    const intent = this.intents.value.find((i: any) => i.name === intentName);
+    if (!intent) return [];
+
+    return intent.parameters.map((param: any) => ({
+      name: param.name,
+      value: param.type === 'date' ? '2025-06-15' : 'test_value',
+      extracted: Math.random() > 0.3
+    }));
+  }
+
+  private async reloadProject() {
+    this.loading = true;
+    try {
+      const projects = await this.apiService.getProjects().toPromise() || [];
+      const updatedProject = projects.find(p => p.id === this.project.id);
+      
+      if (updatedProject) {
+        this.project = updatedProject;
+        this.versions = [...updatedProject.versions].sort((a, b) => b.no - a.no);
+      }
+    } catch (error) {
+      console.error('Failed to reload project:', error);
+    } finally {
+      this.loading = false;
+    }
+  }
+
+  async compareVersions() {
+    if (this.versions.length < 2) {
+      this.snackBar.open('Need at least 2 versions to compare', 'Close', { duration: 3000 });
+      return;
+    }
+  
+    const { default: VersionCompareDialogComponent } = await import('../version-compare-dialog/version-compare-dialog.component');
+    
+    this.dialog.open(VersionCompareDialogComponent, {
+      width: '90vw',
+      maxWidth: '1000px',
+      maxHeight: '80vh',
+      data: {
+        versions: this.versions,
+        selectedVersion: this.selectedVersion
+      }
+    });
+  }
+    
   close() {
     if (this.isDirty) {
       const dialogRef = this.dialog.open(ConfirmDialogComponent, {