@zodic/shared 0.0.195 → 0.0.197

package/app/services/ConceptService.ts

@@ -1,3 +1,7 @@
+import {
+  KVNamespaceListKey,
+  KVNamespaceListResult,
+} from '@cloudflare/workers-types';
 import { and, eq } from 'drizzle-orm';
 import { inject, injectable } from 'inversify';
 import 'reflect-metadata';
@@ -28,111 +32,116 @@ export class ConceptService {
     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);
-    const failureKey = `failures:basic-info:${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);
-  
+
     // ✅ IMMEDIATE SKIP if already exists and override is false
     if (!override && existingEN.name && existingPT.name) {
       console.log(`⚡ Basic info already exists for ${conceptSlug}, skipping.`);
-  
-      // ✅ **Backfill Durable Object** to register the names
-      console.log(`📡 Backfilling Durable Object for ${conceptSlug}...`);
-      try {
-        await Promise.all([
-          stub.fetch(`https://internal/add-name`, {
-            method: 'POST',
-            body: JSON.stringify({ language: 'en-us', name: existingEN.name }),
-            headers: { 'Content-Type': 'application/json' },
-          }),
-          stub.fetch(`https://internal/add-name`, {
-            method: 'POST',
-            body: JSON.stringify({ language: 'pt-br', name: existingPT.name }),
-            headers: { 'Content-Type': 'application/json' },
-          }),
-        ]);
-        console.log(`✅ Successfully backfilled Durable Object for ${conceptSlug}`);
-      } catch (error) {
-        console.error(`❌ Error backfilling Durable Object:`, error);
-      }
-  
-      return; // ✅ Exit early
+      return;
     }
-  
+
     let attempts = 0;
-    const maxAttempts = 2;
-    let newlyGeneratedNames: string[] = []; // ✅ Track generated names in memory
-  
+    const maxAttempts = 3;
+
     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}...`
+        );
+
         // ✅ Fetch the latest name list from Durable Object
-        console.log(`📡 Fetching names from Durable Object for ${conceptSlug}...`);
+        console.log(
+          `📡 Fetching names from Durable Object 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(`✅ Retrieved ${allNamesEN.length} EN names and ${allNamesPT.length} PT names.`);
-        } else {
-          console.log(`❌ Error fetching names from DO for ${conceptSlug}: ${await response.text()}`);
         }
-  
+
         console.log(`✏️ Generating new name...`);
-        // ✅ Merge newly generated names with existing recent names
-        const recentNamesEN = [...allNamesEN.slice(-40), ...newlyGeneratedNames];
-  
         const messages = this.context
           .buildLLMMessages()
           .generateConceptBasicInfo({
             combination: combinationString,
             conceptSlug,
-            existingNames: recentNamesEN,
+            existingNames: allNamesEN.slice(-40),
           });
-  
-        let aiResponse = await this.context.api().callTogether.single(messages, {});
+
+        let aiResponse = await this.context
+          .api()
+          .callTogether.single(messages, {});
         if (!aiResponse) throw new Error(`❌ AI returned an empty response`);
-  
+
         phase = 'cleaning';
-        console.log(`🧼 Cleaning AI response...`);
         aiResponse = this.cleanAIResponse(aiResponse);
-  
+
         phase = 'parsing';
-        console.log(`📜 Parsing AI response...`);
         let { nameEN, descriptionEN, poemEN, namePT, descriptionPT, poemPT } =
           this.parseBasicInfoResponse(aiResponse, conceptSlug);
-  
+
         console.log(`🎭 Generated names: EN - "${nameEN}", PT - "${namePT}"`);
-  
-        // ✅ **Add the generated names to our local tracking list**
-        newlyGeneratedNames.push(nameEN, namePT);
-  
+
+        // ✅ **Check name length and retry if too long**
+        const MAX_NAME_LENGTH = 44; // Adjust if needed
+        if (
+          nameEN.length > MAX_NAME_LENGTH ||
+          namePT.length > MAX_NAME_LENGTH
+        ) {
+          console.warn(
+            `⚠️ Name too long: "${nameEN}" | "${namePT}". Retrying...`
+          );
+
+          // ✅ **Register name in Durable Object as blocked**
+          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' },
+          });
+
+          console.log(`✅ Added long name to DO blocklist, retrying...`);
+          continue;
+        }
+
         // ✅ 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}"`
+          );
+
           // ✅ **On third attempt, store the name anyway & register in kvFailures**
           if (attempts >= maxAttempts) {
-            console.log(`🚨 Max attempts reached. Storing name despite duplicate.`);
-  
-            // ✅ **Register duplicate storage in KV failures**
+            console.log(
+              `🚨 Max attempts reached. Storing name despite duplicate.`
+            );
+
             await kvFailuresStore.put(
               `failures:duplicates:${conceptSlug}:${combinationString}`,
               JSON.stringify({
@@ -144,45 +153,17 @@ export class ConceptService {
                 timestamp: new Date().toISOString(),
               })
             );
-  
-            // ✅ **Store 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' },
-            });
-  
-            // ✅ Store the generated basic info in KV
-            Object.assign(existingEN, {
-              name: nameEN,
-              description: descriptionEN,
-              poem: poemEN,
-              status: 'forced', // 🔥 Mark as "forced" due to duplication
-            });
-            await kvStore.put(kvKeyEN, JSON.stringify(existingEN));
-  
-            Object.assign(existingPT, {
-              name: namePT,
-              description: descriptionPT,
-              poem: poemPT,
-              status: 'forced', // 🔥 Mark as "forced" due to duplication
-            });
-            await kvStore.put(kvKeyPT, JSON.stringify(existingPT));
-  
-            console.log(`✅ Stored duplicate name after max retries: ${nameEN}, ${namePT}`);
-            return;
+
+            console.log(
+              `✅ Stored duplicate name after max retries: ${nameEN}, ${namePT}`
+            );
+            break;
           }
