@zodic/shared 0.0.316 → 0.0.318

package/app/services/ArchetypeService.ts

@@ -6,6 +6,19 @@ import { ZodiacSignSlug } from '../../types/scopes/legacy';
 import { generateArchetypePrompt } from '../../utils/archetypeNamesMessages';
 import { AppContext } from '../base';
 
+interface ParsedDescriptionAndVirtues {
+  descriptionEN: string;
+  descriptionPTM: string;
+  descriptionPTF: string;
+  virtuesEN: string[];
+  virtuesPT: string[];
+}
+
+interface LeonardoPrompt {
+  malePrompt: string;
+  femalePrompt: string;
+}
+
 @injectable()
 export class ArchetypeService {
   constructor(@inject(AppContext) private context: AppContext) {}
@@ -241,7 +254,7 @@ export class ArchetypeService {
       gender,
       language,
     });
-
+  
     const db = this.context.drizzle();
     const archetypes = await db
       .select()
@@ -254,12 +267,12 @@ export class ArchetypeService {
         )
       )
       .execute();
-
+  
     await this.log('info', 'Fetched archetypes for description generation', {
       archetypesCount: archetypes.length,
       names: archetypes.map((a) => a.name),
     });
-
+  
     const descVirtueMessages = this.context
       .buildLLMMessages()
       .generateCosmicMirrorDescriptionAndVirtues({
@@ -271,7 +284,7 @@ export class ArchetypeService {
           archetypes[2].essenceLine,
         ],
       });
-
+  
     await this.log('debug', 'Calling API for descriptions and virtues', {
       messages: descVirtueMessages,
     });
