@zodic/shared 0.0.210 → 0.0.212

package/app/services/ConceptService.ts

@@ -29,67 +29,80 @@ export class ConceptService {
     combinationString: string,
     override: boolean = false
   ): Promise<void> {
-    console.log(`🚀 Generating basic info for concept: ${conceptSlug}, combination: ${combinationString}, override: ${override}`);
-  
+    console.log(
+      `🚀 Generating basic info for concept: ${conceptSlug}, combination: ${combinationString}, override: ${override}`
+    );
+
     const kvStore = this.context.kvConceptsStore();
     const kvFailuresStore = this.context.kvConceptFailuresStore();
     const kvKeyEN = buildConceptKVKey('en-us', conceptSlug, combinationString);
     const kvKeyPT = buildConceptKVKey('pt-br', conceptSlug, combinationString);
-  
+
     // ✅ Use Durable Object stub
     const id = this.context.env.CONCEPT_NAMES_DO.idFromName(conceptSlug);
     const stub = this.context.env.CONCEPT_NAMES_DO.get(id);
-  
+
     console.log(`📡 Fetching existing KV data for ${conceptSlug}...`);
     const existingEN = await this.getKVConcept(kvKeyEN);
     const existingPT = await this.getKVConcept(kvKeyPT);
-  
+
     if (!override && existingEN.name && existingPT.name) {
       console.log(`⚡ Basic info already exists for ${conceptSlug}, skipping.`);
       return;
     }
-  
+
     let attempts = 0;
     const maxAttempts = 3;
     const MAX_NAME_LENGTH = 44;
-  
+
     while (attempts < maxAttempts) {
       let phase = 'generation';
       try {
         attempts++;
-        console.log(`🔄 Attempt ${attempts} to generate basic info for ${conceptSlug}...`);
-  
+        console.log(
+          `🔄 Attempt ${attempts} to generate basic info for ${conceptSlug}...`
+        );
+
         let allNamesEN: string[] = [];
         let allNamesPT: string[] = [];
         const response = await stub.fetch(`https://internal/names`);
-  
+
         if (response.ok) {
-          const data = (await response.json()) as { 'en-us': string[]; 'pt-br': string[] };
+          const data = (await response.json()) as {
+            'en-us': string[];
+            'pt-br': string[];
+          };
           allNamesEN = data['en-us'] || [];
           allNamesPT = data['pt-br'] || [];
         }
-  
+
         console.log(`✏️ Generating new name...`);
-        const messages = this.context.buildLLMMessages().generateConceptBasicInfo({
-          combination: combinationString,
-          conceptSlug,
-          existingNames: allNamesEN.length > 100 ? allNamesEN.slice(-100) : allNamesEN,
-        });
-  
-        let aiResponse = await this.context.api().callTogether.single(messages, {});
+        const messages = this.context
+          .buildLLMMessages()
+          .generateConceptBasicInfo({
+            combination: combinationString,
+            conceptSlug,
+            existingNames:
+              allNamesEN.length > 100 ? allNamesEN.slice(-100) : allNamesEN,
+          });
+
+        let aiResponse = await this.context
+          .api()
+          .callTogether.single(messages, {});
         if (!aiResponse) throw new Error(`❌ AI returned an empty response`);
-  
+
         phase = 'cleaning';
         aiResponse = this.cleanAIResponse(aiResponse);
 
-        console.log("!-- aiResponse -> ", aiResponse)
-        console.log("!-- aiResponse length -> ", aiResponse.length)
-  
+        console.log('!-- aiResponse -> ', aiResponse);
+        console.log('!-- aiResponse length -> ', aiResponse.length);
+
         phase = 'parsing';
-        let { nameEN, descriptionEN, poemEN, namePT, descriptionPT, poemPT } = this.parseBasicInfoResponse(aiResponse, conceptSlug);
-  
+        let { nameEN, descriptionEN, poemEN, namePT, descriptionPT, poemPT } =
+          this.parseBasicInfoResponse(aiResponse, conceptSlug);
+
         console.log(`🎭 Generated names: EN - "${nameEN}", PT - "${namePT}"`);
-  
+
         // ✅ Forcefully trim the name to exactly 5 words if it's too long
         const enforceWordLimit = (name: string): string => {
           const words = name.split(/\s+/);
@@ -98,40 +111,66 @@ export class ConceptService {
           }
           return name;
         };
-  
+
         nameEN = enforceWordLimit(nameEN);
         namePT = enforceWordLimit(namePT);
-  
+
         console.log(`✂️ Trimmed names: EN - "${nameEN}", PT - "${namePT}"`);
-  
+
         // ✅ Check uniqueness before storing
         if (allNamesEN.includes(nameEN) || allNamesPT.includes(namePT)) {
-          console.warn(`⚠️ Duplicate Name Detected: "${nameEN}" or "${namePT}"`);
+          console.warn(
+            `⚠️ Duplicate Name Detected: "${nameEN}" or "${namePT}"`
+          );
           if (attempts >= maxAttempts) {
-            console.log(`🚨 Max attempts reached. Storing name despite duplicate.`);
+            console.log(
+              `🚨 Max attempts reached. Storing name despite duplicate.`
+            );
             await kvFailuresStore.put(
               `failures:duplicates:${conceptSlug}:${combinationString}`,
-              JSON.stringify({ nameEN, namePT, attempts, conceptSlug, combinationString, timestamp: new Date().toISOString() })
+              JSON.stringify({
+                nameEN,
+                namePT,
+                attempts,
+                conceptSlug,
+                combinationString,
+                timestamp: new Date().toISOString(),
+              })
             );
             break;
           }
           continue;
         }
-  
+
         console.log(`📝 Storing names in Durable Object...`);
         // await stub.fetch(`https://internal/add-name`, { method: 'POST', body: JSON.stringify({ language: 'en-us', name: nameEN }), headers: { 'Content-Type': 'application/json' } });
         // await stub.fetch(`https://internal/add-name`, { method: 'POST', body: JSON.stringify({ language: 'pt-br', name: namePT }), headers: { 'Content-Type': 'application/json' } });
-  
-        Object.assign(existingEN, { name: nameEN, description: descriptionEN, poem: poemEN, status: 'idle' });
+
+        Object.assign(existingEN, {
+          name: nameEN,
+          description: descriptionEN,
+          poem: poemEN,
+          status: 'idle',
+        });
         await kvStore.put(kvKeyEN, JSON.stringify(existingEN));
-  
-        Object.assign(existingPT, { name: namePT, description: descriptionPT, poem: poemPT, status: 'idle' });
+
+        Object.assign(existingPT, {
+          name: namePT,
+          description: descriptionPT,
+          poem: poemPT,
+          status: 'idle',
+        });
         await kvStore.put(kvKeyPT, JSON.stringify(existingPT));
-  
-        console.log(`✅ Stored basic info for ${conceptSlug}, combination: ${combinationString}.`);
+
+        console.log(
+          `✅ Stored basic info for ${conceptSlug}, combination: ${combinationString}.`
+        );
         return;
       } catch (error) {
-        console.error(`❌ Attempt ${attempts} failed at phase: ${phase}`, error);
+        console.error(
+          `❌ Attempt ${attempts} failed at phase: ${phase}`,
+          error
+        );
       }
     }
   }