-  
+
           console.log('🔁 Retrying due to duplicate name...');
           continue;
         }
-  
+
         console.log(`📝 Storing names in Durable Object...`);
         // ✅ **Immediately update Durable Object with the new name**
         await stub.fetch(`https://internal/add-name`, {
@@ -190,13 +171,13 @@ export class ConceptService {
           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' },
         });
-  
+
         // ✅ Store the generated basic info in KV
         Object.assign(existingEN, {
           name: nameEN,
@@ -205,7 +186,7 @@ export class ConceptService {
           status: 'idle',
         });
         await kvStore.put(kvKeyEN, JSON.stringify(existingEN));
-  
+
         Object.assign(existingPT, {
           name: namePT,
           description: descriptionPT,
@@ -213,11 +194,16 @@ export class ConceptService {
           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 as Error).message);
+        console.error(
+          `❌ Attempt ${attempts} failed at phase: ${phase}`,
+          (error as Error).message
+        );
       }
     }
   }
@@ -805,4 +791,434 @@ export class ConceptService {
       status: 'idle',
     };
   }
+
+  private async findDuplicateNamesAndUsedNames(limit?: number) {
+    console.log(`🔍 Scanning KV for duplicate names...`);
+
+    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:',
+        cursor,
+      })) as KVNamespaceListResult<KVConcept, string>;
+
+      const {
+        keys,
+        cursor: newCursor,
+      }: { keys: KVNamespaceListKey<KVConcept>[]; cursor?: string } = response;
+
+      totalKeysScanned += keys.length;
+
+      for (const key of keys) {
+        const kvData = (await kvStore.get(key.name, 'json')) as {
+          name: string;
+          ptName?: string;
+        };
+
+        if (kvData?.name) {
+          usedNamesEN.add(kvData.name); // ✅ Store all used EN names
+
+          if (!nameUsageMapEN[kvData.name]) {
+            nameUsageMapEN[kvData.name] = [];
+          }
+          nameUsageMapEN[kvData.name].push(key.name); // Store the key for that name
+        }
+
+        if (kvData?.ptName) {
+          usedNamesPT.add(kvData.ptName); // ✅ Store all used PT names
+        }
+      }
+
+      cursor = newCursor;
+    } while (cursor && (!limit || totalKeysScanned < limit));
+
+    // ✅ 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);
+    }
+
+    console.log(
+      `✅ Found ${duplicateENNames.length} duplicate EN names out of ${totalKeysScanned} entries.`
+    );
+
+    return {
+      duplicateEntries: duplicateENNames, // ✅ List of EN names that need regeneration
+      usedNamesEN, // ✅ Set of all unique EN names
+      usedNamesPT, // ✅ Set of all unique PT names
+    };
+  }
+
+  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.' };
+  }
+
+  private async findDuplicateNamesAndUsedNamesForConcept(
+    conceptSlug: Concept,
+    limit?: number
+  ) {
+    console.log(
+      `🔍 Scanning KV for duplicate names in concept: ${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;
+        };
+
+        if (kvDataEN?.name) {
+          usedNamesEN.add(kvDataEN.name); // ✅ Store all used EN names
+
+          if (!nameUsageMapEN[kvDataEN.name]) {
+            nameUsageMapEN[kvDataEN.name] = [];
+          }
+          nameUsageMapEN[kvDataEN.name].push(key.name); // Store the key for that name
+        }
+
+        if (kvDataPT?.name) {
+          usedNamesPT.add(kvDataPT.name); // ✅ Store all used PT names
+        }
+      }
+
+      cursor = newCursor;
+    } while (cursor && (!limit || totalKeysScanned < limit));
+
+    // ✅ 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);
+    }
+
+    console.log(
+      `✅ Found ${duplicateENNames.length} duplicate EN names for concept "${conceptSlug}" out of ${totalKeysScanned} entries.`
+    );
+
+    return {
+      duplicateEntries: duplicateENNames, // ✅ List of EN names that need regeneration
+      usedNamesEN, // ✅ Set of all unique EN names
+      usedNamesPT, // ✅ Set of all unique 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.`
+      );
+      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(':');
+
+        if (
+          !lang ||
+          !concept ||
+          !combinationString ||
+          concept !== conceptSlug
+        ) {
+          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.`
+          );
+          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 for ${conceptSlug}.` };
+        }
+      }
+    }
+
+    console.log(
+      `🎉 Duplicate names regenerated successfully 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.195",
+  "version": "0.0.197",
   "module": "index.ts",
   "type": "module",
   "publishConfig": {

package/utils/buildMessages.ts

@@ -104,7 +104,7 @@ export const buildLLMMessages = (env: BackendBindings) => ({
     existingNames: string[];
   }): ChatMessages => {
     const zodiacCombination = mapConceptToPlanets(conceptSlug, combination);
-    
+
     return [
       {
         role: 'system',
@@ -179,4 +179,47 @@ export const buildLLMMessages = (env: BackendBindings) => ({
       },
     ];
   },
+
+  regenerateConceptName: ({
+    oldNameEN,
+    description,
+    usedNamesEN,
+  }: {
+    oldNameEN: string;
+    description: string;
+    usedNamesEN: 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]
+      `,
+    },
+    {
+      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.
+      `,
+    },
+  ],
 });