@zodic/shared 0.0.221 → 0.0.223

package/app/services/ConceptService.ts

@@ -3,10 +3,12 @@ import {
   KVNamespaceListResult,
 } from '@cloudflare/workers-types';
 import { and, eq, sql } from 'drizzle-orm';
+import { drizzle } from 'drizzle-orm/d1';
 import { inject, injectable } from 'inversify';
 import 'reflect-metadata';
 import { v4 as uuidv4 } from 'uuid';
 import { schema } from '../..';
+import { conceptsData } from '../../db/schema';
 import { Concept, ControlNetConfig, Languages } from '../../types';
 import {
   KVConcept,
@@ -16,8 +18,6 @@ import {
 import { leonardoInitImages } from '../../utils/initImages';
 import { buildConceptKVKey } from '../../utils/KVKeysBuilders';
 import { AppContext } from '../base/AppContext';
-import { drizzle } from 'drizzle-orm/d1';
-import { conceptsData } from '../../db/schema';
 
 @injectable()
 export class ConceptService {
@@ -1030,11 +1030,16 @@ export class ConceptService {
     };
   }
 
-  async regenerateDuplicateNamesForConcept(conceptSlug: Concept, maxEntries?: number) {
-    console.log(`🔄 [START] Regenerating duplicate names for concept: ${conceptSlug}...`);
-  
+  async regenerateDuplicateNamesForConcept(
+    conceptSlug: Concept,
+    maxEntries?: number
+  ) {
+    console.log(
+      `🔄 [START] Regenerating duplicate names for concept: ${conceptSlug}...`
+    );
+
     const db = drizzle(this.context.env.DB);
-  
+
     // ✅ Step 1: Fetch duplicate entries filtered by conceptSlug
     const duplicateEntries = await db
       .select({
@@ -1057,131 +1062,178 @@ export class ConceptService {
       )
       .limit(maxEntries || 50) // ✅ Apply optional limit
       .execute();
-  
+
     if (!duplicateEntries.length) {
       console.log(`🎉 No duplicates found for ${conceptSlug}.`);
       return { message: `No duplicates detected for ${conceptSlug}.` };
     }
-  
-    console.log(`🔍 Found ${duplicateEntries.length} duplicate entries to process.`);
-  
+
+    console.log(
+      `🔍 Found ${duplicateEntries.length} duplicate entries to process.`
+    );
+
+    // ✅ Group duplicates by name
+    const duplicateGroups = new Map<string, typeof duplicateEntries>();
+    for (const entry of duplicateEntries) {
+      if (!duplicateGroups.has(entry.name)) {
+        duplicateGroups.set(entry.name, []);
+      }
+      duplicateGroups.get(entry.name)!.push(entry);
+    }
+
     let recentDuplicates = new Set<string>(); // ✅ Track newly generated names
     let updatedEntries = 0;
-  
-    for (const entry of duplicateEntries) {
-      const { id, name, description, combination } = entry;
-  
-      console.log(`🎭 Processing duplicate ID ${id}: "${name}"`);
-  
-      let newNameEN: string | null = null;
-      let newNamePT: string | null = null;
-      let attempts = 0;
-      const maxAttempts = 3;
-  
-      while (attempts < maxAttempts) {
-        attempts++;
-  
-        console.log(`📡 Attempt ${attempts}/${maxAttempts} - Requesting AI for new name...`);
-  
-        // ✅ Generate a new name, passing dynamically tracked duplicates
-        const messages = this.context.buildLLMMessages().regenerateConceptName({
-          conceptSlug,
-          oldNameEN: name,
-          description,
-          recentNames: Array.from(recentDuplicates),
-        });
-  
-        const aiResponse = await this.context.api().callTogether.single(messages, {});
-  
-        if (!aiResponse) {
-          console.warn(`⚠️ AI failed to generate a new name for ID ${id}, skipping.`);
-          break;
+
+    for (const [duplicateName, entries] of duplicateGroups.entries()) {
+      console.log(
+        `🔄 Processing duplicate group: "${duplicateName}" with ${entries.length} occurrences`
+      );
+
+      // ✅ Leave the first entry unchanged and only process the extras
+      const [keepEntry, ...entriesToProcess] = entries;
+      console.log(`✅ Keeping original name for ID: ${keepEntry.id}`);
+
+      for (const entry of entriesToProcess) {
+        const { id, description, combination } = entry;
+
+        console.log(`🎭 Processing duplicate ID ${id}: "${duplicateName}"`);
+
+        let newNameEN: string | null = null;
+        let newNamePT: string | null = null;
+        let attempts = 0;
+        const maxAttempts = 3;
+
+        while (attempts < maxAttempts) {
+          attempts++;
+
+          console.log(
+            `📡 Attempt ${attempts}/${maxAttempts} - Requesting AI for new name...`
+          );
+
+          // ✅ Generate a new name, passing dynamically tracked duplicates
+          const messages = this.context
+            .buildLLMMessages()
+            .regenerateConceptName({
+              conceptSlug,
+              oldNameEN: duplicateName,
+              description,
+              recentNames: Array.from(recentDuplicates),
+            });
+
+          const aiResponse = await this.context
+            .api()
+            .callTogether.single(messages, {});
+
+          if (!aiResponse) {
+            console.warn(
+              `⚠️ AI failed to generate a new name for ID ${id}, skipping.`
+            );
+            break;
+          }
+
+          console.log(`📝 Raw AI Response:\n${aiResponse}`);
+
+          // ✅ Mapping for concept names with proper PT articles
+          const conceptMapping = {
+            amulet: { en: 'Amulet', pt: 'Amuleto', articlePT: 'O' },
+            crown: { en: 'Crown', pt: 'Coroa', articlePT: 'A' },
+            scepter: { en: 'Scepter', pt: 'Cetro', articlePT: 'O' },
+            lantern: { en: 'Lantern', pt: 'Candeia', articlePT: 'A' },
+            ring: { en: 'Ring', pt: 'Anel', articlePT: 'O' },
+            orb: { en: 'Orb', pt: 'Orbe', articlePT: 'O' },
+          };
+
+          const {
+            en: conceptEN,
+            pt: conceptPT,
+            articlePT,
+          } = conceptMapping[conceptSlug] || {
+            en: conceptSlug,
+            pt: conceptSlug,
+            articlePT: 'O', // Default to "O" if concept is missing
+          };
+
+          // ✅ Strict regex matching for English and Portuguese
+          const enMatch = aiResponse.match(
+            new RegExp(`EN:\\s*The ${conceptEN} of (.+)`)
+          );
+          const ptMatch = aiResponse.match(
+            new RegExp(`PT:\\s*${articlePT} ${conceptPT} de (.+)`)
+          );
+
+          if (!enMatch || !ptMatch) {
+            console.error(
+              `❌ Invalid AI response format for ID ${id}, retrying...`
+            );
+            continue;
+          }
+
+          newNameEN = `The ${conceptEN} of ${enMatch[1].trim()}`;
+          newNamePT = `${articlePT} ${conceptPT} de ${ptMatch[1].trim()}`;
+
+          console.log(
+            `🎨 Extracted Names: EN - "${newNameEN}", PT - "${newNamePT}"`
+          );
+
+          // ✅ Check if the new name is already in use in D1 before updating
+          const existingEntry = await db
+            .select({ id: conceptsData.id })
+            .from(conceptsData)
+            .where(eq(conceptsData.name, newNameEN))
+            .execute();
+
+          if (existingEntry.length > 0 || recentDuplicates.has(newNameEN)) {
+            console.warn(`⚠️ Duplicate detected: "${newNameEN}", retrying...`);
+            continue;
+          }
+
+          recentDuplicates.add(newNameEN);
+          break; // ✅ Found a valid new name
         }
-  
-        console.log(`📝 Raw AI Response:\n${aiResponse}`);
-  
-        // ✅ Mapping for concept names with proper PT articles
-        const conceptMapping = {
-          amulet: { en: "Amulet", pt: "Amuleto", articlePT: "O" },
-          crown: { en: "Crown", pt: "Coroa", articlePT: "A" },
-          scepter: { en: "Scepter", pt: "Cetro", articlePT: "O" },
-          lantern: { en: "Lantern", pt: "Candeia", articlePT: "A" },
-          ring: { en: "Ring", pt: "Anel", articlePT: "O" },
-          orb: { en: "Orb", pt: "Orbe", articlePT: "O" },
-        };
-  
-        const { en: conceptEN, pt: conceptPT, articlePT } = conceptMapping[conceptSlug] || {
-          en: conceptSlug,
-          pt: conceptSlug,
-          articlePT: "O", // Default to "O" if concept is missing
-        };
-  
-        // ✅ Strict regex matching for English and Portuguese
-        const enMatch = aiResponse.match(new RegExp(`EN:\\s*The ${conceptEN} of (.+)`));
-        const ptMatch = aiResponse.match(new RegExp(`PT:\\s*${articlePT} ${conceptPT} de (.+)`));
-  
-        if (!enMatch || !ptMatch) {
-          console.error(`❌ Invalid AI response format for ID ${id}, retrying...`);
+
+        if (!newNameEN || !newNamePT) {
+          console.error(
+            `🚨 Failed to generate a unique name for ID ${id} after ${maxAttempts} attempts.`
+          );
           continue;
         }
-  
-        newNameEN = `The ${conceptEN} of ${enMatch[1].trim()}`;
-        newNamePT = `${articlePT} ${conceptPT} de ${ptMatch[1].trim()}`;
-  
-        console.log(`🎨 Extracted Names: EN - "${newNameEN}", PT - "${newNamePT}"`);
-  
-        // ✅ Check if the new name is already in use in D1 before updating
-        const existingEntry = await db
-          .select({ id: conceptsData.id })
-          .from(conceptsData)
+
+        console.log(
+          `✅ Updating names: EN - "${newNameEN}", PT - "${newNamePT}"`
+        );
+
+        // ✅ Update English name using the ID
+        await db
+          .update(conceptsData)
+          .set({ name: newNameEN })
           .where(
-            and(
-              eq(conceptsData.language, 'en-us'),
-              eq(conceptsData.name, newNameEN),
-              eq(conceptsData.conceptSlug, conceptSlug)
-            )
+            and(eq(conceptsData.id, id), eq(conceptsData.language, 'en-us'))
           )
           .execute();
-  
-        if (existingEntry.length > 0 || recentDuplicates.has(newNameEN)) {
-          console.warn(`⚠️ Duplicate detected: "${newNameEN}", retrying...`);
-          continue;
-        }
-  
-        recentDuplicates.add(newNameEN);
-        break; // ✅ Found a valid new name
-      }
-  
-      if (!newNameEN || !newNamePT) {
-        console.error(`🚨 Failed to generate a unique name for ID ${id} after ${maxAttempts} attempts.`);
-        continue;
+
+        // ✅ Convert English ID to Portuguese ID by replacing `:en-us:` with `:pt-br:`
+        const ptId = id.replace(':en-us:', ':pt-br:');
+
+        // ✅ Update Portuguese name using the derived PT ID
+        await db
+          .update(conceptsData)
+          .set({ name: newNamePT })
+          .where(
+            and(eq(conceptsData.id, ptId), eq(conceptsData.language, 'pt-br'))
+          )
+          .execute();
+
+        console.log(
+          `📝 Updated IDs: EN (${id}) -> "${newNameEN}", PT (${ptId}) -> "${newNamePT}"`
+        );
+
+        updatedEntries++;
       }
-  
-      console.log(`✅ Updating names: EN - "${newNameEN}", PT - "${newNamePT}"`);
-  
-      // ✅ Update English name using the ID
-      await db
-        .update(conceptsData)
-        .set({ name: newNameEN })
-        .where(and(eq(conceptsData.id, id), eq(conceptsData.language, 'en-us')))
-        .execute();
-  
-      // ✅ Convert English ID to Portuguese ID by replacing `:en-us:` with `:pt-br:`
-      const ptId = id.replace(':en-us:', ':pt-br:');
-  
-      // ✅ Update Portuguese name using the derived PT ID
-      await db
-        .update(conceptsData)
-        .set({ name: newNamePT })
-        .where(and(eq(conceptsData.id, ptId), eq(conceptsData.language, 'pt-br')))
-        .execute();
-  
-      console.log(`📝 Updated IDs: EN (${id}) -> "${newNameEN}", PT (${ptId}) -> "${newNamePT}"`);
-  
-      updatedEntries++;
     }
-  
-    console.log(`🎉 [COMPLETE] Regenerated ${updatedEntries} duplicate names for concept: ${conceptSlug}.`);
+
+    console.log(
+      `🎉 [COMPLETE] Regenerated ${updatedEntries} duplicate names for concept: ${conceptSlug}.`
+    );
     return {
       message: `Duplicate names processed and regenerated for ${conceptSlug}.`,
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zodic/shared",
-  "version": "0.0.221",
+  "version": "0.0.223",
   "module": "index.ts",
   "type": "module",
   "publishConfig": {