@zodic/shared 0.0.213 → 0.0.215

package/app/services/ConceptService.ts

@@ -1089,27 +1089,52 @@ export class ConceptService {
           break;
         }
   
-        // ✅ Parse AI response
-        const [generatedEN, generatedPT] = aiResponse.split('\n').map((s) => s.trim());
+        console.log(`📝 Raw AI Response:\n${aiResponse}`);
   
-        console.log(`🎨 AI Response: EN - "${generatedEN}", PT - "${generatedPT}"`);
+        // ✅ Correctly map concept names and gendered 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 [A-Za-z\\s]+`));
+        const ptMatch = aiResponse.match(new RegExp(`PT:\\s*${articlePT} ${conceptPT} de [A-Za-z\\s]+`));
+  
+        if (!enMatch || !ptMatch) {
+          console.error(`❌ Invalid AI response format! Retrying...`);
+          continue;
+        }
+  
+        newNameEN = enMatch[0].replace(/^EN:\s*/, '').trim();
+        newNamePT = ptMatch[0].replace(/^PT:\s*/, '').trim();
+  
+        console.log(`🎨 Extracted Names: EN - "${newNameEN}", PT - "${newNamePT}"`);
   
         // ✅ Check if the name already exists
         if (
-          usedNamesEN.has(generatedEN) ||
-          usedNamesPT.has(generatedPT) ||
-          recentDuplicates.has(generatedEN)
+          usedNamesEN.has(newNameEN) ||
+          usedNamesPT.has(newNamePT) ||
+          recentDuplicates.has(newNameEN)
         ) {
           console.warn(
-            `⚠️ Duplicate detected: EN - "${generatedEN}", PT - "${generatedPT}". Retrying...`
+            `⚠️ Duplicate detected: EN - "${newNameEN}", PT - "${newNamePT}". Retrying...`
           );
-          recentDuplicates.add(generatedEN);
-          recentDuplicates.add(generatedPT);
+          recentDuplicates.add(newNameEN);
+          recentDuplicates.add(newNamePT);
           continue;
         }
   
-        newNameEN = generatedEN;
-        newNamePT = generatedPT;
         recentDuplicates.add(newNameEN);
         recentDuplicates.add(newNamePT);
         break; // ✅ Found unique names, exit retry loop

package/package.json

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

package/types/scopes/generic.ts

@@ -241,8 +241,7 @@ export type ConceptPhase =
   | 'leonardo-prompt'
   | 'content'
   | 'images'
-  | 'fix-duplicates'
-  ;
+  | 'fix-duplicates';
 
 export const ConceptPhases: Record<string, ConceptPhase> = {
   BASIC_INFO: 'basic-info',

package/utils/buildMessages.ts

@@ -188,52 +188,62 @@ export const buildLLMMessages = (env: BackendBindings) => ({
   }: {
     oldNameEN: string;
     description: string;
-    conceptSlug: string;
+    conceptSlug: Concept;
     recentNames?: string[];
-  }): ChatMessages => [
-    {
-      role: 'system',
-      content: `
-        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.
+  }): ChatMessages => {
+    const conceptNameMap: Record<Concept, Record<'en' | 'pt', string>> = {
+      crown: { en: 'The Crown of', pt: 'A Coroa de' },
+      scepter: { en: 'The Scepter of', pt: 'O Cetro de' },
+      amulet: { en: 'The Amulet of', pt: 'O Amuleto de' },
+      ring: { en: 'The Ring of', pt: 'O Anel de' },
+      lantern: { en: 'The Lantern of', pt: 'A Candeia de' },
+      orb: { en: 'The Orb of', pt: 'O Orbe de' },
+    } as const;
+
+    // ✅ Get the correct mapped names
+    const conceptMapping = conceptNameMap[conceptSlug] || {
+      en: `The ${conceptSlug} of`,
+      pt: `O ${conceptSlug} de`,
+    };
+
+    return [
+      {
+        role: 'system',
+        content: `
+          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 "${conceptMapping.en}" in English and "${
+          conceptMapping.pt
+        }" 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.
+            • The name must not match any of the recently generated names.
+  
+          Example of a valid format:
+            ${conceptMapping.en} Strong Radiant Will
+    
+          No explanations or additional text. Return only the names exactly in the following format:
   
-        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.
+          EN:
+          ${conceptMapping.en} [New Symbolic Concept]
   
-        Input:
-          • Concept Name: ${conceptSlug}
+          PT:
+          ${conceptMapping.pt} [Novo Conceito Simbólico]
+        `,
+      },
+      {
+        role: 'user',
+        content: `
           • Previous Name Already Used: ${oldNameEN}
-          • Recently Generated Names: ${
+          • Recently Generated Names (Do not use these): ${
             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: `
-        • Concept Name: ${conceptSlug}
-        • Previous Name Already Used: ${oldNameEN}
-        • Recently Generated Names: ${
-          recentNames.length > 0 ? recentNames.join(', ') : 'None'
-        }
-        • Description: ${description}
-      `,
-    },
-  ],
+        `,
+      },
+    ];
+  },
 });