@zodic/shared 0.0.223 → 0.0.225

package/app/services/ConceptService.ts

@@ -1034,44 +1034,48 @@ 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 version only
-          eq(conceptsData.conceptSlug, conceptSlug), // ✅ Filter by concept
-          sql`name IN (
-            SELECT name FROM concepts_data 
+    .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 
             WHERE language = 'en-us' AND concept_slug = ${conceptSlug}
-            GROUP BY name HAVING COUNT(*) > 1
-          )`
-        )
+            GROUP BY name 
+            HAVING COUNT(*) > 1
+          )
+        `
       )
-      .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}.` };
     }
-
-    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) {
@@ -1080,59 +1084,50 @@ 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 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' },
@@ -1142,7 +1137,7 @@ export class ConceptService {
             ring: { en: 'Ring', pt: 'Anel', articlePT: 'O' },
             orb: { en: 'Orb', pt: 'Orbe', articlePT: 'O' },
           };
-
+  
           const {
             en: conceptEN,
             pt: conceptPT,
@@ -1152,90 +1147,81 @@ 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++;
       }
     }
-
-    console.log(
-      `🎉 [COMPLETE] Regenerated ${updatedEntries} duplicate names for concept: ${conceptSlug}.`
-    );
+  
+    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}`);
+  
     return {
       message: `Duplicate names processed and regenerated for ${conceptSlug}.`,
+      updated: updatedEntries,
+      skipped: skippedEntries,
+      failed: failedEntries,
+      elapsedTime,
     };
   }
 

package/package.json

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