@@ -289,50 +302,83 @@ export class ArchetypeService {
     await this.log('info', 'Received descriptions and virtues response', {
       responseLength: descVirtueResponse.length,
     });
-
-    const parsedDescVirtues =
-      this.parseDescriptionAndVirtuesResponse(descVirtueResponse);
+  
+    const parsedDescVirtues = this.parseDescriptionAndVirtuesResponse(descVirtueResponse);
     await this.log('info', 'Parsed descriptions and virtues', {
       parsedDescVirtues,
     });
-
+  
     for (let i = 0; i < 3; i++) {
       const index = (i + 1).toString();
-      for (const lang of ['en-us', 'pt-br']) {
-        const descriptionField =
-          lang === 'en-us'
-            ? parsedDescVirtues[i].descriptionEN
-            : gender === 'male'
-            ? parsedDescVirtues[i].descriptionPTM
-            : parsedDescVirtues[i].descriptionPTF;
-
-        const id = `${combinationString}:${gender}:${index}${
-          lang === 'pt-br' ? ':pt' : ''
-        }`;
-        await this.log('debug', `Updating description and virtues for ${id}`, {
-          description: descriptionField,
-          virtues: parsedDescVirtues[i].virtues,
-        });
-
-        await db
-          .update(schema.archetypesData)
-          .set({
-            description: descriptionField,
-            virtues: JSON.stringify(parsedDescVirtues[i].virtues),
-            updatedAt: new Date().getTime(),
-          })
-          .where(
-            and(
-              eq(schema.archetypesData.id, id),
-              eq(schema.archetypesData.language, lang)
-            )
+      
+      // Update English entry (en-us)
+      const enId = `${combinationString}:${gender}:${index}`;
+      await this.log('debug', `Updating description and virtues for ${enId}`, {
+        description: parsedDescVirtues[i].descriptionEN,
+        virtues: parsedDescVirtues[i].virtuesEN,
+      });
+      await db
+        .update(schema.archetypesData)
+        .set({
+          description: parsedDescVirtues[i].descriptionEN,
+          virtues: JSON.stringify(parsedDescVirtues[i].virtuesEN),
+          updatedAt: new Date().getTime(),
+        })
+        .where(
+          and(
+            eq(schema.archetypesData.id, enId),
+            eq(schema.archetypesData.language, 'en-us')
           )
-          .execute();
-
-        await this.log('info', `Updated description and virtues for ${id}`);
-      }
+        )
+        .execute();
+      await this.log('info', `Updated description and virtues for ${enId}`);
+  
+      // Update Portuguese entries (pt-br) for both male and female
+      const ptIdMale = `${combinationString}:${gender}:${index}:pt`;
+      await this.log('debug', `Updating description and virtues for ${ptIdMale} (male)`, {
+        description: parsedDescVirtues[i].descriptionPTM,
+        virtues: parsedDescVirtues[i].virtuesPT,
+      });
+      await db
+        .update(schema.archetypesData)
+        .set({
+          description: parsedDescVirtues[i].descriptionPTM,
+          virtues: JSON.stringify(parsedDescVirtues[i].virtuesPT),
+          updatedAt: new Date().getTime(),
+        })
+        .where(
+          and(
+            eq(schema.archetypesData.id, ptIdMale),
+            eq(schema.archetypesData.language, 'pt-br'),
+            eq(schema.archetypesData.gender, 'male')
+          )
+        )
+        .execute();
+      await this.log('info', `Updated description and virtues for ${ptIdMale} (male)`);
+  
+      const ptIdFemale = `${combinationString}:${gender}:${index}:pt`;
+      await this.log('debug', `Updating description and virtues for ${ptIdFemale} (female)`, {
+        description: parsedDescVirtues[i].descriptionPTF,
+        virtues: parsedDescVirtues[i].virtuesPT,
+      });
+      await db
+        .update(schema.archetypesData)
+        .set({
+          description: parsedDescVirtues[i].descriptionPTF,
+          virtues: JSON.stringify(parsedDescVirtues[i].virtuesPT),
+          updatedAt: new Date().getTime(),
+        })
+        .where(
+          and(
+            eq(schema.archetypesData.id, ptIdFemale),
+            eq(schema.archetypesData.language, 'pt-br'),
+            eq(schema.archetypesData.gender, 'female')
+          )
+        )
+        .execute();
+      await this.log('info', `Updated description and virtues for ${ptIdFemale} (female)`);
     }
-
+  
     await this.log('info', 'Completed generateDescriptionsAndVirtues', {
       combinationString,
       gender,
@@ -341,126 +387,136 @@ export class ArchetypeService {
     return parsedDescVirtues;
   }
 
-  private parseDescriptionAndVirtuesResponse(response: string) {
+
+  private parseDescriptionAndVirtuesResponse(response: string): ParsedDescriptionAndVirtues[] {
     this.log('debug', 'Starting parseDescriptionAndVirtuesResponse', {
       responseLength: response.length,
     });
-
+  
     const entries = response
       .split(/---/)
       .map((block) => block.trim())
       .filter((block) => block.length > 0);
-
+  
     this.log('debug', 'Split response into entries', {
       entriesCount: entries.length,
     });
-
+  
+    if (entries.length !== 3) {
+      this.log('error', 'Expected exactly 3 archetype entries', {
+        entriesCount: entries.length,
+        response,
+      });
+      throw new Error(`Expected exactly 3 archetype entries, but got ${entries.length}`);
+    }
+  
     const result = entries.map((entry, entryIndex) => {
       this.log('debug', `Processing entry ${entryIndex + 1}`, { entry });
-
-      const lines = entry.split('\n').filter((line) => line.trim());
+  
+      const lines = entry.split('\n').map((line) => line.trim()).filter((line) => line);
       this.log('debug', `Split entry ${entryIndex + 1} into lines`, {
         linesCount: lines.length,
         lines,
       });
-
+  
       let descriptionEN = '';
       let descriptionPTM = '';
       let descriptionPTF = '';
-      let virtues: string[] = [];
+      let virtuesEN: string[] = [];
+      let virtuesPT: string[] = [];
       let currentField = '';
-
-      for (const line of lines) {
+  
+      for (let i = 0; i < lines.length; i++) {
+        let line = lines[i];
+  
+        // Remove markdown bold (**...**) from field names
+        line = line.replace(/\*\*(.*?)\*\*/g, '$1');
+  
+        if (line.startsWith('1.') || line.startsWith('2.') || line.startsWith('3.')) {
+          continue; // Skip entry number lines
+        }
+  
         if (line.startsWith('• Description EN:')) {
           currentField = 'descriptionEN';
           descriptionEN = line.split('• Description EN:')[1]?.trim() || '';
-          this.log(
-            'debug',
-            `Extracted descriptionEN for entry ${entryIndex + 1}`,
-            { descriptionEN }
-          );
+          this.log('debug', `Extracted descriptionEN for entry ${entryIndex + 1}`, { descriptionEN });
         } else if (line.startsWith('• Description PT-M:')) {
           currentField = 'descriptionPTM';
           descriptionPTM = line.split('• Description PT-M:')[1]?.trim() || '';
-          this.log(
-            'debug',
-            `Extracted descriptionPTM for entry ${entryIndex + 1}`,
-            { descriptionPTM }
-          );
+          this.log('debug', `Extracted descriptionPTM for entry ${entryIndex + 1}`, { descriptionPTM });
         } else if (line.startsWith('• Description PT-F:')) {
           currentField = 'descriptionPTF';
           descriptionPTF = line.split('• Description PT-F:')[1]?.trim() || '';
-          this.log(
-            'debug',
-            `Extracted descriptionPTF for entry ${entryIndex + 1}`,
-            { descriptionPTF }
-          );
+          this.log('debug', `Extracted descriptionPTF for entry ${entryIndex + 1}`, { descriptionPTF });
+        } else if (line.startsWith('• Virtues EN:')) {
+          currentField = 'virtuesEN';
+          virtuesEN = line
+            .split('• Virtues EN:')[1]
+            ?.split(',')
+            .map((v) => v.trim())
+            .filter((v) => v)
+            .slice(0, 3);
+          this.log('debug', `Extracted virtuesEN for entry ${entryIndex + 1}`, { virtuesEN });
+        } else if (line.startsWith('• Virtues PT:')) {
+          currentField = 'virtuesPT';
+          virtuesPT = line
+            .split('• Virtues PT:')[1]
+            ?.split(',')
+            .map((v) => v.trim())
+            .filter((v) => v)
+            .slice(0, 3);
+          this.log('debug', `Extracted virtuesPT for entry ${entryIndex + 1}`, { virtuesPT });
         } else if (line.startsWith('• Virtues:')) {
-          currentField = 'virtues';
-          virtues =
-            line
-              .split('• Virtues:')[1]
-              ?.split(',')
-              .map((v) => v.trim())
-              .filter((v) => v) || [];
-          this.log('debug', `Extracted virtues for entry ${entryIndex + 1}`, {
-            virtues,
-          });
-        } else if (currentField && currentField !== 'virtues') {
+          // Fallback for older response format: use English virtues and attempt to translate
+          currentField = 'virtuesEN';
+          virtuesEN = line
+            .split('• Virtues:')[1]
+            ?.split(',')
+            .map((v) => v.trim())
+            .filter((v) => v)
+            .slice(0, 3);
+          this.log('debug', `Extracted virtuesEN (fallback) for entry ${entryIndex + 1}`, { virtuesEN });
+  
+          // Simple translation mapping for common virtues (as a fallback)
+          const virtueTranslations: { [key: string]: string } = {
+            Harmony: 'Harmonia',
+            Intuition: 'Intuição',
+            Grace: 'Graça',
+            // Add more translations as needed
+          };
+          virtuesPT = virtuesEN.map((v) => virtueTranslations[v] || v); // Fallback to English if no translation
+          this.log('debug', `Generated virtuesPT (fallback) for entry ${entryIndex + 1}`, { virtuesPT });
+        } else if (currentField && !currentField.startsWith('virtues')) {
           if (currentField === 'descriptionEN') {
-            descriptionEN += ' ' + line.trim();
-            this.log(
-              'debug',
-              `Appended to descriptionEN for entry ${entryIndex + 1}`,
-              { descriptionEN }
-            );
-          }
-          if (currentField === 'descriptionPTM') {
-            descriptionPTM += ' ' + line.trim();
-            this.log(
-              'debug',
-              `Appended to descriptionPTM for entry ${entryIndex + 1}`,
-              { descriptionPTM }
-            );
-          }
-          if (currentField === 'descriptionPTF') {
-            descriptionPTF += ' ' + line.trim();
-            this.log(
-              'debug',
-              `Appended to descriptionPTF for entry ${entryIndex + 1}`,
-              { descriptionPTF }
-            );
+            descriptionEN += ' ' + line;
+            this.log('debug', `Appended to descriptionEN for entry ${entryIndex + 1}`, { descriptionEN });
+          } else if (currentField === 'descriptionPTM') {
+            descriptionPTM += ' ' + line;
+            this.log('debug', `Appended to descriptionPTM for entry ${entryIndex + 1}`, { descriptionPTM });
+          } else if (currentField === 'descriptionPTF') {
+            descriptionPTF += ' ' + line;
+            this.log('debug', `Appended to descriptionPTF for entry ${entryIndex + 1}`, { descriptionPTF });
           }
         }
       }
-
-      if (
-        !descriptionEN ||
-        !descriptionPTM ||
-        !descriptionPTF ||
-        virtues.length !== 3
-      ) {
-        this.log(
-          'warn',
-          `Malformed description and virtues response for entry ${
-            entryIndex + 1
-          }`,
-          {
-            descriptionEN,
-            descriptionPTM,
-            descriptionPTF,
-            virtues,
-            response: entry,
-          }
-        );
+  
+      // Validate the parsed data
+      if (!descriptionEN || !descriptionPTM || !descriptionPTF || virtuesEN.length !== 3 || virtuesPT.length !== 3) {
+        this.log('warn', `Malformed description and virtues response for entry ${entryIndex + 1}`, {
+          descriptionEN,
+          descriptionPTM,
+          descriptionPTF,
+          virtuesEN,
+          virtuesPT,
+          response: entry,
+        });
+        throw new Error(`Malformed response for entry ${entryIndex + 1}: Missing required fields`);
       }
-
-      return { descriptionEN, descriptionPTM, descriptionPTF, virtues };
-    });
-
-    this.log('info', 'Completed parseDescriptionAndVirtuesResponse', {
-      result,
+  
+      return { descriptionEN, descriptionPTM, descriptionPTF, virtuesEN, virtuesPT };
     });
+  
+    this.log('info', 'Completed parseDescriptionAndVirtuesResponse', { result });
     return result;
   }
 
@@ -819,51 +875,67 @@ export class ArchetypeService {
     return parsedPrompts;
   }
 
-  private parseLeonardoPromptResponse(response: string) {
+  private parseLeonardoPromptResponse(response: string): LeonardoPrompt[] {
     this.log('debug', 'Starting parseLeonardoPromptResponse', {
       responseLength: response.length,
     });
-
+  
     const lines = response.split('\n').filter((line) => line.trim());
     this.log('debug', 'Split response into lines', {
       linesCount: lines.length,
       lines,
     });
-
-    const prompts: Array<{ malePrompt: string; femalePrompt: string }> = [];
-
-    for (let i = 0; i < lines.length; i += 2) {
-      const maleLine = lines[i];
-      const femaleLine = lines[i + 1];
-
-      const malePrompt = maleLine.startsWith(`${Math.floor(i / 2) + 1}.m`)
-        ? maleLine.split(`${Math.floor(i / 2) + 1}.m`)[1]?.trim()
-        : '';
-      const femalePrompt = femaleLine.startsWith(`${Math.floor(i / 2) + 1}.f`)
-        ? femaleLine.split(`${Math.floor(i / 2) + 1}.f`)[1]?.trim()
-        : '';
-
-      prompts.push({ malePrompt, femalePrompt });
-      this.log(
-        'debug',
-        `Parsed prompts for archetype ${Math.floor(i / 2) + 1}`,
-        { malePrompt, femalePrompt }
-      );
-
+  
+    const prompts: LeonardoPrompt[] = [];
+    let currentArchetype = 0;
+  
+    for (let i = 0; i < lines.length; i += 4) {
+      // Expect pairs of label and prompt: "1.m", male prompt, "1.f", female prompt
+      const maleLabel = lines[i]; // "1.m"
+      const malePromptLine = lines[i + 1]; // Male prompt text
+      const femaleLabel = lines[i + 2]; // "1.f"
+      const femalePromptLine = lines[i + 3]; // Female prompt text
+  
+      currentArchetype++;
+      const expectedMaleLabel = `${currentArchetype}.m`;
+      const expectedFemaleLabel = `${currentArchetype}.f`;
+  
+      if (!maleLabel?.startsWith(expectedMaleLabel) || !femaleLabel?.startsWith(expectedFemaleLabel)) {
+        this.log('warn', `Malformed Leonardo prompt format for archetype ${currentArchetype}`, {
+          maleLabel,
+          malePromptLine,
+          femaleLabel,
+          femalePromptLine,
+          lines,
+        });
+        throw new Error(`Expected ${expectedMaleLabel} and ${expectedFemaleLabel} at lines ${i} and ${i + 2}`);
+      }
+  
+      const malePrompt = malePromptLine?.trim() || '';
+      const femalePrompt = femalePromptLine?.trim() || '';
+  
       if (!malePrompt || !femalePrompt) {
-        this.log(
-          'warn',
-          `Malformed Leonardo prompt for archetype ${Math.floor(i / 2) + 1}`,
-          {
-            malePrompt,
-            femalePrompt,
-            maleLine,
-            femaleLine,
-          }
-        );
+        this.log('warn', `Empty Leonardo prompt for archetype ${currentArchetype}`, {
+          malePrompt,
+          femalePrompt,
+          malePromptLine,
+          femalePromptLine,
+        });
+        throw new Error(`Empty prompt for archetype ${currentArchetype}`);
       }
+  
+      prompts.push({ malePrompt, femalePrompt });
+      this.log('debug', `Parsed prompts for archetype ${currentArchetype}`, { malePrompt, femalePrompt });
     }
-
+  
+    if (prompts.length !== 3) {
+      this.log('error', 'Expected exactly 3 archetype prompts', {
+        promptsCount: prompts.length,
+        response,
+      });
+      throw new Error(`Expected exactly 3 archetype prompts, but got ${prompts.length}`);
+    }
+  
     this.log('info', 'Completed parseLeonardoPromptResponse', { prompts });
     return prompts;
   }

package/app/services/LeonardoService.ts

@@ -53,39 +53,52 @@ export class LeonardoService {
    * Processes a message from ARCHETYPE_POPULATION_QUEUE to ensure the archetype has three images.
    */
   async processArchetypePopulation(message: QueueMessage): Promise<void> {
-    const { archetypeDataId, combination, gender, language, archetypeIndex } =
-      message;
+    const { archetypeDataId } = message;
     await this.log('info', 'Processing archetype population', {
       archetypeDataId,
-      combination,
-      gender,
-      language,
-      archetypeIndex,
     });
-
+  
     const db = this.context.drizzle();
     const archetype = await db
-      .select()
+      .select({
+        id: schema.archetypesData.id,
+        combination: schema.archetypesData.combination,
+        gender: schema.archetypesData.gender,
+        language: schema.archetypesData.language,
+        archetypeIndex: schema.archetypesData.archetypeIndex,
+        leonardoPrompt: schema.archetypesData.leonardoPrompt,
+        images: schema.archetypesData.images,
+      })
       .from(schema.archetypesData)
       .where(eq(schema.archetypesData.id, archetypeDataId))
       .limit(1)
       .execute();
-
+  
     if (!archetype[0]) {
       await this.log('error', 'Archetype not found', { archetypeDataId });
       throw new Error(`Archetype not found: ${archetypeDataId}`);
     }
-
-    const images = JSON.parse(archetype[0].images || '[]');
-    if (images.length >= 3) {
+  
+    const { combination, gender, language, archetypeIndex, leonardoPrompt, images } = archetype[0];
+  
+    await this.log('info', 'Fetched archetype details', {
+      archetypeDataId,
+      combination,
+      gender,
+      language,
+      archetypeIndex,
+    });
+  
+    const parsedImages = JSON.parse(images || '[]');
+    if (parsedImages.length >= 3) {
       await this.log('info', 'Archetype already has sufficient images', {
         archetypeDataId,
-        imageCount: images.length,
+        imageCount: parsedImages.length,
       });
       return;
     }
-
-    if (!archetype[0].leonardoPrompt) {
+  
+    if (!leonardoPrompt) {
       await this.log('error', 'Missing Leonardo prompt for archetype', {
         archetypeDataId,
       });
@@ -93,21 +106,21 @@ export class LeonardoService {
         `Missing Leonardo prompt for archetype: ${archetypeDataId}`
       );
     }
-
+  
     await this.log('debug', 'Generating images for archetype', {
       archetypeDataId,
-      prompt: archetype[0].leonardoPrompt,
+      prompt: leonardoPrompt,
     });
-
+  
     const generationResponse = await this.context
       .api()
       .callLeonardo.generateImage({
-        prompt: archetype[0].leonardoPrompt,
+        prompt: leonardoPrompt,
         width: 512,
         height: 640,
-        quantity: 3 - images.length,
+        quantity: 3 - parsedImages.length,
       });
-
+  
     const generationId = generationResponse.sdGenerationJob.generationId;
     if (!generationId) {
       await this.log(
@@ -117,7 +130,7 @@ export class LeonardoService {
       );
       throw new Error('Leonardo generation failed to return a valid ID');
     }
-
+  
     await db.insert(schema.generations).values({
       id: generationId,
       archetypeIndex: parseInt(archetypeIndex),
@@ -127,11 +140,11 @@ export class LeonardoService {
       gender,
       createdAt: new Date(),
     });
-
+  
     await this.log('info', 'Queued image generation', {
       generationId,
       archetypeDataId,
-      imagesToGenerate: 3 - images.length,
+      imagesToGenerate: 3 - parsedImages.length,
     });
   }
 

package/app/workflow/ArchetypeWorkflow.ts

@@ -1,4 +1,4 @@
-import { and, eq } from 'drizzle-orm';
+import { and, eq, inArray } from 'drizzle-orm';
 import { inject, injectable } from 'inversify';
 import { schema } from '../..';
 import { Gender } from '../../types';
@@ -55,7 +55,7 @@ export class ArchetypeWorkflow {
       gender,
       language,
     });
-
+  
     // Step 1: Check if archetypes exist, if not, generate names
     let archetypes = await this.archetypeService.fetchArchetypesFromDB(
       combinationString,
@@ -79,7 +79,7 @@ export class ArchetypeWorkflow {
       archetypesCount: archetypes.length,
       archetypeIds: archetypes.map((a) => a.id),
     });
-
+  
     // Step 2: Check if any archetypes are already being processed (images are generating)
     const db = this.context.drizzle();
     await this.log('debug', 'Checking for in-progress image generations', {
@@ -93,11 +93,14 @@ export class ArchetypeWorkflow {
         and(
           eq(schema.generations.status, 'pending'),
           eq(schema.generations.gender, gender),
-          eq(schema.generations.archetypeDataId, combinationString)
+          inArray(
+            schema.generations.archetypeDataId,
+            archetypes.map((a) => a.id)
+          )
         )
       )
       .execute();
-
+  
     if (inProgressGenerations.length > 0) {
       await this.log(
         'warn',
@@ -113,7 +116,7 @@ export class ArchetypeWorkflow {
       combinationString,
       gender,
     });
-
+  
     // Step 3: Generate missing textual content (description, virtues, content, leonardoPrompt)
     const archetypesNeedingText = archetypes.filter(
       (arc) =>
@@ -122,7 +125,7 @@ export class ArchetypeWorkflow {
         arc.content === '[]' ||
         !arc.leonardoPrompt
     );
-
+  
     if (archetypesNeedingText.length > 0) {
       await this.log('info', 'Generating missing textual content', {
         combinationString,
@@ -131,7 +134,7 @@ export class ArchetypeWorkflow {
         archetypesNeedingTextCount: archetypesNeedingText.length,
         archetypeIds: archetypesNeedingText.map((a) => a.id),
       });
-
+  
       const descVirtues =
         await this.archetypeService.generateDescriptionsAndVirtues(
           combinationString,
@@ -157,7 +160,7 @@ export class ArchetypeWorkflow {
         language,
       });
     }
-
+  
     // Refetch archetypes after generating textual content
     const updatedArchetypes = await this.archetypeService.fetchArchetypesFromDB(
       combinationString,
@@ -168,12 +171,12 @@ export class ArchetypeWorkflow {
       updatedArchetypesCount: updatedArchetypes.length,
       archetypeIds: updatedArchetypes.map((a) => a.id),
     });
-
+  
     // Step 4: Queue image generation if needed
     const archetypesNeedingImages = updatedArchetypes.filter(
       (arc) => JSON.parse(arc.images).length < 3
     );
-
+  
     if (archetypesNeedingImages.length > 0) {
       await this.log(
         'info',
@@ -183,14 +186,10 @@ export class ArchetypeWorkflow {
           archetypeIds: archetypesNeedingImages.map((a) => a.id),
         }
       );
-
+  
       const batch = archetypesNeedingImages.map((arc) => ({
         body: {
           archetypeDataId: arc.id,
-          combination: combinationString,
-          gender,
-          language,
-          archetypeIndex: arc.archetypeIndex,
         },
       }));
       await this.log('debug', 'Sending batch to ARCHETYPE_POPULATION_QUEUE', {
@@ -201,10 +200,10 @@ export class ArchetypeWorkflow {
       await this.log('info', 'Successfully queued image generation', {
         batchCount: batch.length,
       });
-
+  
       return { message: 'Images are being processed, please try again later.' };
     }
-
+  
     await this.log('info', 'Archetypes fully processed and ready', {
       updatedArchetypes,
     });

package/package.json

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

package/utils/buildMessages.ts

@@ -34,38 +34,52 @@ export const buildLLMMessages = (env: BackendBindings) => ({
      • Portuguese — masculine version
      • Portuguese — feminine version
   
-  2. Three symbolic **Virtues** for each archetype.
+  2. Three symbolic **Virtues** for each archetype, in both English and Portuguese:
+     • English Virtues (e.g., Harmony, Intuition, Grace)
+     • Portuguese Virtues (e.g., Harmonia, Intuição, Graça)
   
   —
   
-  ✳️ Use the following format exactly for the response:
+  ✳️ Use the following format exactly for the response. Ensure each section is separated by a line break, and virtues are comma-separated on a single line. Do not use markdown (e.g., **bold**) in the field names:
   
   ---
   
   1.
   
-  • Description EN: ...
-  • Description PT-M: ...
-  • Description PT-F: ...
-  • Virtues: Virtue1, Virtue2, Virtue3
+  • Description EN: [Description in English]
+  • Description PT-M: [Description in Portuguese, masculine]
+  • Description PT-F: [Description in Portuguese, feminine]
+  • Virtues EN: Virtue1, Virtue2, Virtue3
+  • Virtues PT: Virtude1, Virtude2, Virtude3
   
   ---
   
   2.
   
-  • Description EN: ...
-  • Description PT-M: ...
-  • Description PT-F: ...
-  • Virtues: Virtue1, Virtue2, Virtue3
+  • Description EN: [Description in English]
+  • Description PT-M: [Description in Portuguese, masculine]
+  • Description PT-F: [Description in Portuguese, feminine]
+  • Virtues EN: Virtue1, Virtue2, Virtue3
+  • Virtues PT: Virtude1, Virtude2, Virtude3
   
   ---
   
   3.
   
-  • Description EN: ...
-  • Description PT-M: ...
-  • Description PT-F: ...
-  • Virtues: Virtue1, Virtue2, Virtue3
+  • Description EN: [Description in English]
+  • Description PT-M: [Description in Portuguese, masculine]
+  • Description PT-F: [Description in Portuguese, feminine]
+  • Virtues EN: Virtue1, Virtue2, Virtue3
+  • Virtues PT: Virtude1, Virtude2, Virtude3
+  
+  —
+  
+  ✳️ Rules:
+  - Do not include extra text outside the specified format.
+  - Do not use markdown (e.g., **bold**, *italic*) in field names like "Description EN" or "Virtues EN".
+  - Ensure each description is 80–100 words.
+  - Virtues must be exactly three per archetype, comma-separated, on a single line.
+  - Use proper grammar and avoid ambiguity in translations.
   `,
       },
       {
@@ -211,56 +225,57 @@ export const buildLLMMessages = (env: BackendBindings) => ({
     {
       role: 'system',
       content: `
-        You are an expert in fantasy image generation. Your task is to transform archetype names and symbolic descriptions into highly detailed prompts for generating photorealistic fantasy characters using Leonardo.ai.
-
-        For each archetype, generate two prompts:
-        - One for a male character
-        - One for a female character
-
-        Instructions:
-        - Focus primarily on the character design—their appearance, clothing, and demeanor. This is more important than the background or setting.
-        - The setting should remain fantasy-inspired, but avoid over-specification. General hints like “enchanted realm” or “mystical battlefield” are enough unless the archetype demands more.
-        - The character must reflect the symbolic and mythic tone of the archetype name and description.
-        - Make sure male characters have short, cropped, or bald hair. Never long.
-        - Female characters may have long, flowing, or styled hair if it suits the archetype.
-        - The outfit should be rich in fantasy elements: armor, cloaks, robes, accessories. Avoid modern or casual clothing.
-        - The character must always be facing the camera, with a clear, visible face.
-        - Rendering instructions must include: 8K, HDR, Unreal Engine, photorealism, cinematic lighting, full body, fantasy aesthetic.
-
-        Each prompt must:
-        - Be under 1200 characters (including spaces).
-        - Clearly distinguish between the male and female versions only by adapting gender-specific features.
-        - Maintain identical structure, setting, and tone between both versions.
-
-        Output Format
-
-        1.m
-        [Prompt for the first archetype made for a male character]
-
-        1.f
-        [Prompt for the first archetype made for a female character (same as the male prompt but adapted for gender-specific traits)]
-
-        2.m
-        [Prompt for the second archetype made for a male character]
-
-        2.f
-        [Prompt for the second archetype made for a female character]
-
-        3.m
-        [Prompt for the third archetype made for a male character]
-
-        3.f
-        [Prompt for the third archetype made for a female character]
-      `,
+  You are an expert in fantasy image generation. Your task is to transform archetype names and symbolic descriptions into highly detailed prompts for generating photorealistic fantasy characters using Leonardo.ai.
+  
+  For each archetype, generate two prompts:
+  - One for a male character
+  - One for a female character
+  
+  Instructions:
+  - Focus primarily on the character design—their appearance, clothing, and demeanor. This is more important than the background or setting.
+  - The setting should remain fantasy-inspired, but avoid over-specification. General hints like “enchanted realm” or “mystical battlefield” are enough unless the archetype demands more.
+  - The character must reflect the symbolic and mythic tone of the archetype name and description.
+  - Make sure male characters have short, cropped, or bald hair. Never long.
+  - Female characters may have long, flowing, or styled hair if it suits the archetype.
+  - The outfit should be rich in fantasy elements: armor, cloaks, robes, accessories. Avoid modern or casual clothing.
+  - The character must always be facing the camera, with a clear, visible face.
+  - Rendering instructions must include: 8K, HDR, Unreal Engine, photorealism, cinematic lighting, full body, fantasy aesthetic.
+  
+  Each prompt must:
+  - Be under 1200 characters (including spaces).
+  - Clearly distinguish between the male and female versions only by adapting gender-specific features.
+  - Maintain identical structure, setting, and tone between both versions.
+  - Be written on a single line (no line breaks within the prompt text).
+  
+  Output Format (each prompt on a new line, no extra spaces or lines):
+  
+  1.m
+  [Prompt for the first archetype made for a male character]
+  1.f
+  [Prompt for the first archetype made for a female character (same as the male prompt but adapted for gender-specific traits)]
+  2.m
+  [Prompt for the second archetype made for a male character]
+  2.f
+  [Prompt for the second archetype made for a female character]
+  3.m
+  [Prompt for the third archetype made for a male character]
+  3.f
+  [Prompt for the third archetype made for a female character]
+  
+  Rules:
+  - Do not include extra text, spaces, or line breaks outside the specified format.
+  - Each prompt must be a single line.
+  - Ensure exactly 3 archetypes are provided, with both male and female prompts for each.
+  `,
     },
     {
       role: 'user',
       content: archetypes
         .map((a, idx) =>
           `
-${idx + 1}.
-- Name: ${a.name}
-- Description: ${a.description}`.trim()
+  ${idx + 1}.
+  - Name: ${a.name}
+  - Description: ${a.description}`.trim()
         )
         .join('\n\n'),
     },