@zodic/shared 0.0.312 → 0.0.314

package/app/services/ArchetypeService.ts

@@ -3,6 +3,7 @@ import { inject, injectable } from 'inversify';
 import { ChatMessages, Composition, schema } from '../..';
 import { KVArchetype, ZodiacSignSlug } from '../../types/scopes/legacy';
 import { generateArchetypePrompt } from '../../utils/archetypeNamesMessages';
+import { duplicatedArchetypeNamePrompt } from '../../utils/duplicatedArchetypeNamePrompt';
 import { buildCosmicMirrorArchetypeKVKey } from '../../utils/KVKeysBuilders';
 import { AppContext } from '../base';
 
@@ -449,18 +450,36 @@ export class ArchetypeService {
 
       const { english, portuguese } = this.parseArchetypeNameBlocks(block);
 
+      // Check if parsing produced the expected number of entries
+      if (english.length !== 3 || portuguese.length !== 3) {
+        console.error(
+          `[Batch] Parsing failed for ${combination}. Expected 3 entries, got English: ${english.length}, Portuguese: ${portuguese.length}`
+        );
+        continue; // Skip this combination if parsing failed
+      }
+
       for (let j = 0; j < 3; j++) {
         const index = (j + 1).toString();
         const englishEntry = english[j];
         const ptEntry = portuguese[j];
 
-        if (await isEnglishNameDuplicate(englishEntry.name)) {
+        // Skip if either entry is missing (shouldn't happen with the above check, but added for safety)
+        if (!englishEntry || !ptEntry) {
           console.warn(
-            `⚠️ [Batch] Duplicate name skipped: ${englishEntry.name}`
+            `[Batch] Skipping index ${index} for ${combination} due to missing parsed data. English: ${JSON.stringify(
+              englishEntry
+            )}, Portuguese: ${JSON.stringify(ptEntry)}`
           );
           continue;
         }
 
+        // if (await isEnglishNameDuplicate(englishEntry.name)) {
+        //   console.warn(
+        //     `⚠️ [Batch] Duplicate name skipped: ${englishEntry.name}`
+        //   );
+        //   continue;
+        // }
+
         for (const gender of ['male', 'female']) {
           const enId = `${combination}:${gender}:${index}`;
           const ptId = `${combination}:${gender}:${index}:pt`;
@@ -733,26 +752,221 @@ export class ArchetypeService {
     );
   }
 
-  async recycleArchetypeNameDumpsBatch(compositions: Composition[]): Promise<void> {
+  async regenerateDuplicateArchetypeNamesBatch(
+    entriesByCombination: Record<string, any[]>
+  ) {
+    const db = this.context.drizzle();
+    console.log(
+      `[RegenerateDuplicatesBatch] Processing batch with ${
+        Object.keys(entriesByCombination).length
+      } combinations`
+    );
+
+    // Process each combination in the batch
+    for (const [combination, entries] of Object.entries(entriesByCombination)) {
+      console.log(
+        `[RegenerateDuplicatesBatch] Processing combination: ${combination}`
+      );
+
+      // Fetch all existing English names for this combination (across all archetypeIndex, gender, language)
+      const existingNamesResult = await db
+        .selectDistinct({ name: schema.archetypesData.name })
+        .from(schema.archetypesData)
+        .where(
+          and(
+            eq(schema.archetypesData.combination, combination),
+            eq(schema.archetypesData.language, 'en-us')
+          )
+        )
+        .execute();
+
+      let existingNames = existingNamesResult.map((r) => r.name);
+      console.log(
+        `[RegenerateDuplicatesBatch] Existing names for ${combination}: ${existingNames.join(
+          ', '
+        )}`
+      );
+
+      // Process each entry with the duplicate name in this combination
+      for (const entry of entries) {
+        const { archetypeIndex, essenceLine } = entry;
+        console.log(
+          `[RegenerateDuplicatesBatch] Regenerating name for ${combination} (archetypeIndex: ${archetypeIndex})`
+        );
+
+        let newName: {
+          name_en: string;
+          name_pt_male: string;
+          name_pt_female: string;
+        } | null = null;
+        let attempts = 0;
+        const maxAttempts = 5;
+
+        // Generate a new name until a unique one is found
+        while (attempts < maxAttempts) {
+          attempts++;
+          console.log(
+            `[RegenerateDuplicatesBatch] Attempt ${attempts} to generate a new name for ${combination} (archetypeIndex: ${archetypeIndex})`
+          );
+
+          // Build the prompt
+          const prompt = duplicatedArchetypeNamePrompt({
+            combination,
+            essenceLine: essenceLine || 'A unique and meaningful archetype', // Fallback for null essenceLine
+            existingNames,
+          });
+
+          // Send the request to the AI
+          const messages: ChatMessages = [{ role: 'user', content: prompt }];
+          const response = await this.context
+            .api()
+            .callTogether.single(messages, {});
+
+          if (!response) {
+            console.error(
+              `[RegenerateDuplicatesBatch] No response from model for ${combination} (archetypeIndex: ${archetypeIndex})`
+            );
+            continue;
+          }
+
+          // Parse the response
+          try {
+            newName = JSON.parse(response);
+            console.log(
+              `[RegenerateDuplicatesBatch] Generated new name: ${JSON.stringify(
+                newName,
+                null,
+                2
+              )}`
+            );
+
+            // Validate the response format
+            if (
+              !newName ||
+              !newName.name_en ||
+              !newName.name_pt_male ||
+              !newName.name_pt_female
+            ) {
+              console.error(
+                `[RegenerateDuplicatesBatch] Invalid response format for ${combination} (archetypeIndex: ${archetypeIndex}): ${response}`
+              );
+              newName = null;
+              continue;
+            }
+          } catch (error) {
+            console.error(
+              `[RegenerateDuplicatesBatch] Failed to parse AI response for ${combination} (archetypeIndex: ${archetypeIndex}): ${response}`,
+              error
+            );
+            continue;
+          }
+
+          // Check if the new name is unique (globally across all combinations)
+          const isDuplicate = await db
+            .select({ name: schema.archetypesData.name })
+            .from(schema.archetypesData)
+            .where(
+              and(
+                eq(schema.archetypesData.language, 'en-us'),
+                eq(schema.archetypesData.name, newName.name_en)
+              )
+            )
+            .limit(1)
+            .execute();
+
+          if (isDuplicate.length > 0) {
+            console.warn(
+              `[RegenerateDuplicatesBatch] Generated name "${newName.name_en}" is already used. Adding to existing names and retrying.`
+            );
+            existingNames.push(newName.name_en);
+            newName = null;
+            continue;
+          }
+
+          // If we reach here, the name is unique
+          break;
+        }
+
+        if (!newName) {
+          console.error(
+            `[RegenerateDuplicatesBatch] Failed to generate a unique name for ${combination} (archetypeIndex: ${archetypeIndex}) after ${maxAttempts} attempts`
+          );
+          continue;
+        }
+
+        // Update the database with the new names
+        for (const gender of ['male', 'female']) {
+          const enId = `${combination}:${gender}:${archetypeIndex}`;
+          const ptId = `${combination}:${gender}:${archetypeIndex}:pt`;
+
+          // Update English entry
+          await db
+            .update(schema.archetypesData)
+            .set({
+              name: newName.name_en,
+              updatedAt: new Date().getTime(),
+            })
+            .where(
+              and(
+                eq(schema.archetypesData.id, enId),
+                eq(schema.archetypesData.language, 'en-us')
+              )
+            )
+            .execute();
+
+          // Update Portuguese entry
+          const ptName =
+            gender === 'female' ? newName.name_pt_female : newName.name_pt_male;
+          await db
+            .update(schema.archetypesData)
+            .set({
+              name: ptName,
+              updatedAt: new Date().getTime(),
+            })
+            .where(
+              and(
+                eq(schema.archetypesData.id, ptId),
+                eq(schema.archetypesData.language, 'pt-br')
+              )
+            )
+            .execute();
+
+          console.log(
+            `[RegenerateDuplicatesBatch] Updated ${combination} (archetypeIndex: ${archetypeIndex}, gender: ${gender}) with new name - English: ${newName.name_en}, Portuguese: ${ptName}`
+          );
+        }
+      }
+    }
+
+    console.log(`✅ [RegenerateDuplicatesBatch] Finished processing batch`);
+  }
+
+  async recycleArchetypeNameDumpsBatch(
+    compositions: Composition[]
+  ): Promise<void> {
     console.log('🔁 [Recycle] Starting recycling of archetype name dumps');
-  
+
     if (compositions.length === 0) {
       console.log('✅ [Recycle] No compositions provided for recycling');
       return;
     }
-  
+
     console.log(
       `📦 [Recycle] Total compositions to recycle: ${compositions.length}`
     );
-  
+
     // Step 1: Process each composition
     const db = this.context.drizzle();
     for (const comp of compositions) {
       const combination = [comp.sun, comp.ascendant, comp.moon].join('-');
       const indexes = comp.indexesToGenerate ?? [1, 2, 3];
-  
-      console.log(`🔄 [Recycle] Processing combination: ${combination} with indexes: [${indexes.join(', ')}]`);
-  
+
+      console.log(
+        `🔄 [Recycle] Processing combination: ${combination} with indexes: [${indexes.join(
+          ', '
+        )}]`
+      );
+
       // Fetch all dump entries for this combination
       const dumpEntries = await db
         .select({
@@ -762,22 +976,28 @@ export class ArchetypeService {
         .from(schema.archetypeNameDumps)
         .where(eq(schema.archetypeNameDumps.combination, combination))
         .execute();
-  
+
       console.log(
-        `[Recycle] Retrieved ${dumpEntries.length} dump entries for ${combination}: ${JSON.stringify(dumpEntries, null, 2)}`
+        `[Recycle] Retrieved ${
+          dumpEntries.length
+        } dump entries for ${combination}: ${JSON.stringify(
+          dumpEntries,
+          null,
+          2
+        )}`
       );
-  
+
       if (dumpEntries.length === 0) {
         console.log(
           `⚠️ [Recycle] No dump entries found for combination: ${combination}`
         );
         continue;
       }
-  
+
       // Step 2: Process each missing index
       for (const index of indexes) {
         console.log(`[Recycle] Processing index ${index} for ${combination}`);
-  
+
         // Find a dump entry that contains the specific index
         let rawText: string | null = null;
         let selectedEntryId: string | null = null;
@@ -791,21 +1011,25 @@ export class ArchetypeService {
             break;
           }
         }
-  
+
         if (!rawText) {
           console.log(
             `⚠️ [Recycle] No dump entry contains index ${index} for combination: ${combination}`
           );
           continue;
         }
-  
+
         // Clean up the raw text
-        console.log(`[Recycle] Cleaning rawText for index ${index}: ${rawText}`);
+        console.log(
+          `[Recycle] Cleaning rawText for index ${index}: ${rawText}`
+        );
         const cleanedText = rawText
           .replace(/###|---\s*###|-\s*###/g, '')
           .trim();
-        console.log(`[Recycle] Cleaned text for index ${index}: ${cleanedText}`);
-  
+        console.log(
+          `[Recycle] Cleaned text for index ${index}: ${cleanedText}`
+        );
+
         // Extract the specific index sections
         const enSectionMatch = cleanedText.match(
           new RegExp(`-EN ${index}\\.\\s*[^-]*(?=-EN|-PT|$)`, 's')
@@ -813,28 +1037,43 @@ export class ArchetypeService {
         const ptSectionMatch = cleanedText.match(
           new RegExp(`-PT ${index}\\.\\s*[^-]*(?=-EN|-PT|$)`, 's')
         );
-  
+
         console.log(
-          `[Recycle] Extracted sections for index ${index} - enSectionMatch: ${JSON.stringify(enSectionMatch)}, ptSectionMatch: ${JSON.stringify(ptSectionMatch)}`
+          `[Recycle] Extracted sections for index ${index} - enSectionMatch: ${JSON.stringify(
+            enSectionMatch
+          )}, ptSectionMatch: ${JSON.stringify(ptSectionMatch)}`
         );
-  
-        if (!enSectionMatch || !ptSectionMatch || !enSectionMatch[0] || !ptSectionMatch[0]) {
+
+        if (
+          !enSectionMatch ||
+          !ptSectionMatch ||
+          !enSectionMatch[0] ||
+          !ptSectionMatch[0]
+        ) {
           console.log(
-            `⚠️ [Recycle] Could not extract index ${index} sections for combination: ${combination}. enSectionMatch: ${JSON.stringify(enSectionMatch)}, ptSectionMatch: ${JSON.stringify(ptSectionMatch)}`
+            `⚠️ [Recycle] Could not extract index ${index} sections for combination: ${combination}. enSectionMatch: ${JSON.stringify(
+              enSectionMatch
+            )}, ptSectionMatch: ${JSON.stringify(ptSectionMatch)}`
           );
           continue;
         }
-  
+
         // Combine the extracted sections into a block for parsing
-        const block = `-EN\n${enSectionMatch[0].replace(/-EN\s*/, '').trim()}\n\n-PT\n${ptSectionMatch[0].replace(/-PT\s*/, '').trim()}`;
+        const block = `-EN\n${enSectionMatch[0]
+          .replace(/-EN\s*/, '')
+          .trim()}\n\n-PT\n${ptSectionMatch[0].replace(/-PT\s*/, '').trim()}`;
         console.log(`[Recycle] Constructed block for index ${index}: ${block}`);
-  
+
         // Step 3: Parse the block
         const { english, portuguese } = this.parseArchetypeNameBlocks(block);
         console.log(
-          `[Recycle] Parsed results for index ${index} - English: ${JSON.stringify(english, null, 2)}, Portuguese: ${JSON.stringify(portuguese, null, 2)}`
+          `[Recycle] Parsed results for index ${index} - English: ${JSON.stringify(
+            english,
+            null,
+            2
+          )}, Portuguese: ${JSON.stringify(portuguese, null, 2)}`
         );
-  
+
         if (english.length === 0 || portuguese.length === 0) {
           console.error(
             `❌ [Recycle] Parsing failed for index ${index} of combination: ${combination}. Block: ${block}`
@@ -860,27 +1099,33 @@ export class ArchetypeService {
           }
           continue;
         }
-  
+
         const englishEntry = english[0];
         const ptEntry = portuguese[0];
-  
+
         console.log(
-          `[Recycle] Extracted entries for index ${index} - englishEntry: ${JSON.stringify(englishEntry, null, 2)}, ptEntry: ${JSON.stringify(ptEntry, null, 2)}`
+          `[Recycle] Extracted entries for index ${index} - englishEntry: ${JSON.stringify(
+            englishEntry,
+            null,
+            2
+          )}, ptEntry: ${JSON.stringify(ptEntry, null, 2)}`
         );
-  
+
         if (!englishEntry || !ptEntry) {
           console.warn(
-            `⚠️ [Recycle] Skipping index ${index} for ${combination} due to missing parsed data. englishEntry: ${JSON.stringify(englishEntry)}, ptEntry: ${JSON.stringify(ptEntry)}`
+            `⚠️ [Recycle] Skipping index ${index} for ${combination} due to missing parsed data. englishEntry: ${JSON.stringify(
+              englishEntry
+            )}, ptEntry: ${JSON.stringify(ptEntry)}`
           );
           continue;
         }
-  
+
         // Step 4: Insert the parsed data into archetypes_data
         for (const gender of ['male', 'female']) {
           const enId = `${combination}:${gender}:${index}`;
           const ptId = `${combination}:${gender}:${index}:pt`;
           const ptName = gender === 'female' ? ptEntry.fem : ptEntry.masc;
-  
+
           console.log(
             `[Recycle] Inserting English entry for ${combination}, index ${index}, gender ${gender}: id=${enId}, name=${englishEntry.name}, essenceLine=${englishEntry.essenceLine}`
           );
@@ -905,7 +1150,7 @@ export class ArchetypeService {
                 updatedAt: new Date().getTime(),
               },
             });
-  
+
           console.log(
             `[Recycle] Inserting Portuguese entry for ${combination}, index ${index}, gender ${gender}: id=${ptId}, name=${ptName}, essenceLine=${ptEntry.essenceLine}`
           );
@@ -930,7 +1175,7 @@ export class ArchetypeService {
                 updatedAt: new Date().getTime(),
               },
             });
-  
+
           // Delete the processed dump entry
           if (selectedEntryId) {
             console.log(
@@ -947,16 +1192,16 @@ export class ArchetypeService {
               `[Recycle] Could not delete dump entry for ${combination}, index ${index}: selectedEntryId is null`
             );
           }
-  
+
           console.log(
             `✅ [Recycle] Saved archetype ${index} (${gender}) for ${combination}`
           );
         }
       }
-  
+
       console.log(`🏁 [Recycle] Finished combination: ${combination}`);
     }
-  
+
     console.log(
       `🎉 [Recycle] Completed recycling for ${compositions.length} combinations`
     );
@@ -1022,95 +1267,139 @@ export class ArchetypeService {
     portuguese: any[];
   } {
     console.log(`[Parse] Starting parsing of block: ${block}`);
-  
+
+    // Split the block into sections based on -EN and -PT markers
     const sections = block.split(/^-EN|^-PT/m).filter((s) => s.trim());
     console.log(
-      `[Parse] Split block into ${sections.length} sections: ${JSON.stringify(sections, null, 2)}`
+      `[Parse] Split block into ${sections.length} sections: ${JSON.stringify(
+        sections,
+        null,
+        2
+      )}`
     );
-  
+
     const english: any[] = [];
     const portuguese: any[] = [];
-  
-    for (const section of sections) {
+
+    // Track whether we're in an EN or PT section
+    let currentLang: 'EN' | 'PT' | null = null;
+
+    for (let i = 0; i < block.length; i++) {
+      if (block.startsWith('-EN', i)) {
+        currentLang = 'EN';
+        i += 3; // Skip past "-EN"
+      } else if (block.startsWith('-PT', i)) {
+        currentLang = 'PT';
+        i += 3; // Skip past "-PT"
+      }
+    }
+
+    // Process each section
+    for (let i = 0; i < sections.length; i++) {
+      const section = sections[i].trim();
       console.log(`[Parse] Processing section: ${section}`);
-  
-      if (section.startsWith('EN')) {
-        const lines = section.split('\n').filter((l) => l.trim());
-        console.log(
-          `[Parse] Extracted ${lines.length} lines from English section: ${JSON.stringify(lines, null, 2)}`
-        );
-  
-        const nameMatch = lines
-          .find((l) => l.includes('• Name:'))
-          ?.split('• Name:')[1]
-          ?.trim();
-        console.log(`[Parse] English nameMatch: ${nameMatch}`);
-  
-        const essenceMatch = lines
-          .find((l) => l.includes('• Essence:'))
-          ?.split('• Essence:')[1]
-          ?.trim();
-        console.log(`[Parse] English essenceMatch: ${essenceMatch}`);
-  
-        if (nameMatch && essenceMatch) {
-          const entry = { name: nameMatch, essenceLine: essenceMatch };
-          english.push(entry);
-          console.log(
-            `[Parse] Added English entry: ${JSON.stringify(entry, null, 2)}`
-          );
-        } else {
-          console.warn(
-            `[Parse] Skipping English section due to missing fields. nameMatch: ${nameMatch}, essenceMatch: ${essenceMatch}`
-          );
-        }
-      } else if (section.startsWith('PT')) {
-        const lines = section.split('\n').filter((l) => l.trim());
+
+      // Determine the language based on the section's position relative to -EN and -PT markers
+      const lang = i === 0 ? 'EN' : 'PT'; // First section after -EN, second after -PT
+
+      // Split the section into individual entries based on numbered markers (1., 2., 3.)
+      const entries = section.split(/\n(?=\d+\.\s*)/).filter((e) => e.trim());
+      console.log(
+        `[Parse] Split section into ${entries.length} entries: ${JSON.stringify(
+          entries,
+          null,
+          2
+        )}`
+      );
+
+      for (const entry of entries) {
+        const lines = entry.split('\n').filter((l) => l.trim());
         console.log(
-          `[Parse] Extracted ${lines.length} lines from Portuguese section: ${JSON.stringify(lines, null, 2)}`
+          `[Parse] Extracted ${lines.length} lines from entry: ${JSON.stringify(
+            lines,
+            null,
+            2
+          )}`
         );
-  
-        const mascMatch = lines
-          .find((l) => l.includes('• Masculino:'))
-          ?.split('• Masculino:')[1]
-          ?.trim();
-        console.log(`[Parse] Portuguese mascMatch: ${mascMatch}`);
-  
-        const femMatch = lines
-          .find((l) => l.includes('• Feminino:'))
-          ?.split('• Feminino:')[1]
-          ?.trim();
-        console.log(`[Parse] Portuguese femMatch: ${femMatch}`);
-  
-        const essenceMatch = lines
-          .find((l) => l.includes('• Essência:'))
-          ?.split('• Essência:')[1]
-          ?.trim();
-        console.log(`[Parse] Portuguese essenceMatch: ${essenceMatch}`);
-  
-        if (mascMatch && femMatch && essenceMatch) {
-          const entry = {
-            masc: mascMatch,
-            fem: femMatch,
-            essenceLine: essenceMatch,
-          };
-          portuguese.push(entry);
-          console.log(
-            `[Parse] Added Portuguese entry: ${JSON.stringify(entry, null, 2)}`
-          );
-        } else {
-          console.warn(
-            `[Parse] Skipping Portuguese section due to missing fields. mascMatch: ${mascMatch}, femMatch: ${femMatch}, essenceMatch: ${essenceMatch}`
-          );
+
+        if (lang === 'EN') {
+          const nameMatch = lines
+            .find((l) => l.includes('• Name:'))
+            ?.split('• Name:')[1]
+            ?.trim();
+          console.log(`[Parse] English nameMatch: ${nameMatch}`);
+
+          const essenceMatch = lines
+            .find((l) => l.includes('• Essence:'))
+            ?.split('• Essence:')[1]
+            ?.trim();
+          console.log(`[Parse] English essenceMatch: ${essenceMatch}`);
+
+          if (nameMatch && essenceMatch) {
+            const englishEntry = { name: nameMatch, essenceLine: essenceMatch };
+            english.push(englishEntry);
+            console.log(
+              `[Parse] Added English entry: ${JSON.stringify(
+                englishEntry,
+                null,
+                2
+              )}`
+            );
+          } else {
+            console.warn(
+              `[Parse] Skipping English entry due to missing fields. nameMatch: ${nameMatch}, essenceMatch: ${essenceMatch}`
+            );
+          }
+        } else if (lang === 'PT') {
+          const mascMatch = lines
+            .find((l) => l.includes('• Masculino:'))
+            ?.split('• Masculino:')[1]
+            ?.trim();
+          console.log(`[Parse] Portuguese mascMatch: ${mascMatch}`);
+
+          const femMatch = lines
+            .find((l) => l.includes('• Feminino:'))
+            ?.split('• Feminino:')[1]
+            ?.trim();
+          console.log(`[Parse] Portuguese femMatch: ${femMatch}`);
+
+          const essenceMatch = lines
+            .find((l) => l.includes('• Essência:'))
+            ?.split('• Essência:')[1]
+            ?.trim();
+          console.log(`[Parse] Portuguese essenceMatch: ${essenceMatch}`);
+
+          if (mascMatch && femMatch && essenceMatch) {
+            const ptEntry = {
+              masc: mascMatch,
+              fem: femMatch,
+              essenceLine: essenceMatch,
+            };
+            portuguese.push(ptEntry);
+            console.log(
+              `[Parse] Added Portuguese entry: ${JSON.stringify(
+                ptEntry,
+                null,
+                2
+              )}`
+            );
+          } else {
+            console.warn(
+              `[Parse] Skipping Portuguese entry due to missing fields. mascMatch: ${mascMatch}, femMatch: ${femMatch}, essenceMatch: ${essenceMatch}`
+            );
+          }
         }
-      } else {
-        console.warn(`[Parse] Unrecognized section: ${section}`);
       }
     }
-  
+
     console.log(
-      `[Parse] Final parsed results - English: ${JSON.stringify(english, null, 2)}, Portuguese: ${JSON.stringify(portuguese, null, 2)}`
+      `[Parse] Final parsed results - English: ${JSON.stringify(
+        english,
+        null,
+        2
+      )}, Portuguese: ${JSON.stringify(portuguese, null, 2)}`
     );
-  
+
     return { english, portuguese };
   }
 }

package/package.json

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

package/utils/duplicatedArchetypeNamePrompt.ts

@@ -0,0 +1,47 @@
+type ArchetypePromptInputs = {
+  combination: string;
+  essenceLine: string;
+  existingNames: string[];
+};
+
+export function duplicatedArchetypeNamePrompt({
+  combination,
+  essenceLine,
+  existingNames,
+}: ArchetypePromptInputs): string {
+  return `
+You are a creative naming assistant for a symbolic astrology project. Each archetype is defined by a unique combination of three zodiac signs (Sun, Moon, Ascendant), and has an associated *essence line* that captures its spiritual and psychological meaning. Your task is to generate a new, poetic and meaningful name for the archetype, ensuring it is unique among previously used names.
+
+---
+
+Input:
+
+- Combination: \`${combination}\`
+- Essence Line: \`${essenceLine}\`
+- Existing Names: \`${JSON.stringify(existingNames)}\`
+
+---
+
+Important Instructions:
+
+1. Create a new archetype name that poetically reflects the given essence line.
+2. The name should follow the same style as existing archetypes (e.g., \`The Wandering Alchemist\`, \`The Radiant Mask\`, \`The Harmonious Builder\`).
+3. The name must not appear in the list of existing names.
+4. Also generate Portuguese translations of the name:
+   - One in masculine form.
+   - One in feminine form.
+5. Ensure all outputs are semantically coherent and well-written.
+6. Use the following output format precisely.
+
+---
+
+Output Format (exactly like this, do not change it):
+
+{
+  "name_en": <Name in English>,
+  "name_pt_male": <Name in Portuguese Male>,
+  "name_pt_female": <Name in Portuguese Female>,
+}
+
+`;
+}