@@ -157,18 +196,22 @@ export class ConceptService {
     descriptionPT: string;
     poemPT: string[];
   } {
-    console.log('📌 Parsing basic info response from ChatGPT:', response);
+    console.log('📌 Received AI response for parsing:', response);
 
     // ✅ More flexible regex to handle variations in formatting
+    console.log('🔎 Attempting to match English section...');
     const enMatch = response.match(
       /EN:\s*(?:•\s*)?Name:\s*(.+?)\s*(?:•\s*)?Description:\s*([\s\S]+?)\s*(?:•\s*)?Poetic Passage:\s*([\s\S]+?)\s*(?=PT:|$)/
     );
+
+    console.log('🔎 Attempting to match Portuguese section...');
     const ptMatch = response.match(
       /PT:\s*(?:•\s*)?Nome:\s*(.+?)\s*(?:•\s*)?Descrição:\s*([\s\S]+?)\s*(?:•\s*)?Passagem Poética:\s*([\s\S]+)/
     );
 
     if (!enMatch || !ptMatch) {
       console.error('❌ Invalid basic info response format:', response);
+      console.log('❌ Regex match results:', { enMatch, ptMatch });
       throw new Error('Invalid basic info response format');
     }
 
@@ -176,14 +219,15 @@ export class ConceptService {
     const cleanText = (text: string) => text.trim().replace(/\*/g, '');
 
     // ✅ Parse and clean extracted content
+    console.log('✂️ Extracting and cleaning English content...');
     const nameEN = cleanText(enMatch[1]);
     const descriptionEN = cleanText(enMatch[2]);
     const poemEN = enMatch[3]
       .trim()
       .split(/\n+/)
       .map((line) => cleanText(line));
-    
 
+    console.log('✂️ Extracting and cleaning Portuguese content...');
     const namePT = cleanText(ptMatch[1]);
     const descriptionPT = cleanText(ptMatch[2]);
     const poemPT = ptMatch[3]
@@ -191,6 +235,15 @@ export class ConceptService {
       .split(/\n+/)
       .map((line) => cleanText(line));
 
+    console.log('📌 Extracted values before processing:', {
+      nameEN,
+      descriptionEN,
+      poemEN,
+      namePT,
+      descriptionPT,
+      poemPT,
+    });
+
     // ✅ Determine appropriate replacement text based on conceptSlug
     const conceptPlaceholder = `this ${
       conceptSlug.charAt(0).toUpperCase() + conceptSlug.slice(1)
@@ -210,15 +263,18 @@ export class ConceptService {
     };
 
     // ✅ Ensure the concept name is not repeated in the description
+    console.log('🔄 Replacing concept name in descriptions...');
     const cleanedDescriptionEN = replaceConceptName(descriptionEN, nameEN);
     const cleanedDescriptionPT = replaceConceptName(descriptionPT, namePT);
 
     // ✅ If the name appears in the poem, trigger a retry
+    console.log('🔍 Checking for concept name in poems...');
     if (
       poemEN.some((line) => line.includes(nameEN)) ||
       poemPT.some((line) => line.includes(namePT))
     ) {
       console.error('❌ Concept name detected in poem, triggering a retry.');
+      console.log('❌ Problematic lines:', { poemEN, poemPT });
       throw new Error('Concept name found in poem, regenerating response.');
     }
 
@@ -791,361 +847,319 @@ export class ConceptService {
     };
   }
 
-  async regenerateDuplicateNames(limit?: number) {
-    console.log(`🔄 Processing duplicate names for regeneration...`);
-
-    const { duplicateEntries, usedNamesEN, usedNamesPT } =
-      await this.findDuplicateNamesAndUsedNames(limit);
-
-    if (duplicateEntries.length === 0) {
-      console.log(`🎉 No duplicates found. Nothing to regenerate.`);
-      return { message: 'No duplicates detected.' };
-    }
-
-    for (const { name: oldNameEN, combinations } of duplicateEntries) {
-      for (let i = 1; i < combinations.length; i++) {
-        const [_, lang, conceptSlug, combinationString] =
-          combinations[i].split(':');
-
-        if (!lang || !conceptSlug || !combinationString) {
-          console.warn(`⚠️ Invalid KV key format: ${combinations[i]}`);
-          continue;
-        }
-
-        const kvKeyEN = buildConceptKVKey(
-          'en-us',
-          conceptSlug as Concept,
-          combinationString
-        );
-        const kvKeyPT = buildConceptKVKey(
-          'pt-br',
-          conceptSlug as Concept,
-          combinationString
-        );
-
-        const kvDataEN = (await this.context.env.KV_CONCEPTS.get(
-          kvKeyEN,
-          'json'
-        )) as {
-          name: string;
-          description: string;
-        };
-        const kvDataPT = (await this.context.env.KV_CONCEPTS.get(
-          kvKeyPT,
-          'json'
-        )) as {
-          name: string;
-        };
-
-        console.log(
-          `🎭 Regenerating name for: ${kvKeyEN} (Old Name: "${oldNameEN}")`
-        );
-
-        let newNameEN: string | null = null;
-        let newNamePT: string | null = null;
-        let attempts = 0;
-        const maxAttempts = 3;
-
-        while (attempts < maxAttempts) {
-          attempts++;
-
-          const messages = this.context
-            .buildLLMMessages()
-            .regenerateConceptName({
-              oldNameEN: kvDataEN.name,
-              description: kvDataEN.description,
-              usedNamesEN: Array.from(usedNamesEN), // ✅ Ensure array format
-            });
-
-          const aiResponse = await this.context
-            .api()
-            .callTogether.single(messages, {});
-          if (!aiResponse) {
-            console.warn(
-              `⚠️ AI failed to generate a new name for ${kvKeyEN}, skipping.`
-            );
-            break;
-          }
-
-          // ✅ Parse AI response to extract both EN and PT names
-          const [generatedEN, generatedPT] = aiResponse
-            .split('\n')
-            .map((s) => s.trim());
-
-          // ✅ Validate that the generated names are not duplicates
-          if (!usedNamesEN.has(generatedEN) && !usedNamesPT.has(generatedPT)) {
-            newNameEN = generatedEN;
-            newNamePT = generatedPT;
-            break; // ✅ Found unique names, exit retry loop
-          }
-
-          console.warn(
-            `⚠️ AI suggested a duplicate name: EN - "${generatedEN}", PT - "${generatedPT}". Retrying... (Attempt ${attempts}/${maxAttempts})`
-          );
-        }
-
-        if (!newNameEN || !newNamePT) {
-          console.error(
-            `🚨 Failed to generate a unique name for ${kvKeyEN} after ${maxAttempts} attempts.`
-          );
-          continue;
-        }
-
-        console.log(
-          `✅ Storing new names for ${kvKeyEN}: EN - "${newNameEN}", PT - "${newNamePT}"`
-        );
-
-        // ✅ Update KV with new names (EN)
-        Object.assign(kvDataEN, { name: newNameEN });
-        await this.context.env.KV_CONCEPTS.put(
-          kvKeyEN,
-          JSON.stringify(kvDataEN)
-        );
-
-        // ✅ Update KV with new names (PT)
-        Object.assign(kvDataPT, { name: newNamePT });
-        await this.context.env.KV_CONCEPTS.put(
-          kvKeyPT,
-          JSON.stringify(kvDataPT)
-        );
-
-        // ✅ Add new names to the used names sets to prevent future reuse
-        usedNamesEN.add(newNameEN);
-        usedNamesPT.add(newNamePT);
-
-        // ✅ Stop if limit is reached
-        if (limit && --limit <= 0) {
-          console.log(`🎯 Limit reached, stopping further processing.`);
-          return { message: 'Regeneration limit reached.' };
-        }
-      }
-    }
-
-    console.log(`🎉 Duplicate names regenerated successfully.`);
-    return { message: 'Duplicate names processed and regenerated.' };
-  }
-
-  async findDuplicateNamesAndUsedNamesForConcept(
-    conceptSlug: Concept,
-    limit?: number
-  ) {
+  // async regenerateDuplicateNames(limit?: number) {
+  //   console.log(`🔄 Processing duplicate names for regeneration...`);
+
+  //   const { duplicateEntries, usedNamesEN, usedNamesPT } =
+  //     await this.findDuplicateNamesAndUsedNames(limit);
+
+  //   if (duplicateEntries.length === 0) {
+  //     console.log(`🎉 No duplicates found. Nothing to regenerate.`);
+  //     return { message: 'No duplicates detected.' };
+  //   }
+
+  //   for (const { name: oldNameEN, combinations } of duplicateEntries) {
+  //     for (let i = 1; i < combinations.length; i++) {
+  //       const [_, lang, conceptSlug, combinationString] =
+  //         combinations[i].split(':');
+
+  //       if (!lang || !conceptSlug || !combinationString) {
+  //         console.warn(`⚠️ Invalid KV key format: ${combinations[i]}`);
+  //         continue;
+  //       }
+
+  //       const kvKeyEN = buildConceptKVKey(
+  //         'en-us',
+  //         conceptSlug as Concept,
+  //         combinationString
+  //       );
+  //       const kvKeyPT = buildConceptKVKey(
+  //         'pt-br',
+  //         conceptSlug as Concept,
+  //         combinationString
+  //       );
+
+  //       const kvDataEN = (await this.context.env.KV_CONCEPTS.get(
+  //         kvKeyEN,
+  //         'json'
+  //       )) as {
+  //         name: string;
+  //         description: string;
+  //       };
+  //       const kvDataPT = (await this.context.env.KV_CONCEPTS.get(
+  //         kvKeyPT,
+  //         'json'
+  //       )) as {
+  //         name: string;
+  //       };
+
+  //       console.log(
+  //         `🎭 Regenerating name for: ${kvKeyEN} (Old Name: "${oldNameEN}")`
+  //       );
+
+  //       let newNameEN: string | null = null;
+  //       let newNamePT: string | null = null;
+  //       let attempts = 0;
+  //       const maxAttempts = 3;
+
+  //       while (attempts < maxAttempts) {
+  //         attempts++;
+
+  //         const messages = this.context
+  //           .buildLLMMessages()
+  //           .regenerateConceptName({
+  //             oldNameEN: kvDataEN.name,
+  //             description: kvDataEN.description,
+  //             usedNamesEN: Array.from(usedNamesEN), // ✅ Ensure array format
+  //           });
+
+  //         const aiResponse = await this.context
+  //           .api()
+  //           .callTogether.single(messages, {});
+  //         if (!aiResponse) {
+  //           console.warn(
+  //             `⚠️ AI failed to generate a new name for ${kvKeyEN}, skipping.`
+  //           );
+  //           break;
+  //         }
+
+  //         // ✅ Parse AI response to extract both EN and PT names
+  //         const [generatedEN, generatedPT] = aiResponse
+  //           .split('\n')
+  //           .map((s) => s.trim());
+
+  //         // ✅ Validate that the generated names are not duplicates
+  //         if (!usedNamesEN.has(generatedEN) && !usedNamesPT.has(generatedPT)) {
+  //           newNameEN = generatedEN;
+  //           newNamePT = generatedPT;
+  //           break; // ✅ Found unique names, exit retry loop
+  //         }
+
+  //         console.warn(
+  //           `⚠️ AI suggested a duplicate name: EN - "${generatedEN}", PT - "${generatedPT}". Retrying... (Attempt ${attempts}/${maxAttempts})`
+  //         );
+  //       }
+
+  //       if (!newNameEN || !newNamePT) {
+  //         console.error(
+  //           `🚨 Failed to generate a unique name for ${kvKeyEN} after ${maxAttempts} attempts.`
+  //         );
+  //         continue;
+  //       }
+
+  //       console.log(
+  //         `✅ Storing new names for ${kvKeyEN}: EN - "${newNameEN}", PT - "${newNamePT}"`
+  //       );
+
+  //       // ✅ Update KV with new names (EN)
+  //       Object.assign(kvDataEN, { name: newNameEN });
+  //       await this.context.env.KV_CONCEPTS.put(
+  //         kvKeyEN,
+  //         JSON.stringify(kvDataEN)
+  //       );
+
+  //       // ✅ Update KV with new names (PT)
+  //       Object.assign(kvDataPT, { name: newNamePT });
+  //       await this.context.env.KV_CONCEPTS.put(
+  //         kvKeyPT,
+  //         JSON.stringify(kvDataPT)
+  //       );
+
+  //       // ✅ Add new names to the used names sets to prevent future reuse
+  //       usedNamesEN.add(newNameEN);
+  //       usedNamesPT.add(newNamePT);
+
+  //       // ✅ Stop if limit is reached
+  //       if (limit && --limit <= 0) {
+  //         console.log(`🎯 Limit reached, stopping further processing.`);
+  //         return { message: 'Regeneration limit reached.' };
+  //       }
+  //     }
+  //   }
+
+  //   console.log(`🎉 Duplicate names regenerated successfully.`);
+  //   return { message: 'Duplicate names processed and regenerated.' };
+  // }
+
+  async findDuplicateNamesForConcept(conceptSlug: Concept) {
     console.log(
-      `🔍 Scanning KV for duplicate names in concept: ${conceptSlug}...`
+      `🔍 Fetching duplicate names from KV_CONCEPT_CACHE for ${conceptSlug}...`
     );
 
-    const kvStore = this.context.env.KV_CONCEPTS;
-    let cursor: string | undefined = undefined;
-    let nameUsageMapEN: Record<string, string[]> = {}; // { enName: [combination1, combination2] }
-    let usedNamesEN = new Set<string>(); // ✅ All used EN names
-    let usedNamesPT = new Set<string>(); // ✅ All used PT names
-    let totalKeysScanned = 0;
-
-    do {
-      const response: KVNamespaceListResult<KVConcept> = (await kvStore.list({
-        prefix: `concepts:en-us:${conceptSlug}:`, // ✅ Fetch only keys for this concept
-        cursor,
-      })) as KVNamespaceListResult<KVConcept, string>;
-
-      const {
-        keys,
-        cursor: newCursor,
-      }: { keys: KVNamespaceListKey<KVConcept>[]; cursor?: string } = response;
-
-      totalKeysScanned += keys.length;
-
-      for (const key of keys) {
-        const kvDataEN = (await kvStore.get(key.name, 'json')) as {
-          name: string;
-        };
-        const kvKeyPT = key.name.replace(':en-us:', ':pt-br:'); // ✅ Get corresponding PT key
-        const kvDataPT = (await kvStore.get(kvKeyPT, 'json')) as {
-          name: string;
-        };
+    const kvCacheStore = this.context.env.KV_CONCEPT_CACHE;
 
-        if (kvDataEN?.name) {
-          usedNamesEN.add(kvDataEN.name); // ✅ Store all used EN names
+    // ✅ Fetch the cached concept name mappings
+    const nameMap: Record<string, string[]> =
+      (await kvCacheStore.get(
+        `cache:concepts:en-us:${conceptSlug}:0`,
+        'json'
+      )) || {};
 
-          if (!nameUsageMapEN[kvDataEN.name]) {
-            nameUsageMapEN[kvDataEN.name] = [];
-          }
-          nameUsageMapEN[kvDataEN.name].push(key.name); // Store the key for that name
-        }
+    let duplicateKeys: string[] = [];
+    let usedNamesEN = new Set<string>();
+    let usedNamesPT = new Set<string>();
 
-        if (kvDataPT?.name) {
-          usedNamesPT.add(kvDataPT.name); // ✅ Store all used PT names
-        }
+    for (const [name, keys] of Object.entries(nameMap)) {
+      if (keys.length > 1) {
+        duplicateKeys.push(...keys.slice(1)); // ✅ Store all but the first occurrence
       }
+      usedNamesEN.add(name);
+    }
 
-      cursor = newCursor;
-    } while (cursor && (!limit || totalKeysScanned < limit));
+    // ✅ Fetch PT-BR version from cache
+    const nameMapPT: Record<string, string[]> =
+      (await kvCacheStore.get(
+        `cache:concepts:pt-br:${conceptSlug}:0`,
+        'json'
+      )) || {};
 
-    // ✅ Find names used more than once (EN)
-    let duplicateENNames = Object.entries(nameUsageMapEN)
-      .filter(([_, combinations]) => combinations.length > 1)
-      .map(([name, combinations]) => ({
-        name,
-        combinations,
-      }));
-
-    // ✅ If limit is set, trim duplicates list
-    if (limit && duplicateENNames.length > limit) {
-      duplicateENNames = duplicateENNames.slice(0, limit);
+    for (const name of Object.keys(nameMapPT)) {
+      usedNamesPT.add(name);
     }
 
     console.log(
-      `✅ Found ${duplicateENNames.length} duplicate EN names for concept "${conceptSlug}" out of ${totalKeysScanned} entries.`
+      `✅ Found ${duplicateKeys.length} duplicate keys for ${conceptSlug}.`
     );
 
     return {
-      duplicateEntries: duplicateENNames, // ✅ List of EN names that need regeneration
-      usedNamesEN, // ✅ Set of all unique EN names
-      usedNamesPT, // ✅ Set of all unique PT names
+      duplicateKeys, // ✅ List of keys that need new names
+      usedNamesEN, // ✅ Set of all used EN names
+      usedNamesPT, // ✅ Set of all used PT names
     };
   }
 
-  async regenerateDuplicateNamesForConcept(
-    conceptSlug: Concept,
-    limit?: number
-  ) {
-    console.log(`🔄 Processing duplicate names for concept: ${conceptSlug}...`);
-
-    const { duplicateEntries, usedNamesEN, usedNamesPT } =
-      await this.findDuplicateNamesAndUsedNamesForConcept(conceptSlug, limit);
-
-    if (duplicateEntries.length === 0) {
-      console.log(
-        `🎉 No duplicates found for concept: ${conceptSlug}. Nothing to regenerate.`
-      );
+  async regenerateDuplicateNamesForConcept(conceptSlug: Concept) {
+    console.log(`🔄 [START] Regenerating duplicate names for concept: ${conceptSlug}`);
+  
+    const kvCacheStore = this.context.env.KV_CONCEPT_CACHE;
+    const kvStore = this.context.env.KV_CONCEPTS;
+  
+    // ✅ Get duplicate keys and used names
+    const { duplicateKeys, usedNamesEN, usedNamesPT } =
+      await this.findDuplicateNamesForConcept(conceptSlug);
+  
+    if (duplicateKeys.length === 0) {
+      console.log(`🎉 No duplicates found for ${conceptSlug}.`);
       return { message: `No duplicates detected for ${conceptSlug}.` };
     }
-
-    for (const { name: oldNameEN, combinations } of duplicateEntries) {
-      for (let i = 1; i < combinations.length; i++) {
-        const [_, lang, concept, combinationString] =
-          combinations[i].split(':');
-
+  
+    let updatedKeys: string[] = [];
+    let recentDuplicates = new Set<string>(); // ✅ Track newly generated names dynamically
+  
+    console.log(`🔍 Found ${duplicateKeys.length} duplicate keys to process.`);
+  
+    for (const kvKeyEN of duplicateKeys) {
+      const kvKeyPT = kvKeyEN.replace(':en-us:', ':pt-br:');
+  
+      const kvDataEN = (await kvStore.get(kvKeyEN, 'json')) as {
+        name: string;
+        description: string;
+      };
+      const kvDataPT = (await kvStore.get(kvKeyPT, 'json')) as { name: string };
+  
+      if (!kvDataEN || !kvDataEN.name) {
+        console.warn(`⚠️ Missing data for key: ${kvKeyEN}, skipping.`);
+        continue;
+      }
+  
+      console.log(`🎭 Processing duplicate: ${kvKeyEN} (Old Name: "${kvDataEN.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: kvDataEN.name,
+          description: kvDataEN.description,
+          recentNames: Array.from(recentDuplicates), // ✅ Prevent reusing recent names
+        });
+  
+        const aiResponse = await this.context.api().callTogether.single(messages, {});
+  
+        if (!aiResponse) {
+          console.warn(`⚠️ AI failed to generate a new name for ${kvKeyEN}, skipping.`);
+          break;
+        }
+  
+        // ✅ Parse AI response
+        const [generatedEN, generatedPT] = aiResponse.split('\n').map((s) => s.trim());
+  
+        console.log(`🎨 AI Response: EN - "${generatedEN}", PT - "${generatedPT}"`);
+  
+        // ✅ Check if the name already exists
         if (
-          !lang ||
-          !concept ||
-          !combinationString ||
-          concept !== conceptSlug
+          usedNamesEN.has(generatedEN) ||
+          usedNamesPT.has(generatedPT) ||
+          recentDuplicates.has(generatedEN)
         ) {
-          console.warn(`⚠️ Invalid KV key format: ${combinations[i]}`);
-          continue;
-        }
-
-        const kvKeyEN = buildConceptKVKey(
-          'en-us',
-          concept as Concept,
-          combinationString
-        );
-        const kvKeyPT = buildConceptKVKey(
-          'pt-br',
-          concept as Concept,
-          combinationString
-        );
-
-        const kvDataEN = (await this.context.env.KV_CONCEPTS.get(
-          kvKeyEN,
-          'json'
-        )) as {
-          name: string;
-          description: string;
-        };
-        const kvDataPT = (await this.context.env.KV_CONCEPTS.get(
-          kvKeyPT,
-          'json'
-        )) as {
-          name: string;
-        };
-
-        console.log(
-          `🎭 Regenerating name for: ${kvKeyEN} (Old Name: "${oldNameEN}")`
-        );
-
-        let newNameEN: string | null = null;
-        let newNamePT: string | null = null;
-        let attempts = 0;
-        const maxAttempts = 3;
-
-        while (attempts < maxAttempts) {
-          attempts++;
-
-          const messages = this.context
-            .buildLLMMessages()
-            .regenerateConceptName({
-              oldNameEN: kvDataEN.name,
-              description: kvDataEN.description,
-              usedNamesEN: Array.from(usedNamesEN), // ✅ Ensure array format
-            });
-
-          const aiResponse = await this.context
-            .api()
-            .callTogether.single(messages, {});
-          if (!aiResponse) {
-            console.warn(
-              `⚠️ AI failed to generate a new name for ${kvKeyEN}, skipping.`
-            );
-            break;
-          }
-
-          // ✅ Parse AI response to extract both EN and PT names
-          const [generatedEN, generatedPT] = aiResponse
-            .split('\n')
-            .map((s) => s.trim());
-
-          // ✅ Validate that the generated names are not duplicates
-          if (!usedNamesEN.has(generatedEN) && !usedNamesPT.has(generatedPT)) {
-            newNameEN = generatedEN;
-            newNamePT = generatedPT;
-            break; // ✅ Found unique names, exit retry loop
-          }
-
           console.warn(
-            `⚠️ AI suggested a duplicate name: EN - "${generatedEN}", PT - "${generatedPT}". Retrying... (Attempt ${attempts}/${maxAttempts})`
-          );
-        }
-
-        if (!newNameEN || !newNamePT) {
-          console.error(
-            `🚨 Failed to generate a unique name for ${kvKeyEN} after ${maxAttempts} attempts.`
+            `⚠️ Duplicate detected: EN - "${generatedEN}", PT - "${generatedPT}". Retrying...`
           );
+          recentDuplicates.add(generatedEN);
+          recentDuplicates.add(generatedPT);
           continue;
         }
-
-        console.log(
-          `✅ Storing new names for ${kvKeyEN}: EN - "${newNameEN}", PT - "${newNamePT}"`
-        );
-
-        // ✅ Update KV with new names (EN)
-        Object.assign(kvDataEN, { name: newNameEN });
-        await this.context.env.KV_CONCEPTS.put(
-          kvKeyEN,
-          JSON.stringify(kvDataEN)
-        );
-
-        // ✅ Update KV with new names (PT)
-        Object.assign(kvDataPT, { name: newNamePT });
-        await this.context.env.KV_CONCEPTS.put(
-          kvKeyPT,
-          JSON.stringify(kvDataPT)
+  
+        newNameEN = generatedEN;
+        newNamePT = generatedPT;
+        recentDuplicates.add(newNameEN);
+        recentDuplicates.add(newNamePT);
+        break; // ✅ Found unique names, exit retry loop
+      }
+  
+      if (!newNameEN || !newNamePT) {
+        console.error(`🚨 Failed to generate a unique name for ${kvKeyEN} after ${maxAttempts} attempts.`);
+        continue;
+      }
+  
+      console.log(`✅ Storing new names: EN - "${newNameEN}", PT - "${newNamePT}"`);
+  
+      // ✅ Update KV with new names (EN)
+      Object.assign(kvDataEN, { name: newNameEN });
+      await kvStore.put(kvKeyEN, JSON.stringify(kvDataEN));
+  
+      // ✅ Update KV with new names (PT)
+      Object.assign(kvDataPT, { name: newNamePT });
+      await kvStore.put(kvKeyPT, JSON.stringify(kvDataPT));
+  
+      // ✅ Add new names to used names sets
+      usedNamesEN.add(newNameEN);
+      usedNamesPT.add(newNamePT);
+  
+      // ✅ Collect successfully processed keys for cache update
+      updatedKeys.push(kvKeyEN);
+    }
+  
+    // ✅ Remove successfully updated keys from duplicate cache
+    if (updatedKeys.length > 0) {
+      let duplicateKeysList: string[] =
+        (await kvCacheStore.get(`cache:duplicates:${conceptSlug}`, 'json')) || [];
+  
+      console.log(`🗑️ Removing ${updatedKeys.length} resolved duplicates from cache.`);
+  
+      // ✅ Remove processed keys
+      duplicateKeysList = duplicateKeysList.filter((key) => !updatedKeys.includes(key));
+  
+      if (duplicateKeysList.length === 0) {
+        console.log(`✅ All duplicates resolved for ${conceptSlug}, deleting cache entry.`);
+        await kvCacheStore.delete(`cache:duplicates:${conceptSlug}`);
+      } else {
+        await kvCacheStore.put(
+          `cache:duplicates:${conceptSlug}`,
+          JSON.stringify(duplicateKeysList)
         );
-
-        // ✅ Add new names to the used names sets to prevent future reuse
-        usedNamesEN.add(newNameEN);
-        usedNamesPT.add(newNamePT);
-
-        // ✅ Stop if limit is reached
-        if (limit && --limit <= 0) {
-          console.log(`🎯 Limit reached, stopping further processing.`);
-          return { message: `Regeneration limit reached for ${conceptSlug}.` };
-        }
       }
     }
-
-    console.log(
-      `🎉 Duplicate names regenerated successfully for concept: ${conceptSlug}.`
-    );
+  
+    console.log(`🎉 [COMPLETE] Duplicate names regenerated successfully for concept: ${conceptSlug}.`);
     return {
       message: `Duplicate names processed and regenerated for ${conceptSlug}.`,
     };
@@ -1207,4 +1221,58 @@ export class ConceptService {
       message: `Cached ${totalKeysScanned} EN names for ${conceptSlug} in ${batchIndex} batches.`,
     };
   }
