feat: add model type management for updating config types in database + bump version + fix license in package.json

Author: Pfannkuchensack

README.md

@@ -13,6 +13,7 @@ A tool for managing and analyzing InvokeAI database entries and PNG metadata.
 - **Metadata Extraction**: Automatic extraction and storage of InvokeAI metadata
 - **Workflow Detection**: Identification and flagging of images with workflow information
 - **Model Path Management**: Management of model paths in the database
+- **Model Type Management**: Management of model types in the database
 
 ### PNG Metadata Analysis
 - **Inspection**: Detailed analysis of PNG metadata, including InvokeAI-specific chunks

index.html

@@ -65,6 +65,20 @@ <h3 data-i18n="pathReplacementTitle">Pfad-Ersetzung</h3>
           </div>
         </div>
       </div>
+      
+      <div class="type-replacement-section">
+        <h3 data-i18n="modelTypeManagementTitle">Model-Type-Verwaltung</h3>
+        <p data-i18n="selectModelsHint">Wählen Sie die Models aus, deren config-type geändert werden soll:</p>
+        <div class="replacement-inputs">
+          <div class="input-group">
+            <label for="new-type" data-i18n="newTypeLabel">Neuer Type:</label>
+            <input type="text" id="new-type" placeholder="z.B. main">
+          </div>
+        </div>
+        <div class="model-type-actions">
+          <button id="update-types-button" class="primary-button" disabled data-i18n="updateTypesButton">Ausgewählte Types aktualisieren</button>
+        </div>
+      </div>
     </div>
 
     <!-- Models-Ergebnisse -->

main.js

@@ -1063,3 +1063,106 @@ ipcMain.handle('update-model-paths', async (event, { dbPath, oldPath, newPath })
     return { success: false, message: error.message };
   }
 });
+
+// IPC-Handler für das Aktualisieren von Model-Types
+ipcMain.handle('update-model-types', async (event, { dbPath, modelIds, newType }) => {
+  try {
+    const db = new sqlite3.Database(dbPath);
+    
+    return new Promise((resolve, reject) => {
+      // Validiere die Eingaben
+      if (!modelIds || !Array.isArray(modelIds) || modelIds.length === 0) {
+        db.close();
+        resolve({ success: false, message: 'Keine Models ausgewählt.' });
+        return;
+      }
+      
+      if (!newType || newType.trim() === '') {
+        db.close();
+        resolve({ success: false, message: 'Neuer Type ist erforderlich.' });
+        return;
+      }
+      
+      // Lade die ausgewählten Models
+      const placeholders = modelIds.map(() => '?').join(',');
+      db.all(`SELECT rowid as id, name, type, config FROM models WHERE rowid IN (${placeholders}) AND config IS NOT NULL`, modelIds, (err, rows) => {
+        if (err) {
+          db.close();
+          resolve({ success: false, message: `Fehler beim Laden der Models: ${err.message}` });
+          return;
+        }
+        
+        const modelsToUpdate = [];
+        
+        // Prüfe jedes ausgewählte Model
+        for (const row of rows) {
+          try {
+            const config = JSON.parse(row.config);
+            modelsToUpdate.push({
+              id: row.id,
+              name: row.name,
+              currentType: row.type,
+              config: config
+            });
+          } catch (jsonErr) {
+            console.warn(`Fehler beim Parsen der config für Model ID ${row.id}:`, jsonErr);
+          }
+        }
+        
+        if (modelsToUpdate.length === 0) {
+          db.close();
+          resolve({ 
+            success: true, 
+            message: 'Keine gültigen Models zum Aktualisieren gefunden.',
+            updatedCount: 0
+          });
+          return;
+        }
+        
+        let updatedCount = 0;
+        let completedUpdates = 0;
+        
+        const updateModel = (model) => {
+          // Aktualisiere den type in der config
+          const updatedConfig = { ...model.config };
+          const oldConfigType = updatedConfig.type || 'unbekannt';
+          updatedConfig.type = newType;
+          
+          const updatedConfigJson = JSON.stringify(updatedConfig);
+          
+          db.run(
+            `UPDATE models SET config = ? WHERE rowid = ?`,
+            [updatedConfigJson, model.id],
+            function(updateErr) {
+              completedUpdates++;
+              
+              if (updateErr) {
+                console.error(`Fehler beim Aktualisieren von Model ${model.name}:`, updateErr);
+              } else {
+                updatedCount++;
+                console.log(`Model "${model.name}" config-type von "${oldConfigType}" zu "${newType}" geändert`);
+              }
+              
+              // Wenn alle Updates abgeschlossen sind
+              if (completedUpdates === modelsToUpdate.length) {
+                db.close();
+                resolve({
+                  success: true,
+                  message: `${updatedCount} von ${modelsToUpdate.length} Models erfolgreich aktualisiert.`,
+                  updatedCount: updatedCount,
+                  totalModels: modelsToUpdate.length
+                });
+              }
+            }
+          );
+        };
+        
+        // Starte alle Updates
+        modelsToUpdate.forEach(updateModel);
+      });
+    });
+  } catch (error) {
+    console.error('Fehler beim Aktualisieren der Model-Types:', error);
+    return { success: false, message: error.message };
+  }
+});

