@zodic/shared 0.0.225 → 0.0.226

package/app/services/ConceptService.ts

@@ -1034,27 +1034,29 @@ export class ConceptService {
     conceptSlug: Concept,
     maxEntries?: number
   ) {
-    console.log(`🔄 [START] Regenerating duplicate names for concept: ${conceptSlug}...`);
+    console.log(
+      `🔄 [START] Regenerating duplicate names for concept: ${conceptSlug}...`
+    );
     const startTime = Date.now();
-  
+
     const db = drizzle(this.context.env.DB);
-  
+
     // ✅ Step 1: Fetch duplicate entries filtered by conceptSlug
     console.log(`📡 Fetching duplicate entries for concept: ${conceptSlug}...`);
-  
+
     const duplicateEntries = await db
-    .select({
-      id: conceptsData.id,
-      name: conceptsData.name,
-      description: conceptsData.description,
-      combination: conceptsData.combination,
-    })
-    .from(conceptsData)
-    .where(
-      and(
-        eq(conceptsData.language, 'en-us'), // ✅ English only
-        eq(conceptsData.conceptSlug, conceptSlug), // ✅ Filter by concept
-        sql`
+      .select({
+        id: conceptsData.id,
+        name: conceptsData.name,
+        description: conceptsData.description,
+        combination: conceptsData.combination,
+      })
+      .from(conceptsData)
+      .where(
+        and(
+          eq(conceptsData.language, 'en-us'), // ✅ English only
+          eq(conceptsData.conceptSlug, conceptSlug), // ✅ Filter by concept
+          sql`
           name IN (
             SELECT name 
             FROM concepts_data 
@@ -1063,19 +1065,24 @@ export class ConceptService {
             HAVING COUNT(*) > 1
           )
         `
+        )
       )
-    )
-    .orderBy(conceptsData.name) // ✅ Order by name for better grouping
-    .limit(maxEntries || 50) // ✅ Apply optional limit
-    .execute();
-    
+      .orderBy(conceptsData.name) // ✅ Order by name for better grouping
+      .limit(maxEntries || 50) // ✅ Apply optional limit
+      .execute();
+
     if (!duplicateEntries.length) {
       console.log(`🎉 No duplicates found for ${conceptSlug}.`);
-      return { message: `No duplicates detected for ${conceptSlug}.` };
+      return {
+        message: `No duplicates detected for ${conceptSlug}.`,
+        remainingDuplicates: 0,
+      };
     }
-  
-    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) {
@@ -1084,50 +1091,60 @@ export class ConceptService {
       }
       duplicateGroups.get(entry.name)!.push(entry);
     }
-  
+
     let recentDuplicates = new Set<string>(); // ✅ Track newly generated names
     let updatedEntries = 0;
     let skippedEntries = 0;
     let failedEntries = 0;
-  
+
     for (const [duplicateName, entries] of duplicateGroups.entries()) {
-      console.log(`🔄 Processing duplicate group: "${duplicateName}" with ${entries.length} occurrences`);
-  
+      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 a new name...`);
-  
+          console.log(
+            `📡 Attempt ${attempts}/${maxAttempts} - Requesting AI for a 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, {});
-  
+          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.`);
+            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' },
@@ -1137,7 +1154,7 @@ export class ConceptService {
             ring: { en: 'Ring', pt: 'Anel', articlePT: 'O' },
             orb: { en: 'Orb', pt: 'Orbe', articlePT: 'O' },
           };
-  
+
           const {
             en: conceptEN,
             pt: conceptPT,
@@ -1147,80 +1164,120 @@ export class ConceptService {
             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 (.+)`));
-  
+          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...`);
+            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}"`);
-  
+
+          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
         }
-  
+
         if (!newNameEN || !newNamePT) {
-          console.error(`🚨 Failed to generate a unique name for ID ${id} after ${maxAttempts} attempts.`);
+          console.error(
+            `🚨 Failed to generate a unique name for ID ${id} after ${maxAttempts} attempts.`
+          );
           failedEntries++;
           continue;
         }
-  
-        console.log(`✅ Updating names: EN - "${newNameEN}", PT - "${newNamePT}"`);
-  
+
+        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')))
+          .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')))
+          .where(
+            and(eq(conceptsData.id, ptId), eq(conceptsData.language, 'pt-br'))
+          )
           .execute();
-  
-        console.log(`📝 Updated IDs: EN (${id}) -> "${newNameEN}", PT (${ptId}) -> "${newNamePT}"`);
-  
+
+        console.log(
+          `📝 Updated IDs: EN (${id}) -> "${newNameEN}", PT (${ptId}) -> "${newNamePT}"`
+        );
+
         updatedEntries++;
       }
     }
-  
+
     const elapsedTime = ((Date.now() - startTime) / 1000).toFixed(2);
-  
+
     console.log(`🎉 [COMPLETE] Regeneration finished in ${elapsedTime}s.`);
     console.log(`✅ Successfully updated: ${updatedEntries}`);
     console.log(`⚠️ Skipped (already unique): ${skippedEntries}`);
     console.log(`🚨 Failed attempts: ${failedEntries}`);
-  
+
+    const remainingDuplicates = await db
+      .select({ count: sql<number>`COUNT(*)` }) // ✅ Count only duplicates
+      .from(conceptsData)
+      .where(
+        and(
+          eq(conceptsData.conceptSlug, conceptSlug), // ✅ Filter by concept
+          sql`name IN (
+          SELECT name FROM concepts_data 
+          WHERE concept_slug = ${conceptSlug}
+          GROUP BY name 
+          HAVING COUNT(*) > 1
+        )`
+        )
+      )
+      .execute()
+      .then((res) => res[0]?.count || 0);
+
+    console.log(
+      `🔄 Remaining duplicates for ${conceptSlug}: ${remainingDuplicates}`
+    );
+
     return {
       message: `Duplicate names processed and regenerated for ${conceptSlug}.`,
       updated: updatedEntries,
       skipped: skippedEntries,
       failed: failedEntries,
+      remainingDuplicates,
       elapsedTime,
     };
   }

package/package.json

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