+
+  async cacheDuplicateConcepts(conceptSlug: Concept) {
+    console.log(`🔍 Identifying duplicate entries for concept: ${conceptSlug}`);
+
+    const kvCacheStore = this.context.env.KV_CONCEPT_CACHE;
+    let cursor: string | undefined = undefined;
+    let batchIndex = 0;
+    let duplicateKeys: string[] = [];
+
+    do {
+      const batchKey = `cache:concepts:en-us:${conceptSlug}:${batchIndex}`;
+      const batchData = await kvCacheStore.get<{ [name: string]: string[] }>(
+        batchKey,
+        'json'
+      );
+
+      if (!batchData) {
+        console.log(`⚠️ No data found for batch: ${batchKey}, stopping.`);
+        break;
+      }
+
+      console.log(
+        `📦 Processing batch ${batchIndex} with ${
+          Object.keys(batchData).length
+        } names`
+      );
+
+      for (const [name, keys] of Object.entries(batchData)) {
+        if (keys.length > 1) {
+          // Collect duplicate entries (all but the first one)
+          duplicateKeys.push(...keys.slice(1));
+        }
+      }
+
+      batchIndex++;
+    } while (true);
+
+    if (duplicateKeys.length === 0) {
+      console.log(`✅ No duplicates found for ${conceptSlug}.`);
+      return;
+    }
+
+    console.log(
+      `🚨 Found ${duplicateKeys.length} duplicate entries for ${conceptSlug}`
+    );
+
+    // Store the duplicate keys list in KV
+    await kvCacheStore.put(
+      `cache:duplicates:${conceptSlug}`,
+      JSON.stringify(duplicateKeys)
+    );
+
+    console.log(`✅ Stored duplicate keys for ${conceptSlug} in cache.`);
+  }
 }