package.json

@@ -1,6 +1,6 @@
 {
   "name": "sqlite-electron-tool",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Electron-App zum Abgleich von InvokeAI DB mit Bilddateien",
   "main": "main.js",
   "scripts": {
@@ -14,7 +14,7 @@
     "png-analyzer": "node png-metadata-analyzer.js"
   },
   "author": "Pfannkuchensack",
-  "license": "ISC",
+  "license": "MIT",
   "devDependencies": {
     "@electron-forge/cli": "^7.8.1",
     "@electron-forge/maker-deb": "^7.8.1",

preload.js

@@ -11,7 +11,8 @@ contextBridge.exposeInMainWorld('electronAPI', {
   syncThumbnails: (params) => ipcRenderer.invoke('sync-thumbnails', params),
   restoreThumbnails: (params) => ipcRenderer.invoke('restore-thumbnails', params),
   loadModels: (params) => ipcRenderer.invoke('load-models', params),
-  updateModelPaths: (params) => ipcRenderer.invoke('update-model-paths', params)
+  updateModelPaths: (params) => ipcRenderer.invoke('update-model-paths', params),
+  updateModelTypes: (params) => ipcRenderer.invoke('update-model-types', params)
 });
 
 // Stelle die Übersetzungen im Renderer-Prozess zur Verfügung

renderer.js

@@ -39,6 +39,10 @@ const newPathInput = document.getElementById('new-path');
 const modelsList = document.getElementById('models-list');
 const modelsCount = document.getElementById('models-count');
 
+// Model-Type-Management DOM-Elemente
+const updateTypesButton = document.getElementById('update-types-button');
+const newTypeInput = document.getElementById('new-type');
+
 // Feste Werte für Tabelle und Spalte
 const MODELS_TABLE = 'models';
 const PATH_COLUMN = 'path';
@@ -371,6 +375,67 @@ updatePathsButton.addEventListener('click', async () => {
   }
 });
 
+// Event-Handler für Model-Type-Update
+updateTypesButton.addEventListener('click', async () => {
+  try {
+    if (!dbPath) {
+      setStatus(window.translations[currentLanguage].noDbSelected || 'Bitte wählen Sie zuerst eine Datenbank aus.', true);
+      return;
+    }
+    
+    const newType = newTypeInput.value.trim();
+    
+    if (!newType) {
+      setStatus(window.translations[currentLanguage].newTypeRequired || 'Bitte geben Sie den neuen Type ein.', true);
+      return;
+    }
+    
+    // Sammle die ausgewählten Model-IDs
+    const selectedModelIds = [];
+    const checkboxes = document.querySelectorAll('.model-checkbox:checked');
+    
+    checkboxes.forEach(checkbox => {
+      const index = parseInt(checkbox.id.replace('model-', ''));
+      if (modelsData[index] && modelsData[index].id) {
+        selectedModelIds.push(modelsData[index].id);
+      }
+    });
+    
+    if (selectedModelIds.length === 0) {
+      setStatus(window.translations[currentLanguage].noModelsSelected || 'Bitte wählen Sie mindestens ein Model aus.', true);
+      return;
+    }
+    
+    // Bestätigungsdialog
+    const confirmMessage = (window.translations[currentLanguage].confirmUpdateTypes || 'Möchten Sie wirklich den config-type von {count} ausgewählten Models zu "{newType}" ändern?')
+      .replace('{count}', selectedModelIds.length)
+      .replace('{newType}', newType);
+    
+    if (!confirm(confirmMessage)) {
+      return;
+    }
+    
+    setStatus(window.translations[currentLanguage].updatingTypes || 'Aktualisiere Model-Types...');
+    
+    const result = await window.electronAPI.updateModelTypes({
+      dbPath: dbPath,
+      modelIds: selectedModelIds,
+      newType: newType
+    });
+    
+    if (result.success) {
+      setStatus(window.translations[currentLanguage].typesUpdated + ` (${result.updatedCount} von ${selectedModelIds.length} Models aktualisiert)`);
+      // Models neu laden um aktualisierte Types anzuzeigen
+      loadModelsButton.click();
+    } else {
+      setStatus(result.message, true);
+    }
+    
+  } catch (error) {
+    setStatus(`Fehler beim Aktualisieren der Model-Types: ${error.message}`, true);
+  }
+});
+
 // Hilfsfunktion zum Anzeigen der Models
 function displayModels() {
   if (!modelsData || modelsData.length === 0) {
@@ -400,9 +465,17 @@ function displayModels() {
 
     const modelInfo = document.createElement('div');
     modelInfo.className = 'model-info';
+    
+    // Extrahiere config-Type falls vorhanden
+    let configType = 'Unbekannt';
+    if (model.config && model.config.type) {
+      configType = model.config.type;
+    }
+    
     modelInfo.innerHTML = `
       <strong>${model.name || 'Unbenannt'}</strong><br>
-      <span>Typ: ${model.type || 'Unbekannt'}</span><br>
+      <span>DB-Typ: ${model.type || 'Unbekannt'}</span><br>
+      <span>Config-Typ: ${configType}</span><br>
       <span>Pfad: ${model.path || 'Kein Pfad'}</span>
     `;
 
@@ -418,6 +491,7 @@ function updateSyncButtonState() {
   syncButton.disabled = !dbPath || !outputDir;
   syncThumbnailsButton.disabled = !dbPath || !outputDir;
   loadModelsButton.disabled = !dbPath;
+  updateTypesButton.disabled = !dbPath;
 }
 
 // Hilfsfunktion zum Anzeigen der Synchronisierungsergebnisse

styles.css

@@ -250,6 +250,18 @@ button:disabled {
   color: #2c3e50;
 }
 
+.model-type-actions {
+  margin-top: 15px;
+  display: flex;
+  gap: 10px;
+}
+
+.type-replacement-section {
+  margin-top: 20px;
+  padding-top: 20px;
+  border-top: 1px solid #eee;
+}
+
 #status-bar {
   background-color: #2c3e50;
   color: white;

translations.js

@@ -69,6 +69,17 @@ const translationsjs = {
     oldPathRequired: 'Bitte geben Sie den alten Pfad ein.',
     newPathRequired: 'Bitte geben Sie den neuen Pfad ein.',
 
+    // Model Type Management
+    modelTypeManagementTitle: 'Model-Type-Verwaltung',
+    updateTypesButton: 'Ausgewählte Types aktualisieren',
+    selectModelsHint: 'Wählen Sie die Models aus, deren config-type geändert werden soll:',
+    newTypeLabel: 'Neuer Type:',
+    updatingTypes: 'Aktualisiere Model-Types...',
+    typesUpdated: 'Model-Types wurden erfolgreich aktualisiert.',
+    noModelsSelected: 'Bitte wählen Sie mindestens ein Model aus.',
+    confirmUpdateTypes: 'Möchten Sie wirklich den config-type von {count} ausgewählten Models zu "{newType}" ändern?',
+    newTypeRequired: 'Bitte geben Sie den neuen Type ein.',
+    
     // Sprachauswahl
     languageLabel: 'Sprache:',
     languageDE: 'Deutsch',
@@ -143,6 +154,17 @@ const translationsjs = {
     oldPathRequired: 'Please enter the old path.',
     newPathRequired: 'Please enter the new path.',
 
+    // Model Type Management
+    modelTypeManagementTitle: 'Model Type Management',
+    updateTypesButton: 'Update Selected Types',
+    selectModelsHint: 'Select the models whose config-type should be changed:',
+    newTypeLabel: 'New Type:',
+    updatingTypes: 'Updating model types...',
+    typesUpdated: 'Model types updated successfully.',
+    noModelsSelected: 'Please select at least one model.',
+    confirmUpdateTypes: 'Do you really want to change the config-type of {count} selected models to "{newType}"?',
+    newTypeRequired: 'Please enter the new type.',
+    
     // Language selection
     languageLabel: 'Language:',
     languageDE: 'German',