package/app/workflow/ConceptWorkflow.ts

@@ -66,6 +66,17 @@ export class ConceptWorkflow {
     }
   }
 
+  async processDuplicateNames(conceptSlug: Concept) {
+    console.log(`🔍 Initiating duplicate name resolution for ${conceptSlug}`);
+
+    try {
+      await this.conceptService.regenerateDuplicateNamesForConcept(conceptSlug);
+      console.log(`✅ Duplicate names resolved for ${conceptSlug}`);
+    } catch (error) {
+      console.error(`❌ Error resolving duplicates for ${conceptSlug}:`, error);
+    }
+  }
+
   async processBatch(
     conceptSlug: Concept,
     combinations: string[],

package/package.json

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

package/utils/buildMessages.ts

@@ -183,42 +183,56 @@ export const buildLLMMessages = (env: BackendBindings) => ({
   regenerateConceptName: ({
     oldNameEN,
     description,
-    usedNamesEN,
+    conceptSlug,
+    recentNames = [],
   }: {
     oldNameEN: string;
     description: string;
-    usedNamesEN: string[];
+    conceptSlug: string;
+    recentNames?: string[];
   }): ChatMessages => [
     {
       role: 'system',
       content: `
-        You are an expert in creating mystical and evocative names for spiritual artifacts.
-        
-        ## Instructions:
-        - The name "${oldNameEN}" is already in use. Generate a new unique name that preserves the essence but avoids duplication.
-        - Keep it concise (≤5 words) and memorable.
-        - Ensure the name feels symbolic and mystical, fitting within the theme of arcane wisdom.
-        - Do NOT use astrological signs or zodiac references.
-        - Provide a natural Portuguese translation of the new name.
-        - Avoid these names: ${
-          usedNamesEN.length ? usedNamesEN.join(', ') : 'None'
-        }.
-
-        ## Output Format:
-        EN: [new unique name]  
-        PT: [Portuguese translation]
+        You are an expert in mystical and symbolic naming. Your task is to generate a new, unique name for a given concept while ensuring it aligns with its description.
+  
+        Guidelines:
+          • The name must have exactly six words.
+          • It must start with "The ${conceptSlug} of" in English and "O ${conceptSlug} de" in Portuguese.
+          • The last three words should be distinct, meaningful, and thematically relevant.
+          • It should reflect the concept’s core essence such as protection, transformation, or resilience.
+          • Avoid generic, redundant, or overly abstract terms.
+          • Ensure it does not resemble the previous name.
+          • The name must not match any of the recently generated names.
+  
+        Input:
+          • Concept Name: ${conceptSlug}
+          • Previous Name Already Used: ${oldNameEN}
+          • Recently Generated Names: ${
+            recentNames.length > 0 ? recentNames.join(', ') : 'None'
+          }
+          • Description: ${description}
+  
+        Output Format:
+  
+        EN:
+          • New Name: The ${conceptSlug} of [New Symbolic Concept]
+  
+        PT:
+          • Novo Nome: O ${conceptSlug} de [Novo Conceito Simbólico]
+  
+        No explanations or additional text. Return only the names.
       `,
     },
     {
       role: 'user',
       content: `
-        The current name "${oldNameEN}" has been found to be a duplicate.
-
-        ### Description:
-        ${description}
-
-        Generate a unique and evocative English name while maintaining the essence of the concept.
-        Also, provide a natural Portuguese translation of the new name.
+        • Concept Name: ${conceptSlug}
+        • Previous Name Already Used: ${oldNameEN}
+        • Recently Generated Names: ${
+          recentNames.length > 0 ? recentNames.join(', ') : 'None'
+        }
+        • Description: ${description}
       `,
     },
   ],