@zodic/shared 0.0.373 → 0.0.375

package/app/services/ArchetypeService.ts

@@ -29,7 +29,6 @@ export class ArchetypeService {
     context: Record<string, any> = {}
   ) {
     const logMessage = `[${new Date().toISOString()}] [${level.toUpperCase()}] ${message}`;
-
     console[level](logMessage, context);
   }
 
@@ -49,6 +48,7 @@ export class ArchetypeService {
       .select()
       .from(schema.archetypesData)
       .where(eq(schema.archetypesData.combination, combinationString))
+      .orderBy(schema.archetypesData.archetypeIndex)
       .execute();
 
     if (
@@ -134,7 +134,7 @@ export class ArchetypeService {
         continue;
       }
 
-      for (const gender of ['male', 'female']) {
+      for (const gender of ['male', 'female'] as Gender[]) {
         for (const lang of ['en-us', 'pt-br']) {
           const id = `${combinationString}:${gender}:${index}${
             lang === 'pt-br' ? ':pt' : ''
@@ -153,6 +153,7 @@ export class ArchetypeService {
             await this.log('debug', `Skipping existing archetype ${id}`, {
               name: existing.name,
               essenceLine: existing.essenceLine,
+              archetypeIndex: index,
             });
             continue;
           }
@@ -160,6 +161,9 @@ export class ArchetypeService {
           await this.log('debug', `Saving archetype name for ${id}`, {
             name,
             essenceLine,
+            archetypeIndex: index,
+            gender,
+            language: lang,
           });
 
           await db
@@ -210,6 +214,13 @@ export class ArchetypeService {
       blocksCount: blocks.length,
     });
 
+    if (blocks.length !== 3) {
+      this.log('error', 'Expected exactly 3 archetype blocks', {
+        blocksCount: blocks.length,
+      });
+      throw new Error(`Expected 3 archetype blocks, got ${blocks.length}`);
+    }
+
     const english: Array<{ name: string; essenceLine: string }> = [];
     const portuguese: Array<{
       masc: string;
@@ -217,7 +228,7 @@ export class ArchetypeService {
       essenceLine: string;
     }> = [];
 
-    for (const block of blocks) {
+    blocks.forEach((block, index) => {
       const nameMatch = block.match(/- Name: (.+)/);
       const essenceLineMatch = block.match(/- Essence Line: (.+)/);
       const ptMascMatch = block.match(/- Portuguese \(Masc\): (.+)/);
@@ -240,10 +251,21 @@ export class ArchetypeService {
           fem: ptFemMatch[1].trim(),
           essenceLine: ptEssenceLineMatch[1].trim(),
         });
+        this.log('debug', `Parsed block for archetypeIndex ${index + 1}`, {
+          english: english[index],
+          portuguese: portuguese[index],
+        });
       } else {
-        this.log('warn', 'Malformed archetype name block', { block });
+        this.log(
+          'error',
+          `Malformed archetype name block for index ${index + 1}`,
+          { block }
+        );
+        throw new Error(
+          `Malformed archetype name block for index ${index + 1}`
+        );
       }
-    }
+    });
 
     this.log('info', 'Completed parseArchetypeNameBlocks', {
       english,
@@ -254,7 +276,7 @@ export class ArchetypeService {
 
   async generateDescriptionsAndVirtues(
     combinationString: string,
-    gender: Gender,
+    gender: Gender, // Used for compatibility, but processes both genders
     language: string,
     override: boolean = false
   ): Promise<ParsedDescriptionAndVirtues[]> {
@@ -266,48 +288,70 @@ export class ArchetypeService {
     });
 
     const db = this.context.drizzle();
-    const archetypes = await db
-      .select()
-      .from(schema.archetypesData)
-      .where(
-        and(
-          eq(schema.archetypesData.combination, combinationString),
-          eq(schema.archetypesData.gender, gender),
-          eq(schema.archetypesData.language, language)
+    const allGenders: Gender[] = ['male', 'female'];
+    const archetypesByGender: Record<Gender, any[]> = { male: [], female: [] };
+
+    for (const g of allGenders) {
+      const archetypes = await db
+        .select()
+        .from(schema.archetypesData)
+        .where(
+          and(
+            eq(schema.archetypesData.combination, combinationString),
+            eq(schema.archetypesData.gender, g),
+            eq(schema.archetypesData.language, language)
+          )
         )
-      )
-      .execute();
+        .orderBy(schema.archetypesData.archetypeIndex)
+        .execute();
+      archetypesByGender[g] = archetypes;
+    }
 
-    if (
-      !override &&
-      archetypes.every((a) => a.description && a.virtues !== '[]')
-    ) {
+    const needsGeneration = allGenders.some(
+      (g) =>
+        archetypesByGender[g].length !== 3 ||
+        archetypesByGender[g].some((a) => !a.description || a.virtues === '[]')
+    );
+
+    if (!override && !needsGeneration) {
       await this.log('info', 'Skipping descriptions and virtues generation', {
         reason: 'Descriptions and virtues already exist for all archetypes',
       });
-      return archetypes.map((a) => ({
+      return archetypesByGender['male'].map((a, i) => ({
         descriptionEN: a.description || '',
-        descriptionPTM: a.description || '',
-        descriptionPTF: a.description || '',
+        descriptionPTM: archetypesByGender['male'][i].description || '',
+        descriptionPTF: archetypesByGender['female'][i].description || '',
         virtuesEN: JSON.parse(a.virtues || '[]'),
         virtuesPT: JSON.parse(a.virtues || '[]'),
       }));
     }
 
     await this.log('info', 'Fetched archetypes for description generation', {
-      archetypesCount: archetypes.length,
-      names: archetypes.map((a) => a.name),
+      maleArchetypes: archetypesByGender['male'].map((a) => ({
+        id: a.id,
+        name: a.name,
+        index: a.archetypeIndex,
+      })),
+      femaleArchetypes: archetypesByGender['female'].map((a) => ({
+        id: a.id,
+        name: a.name,
+        index: a.archetypeIndex,
+      })),
     });
 
     const descVirtueMessages = this.context
       .buildLLMMessages()
       .generateCosmicMirrorDescriptionAndVirtues({
         combination: combinationString,
-        names: [archetypes[0].name, archetypes[1].name, archetypes[2].name],
-        essenceLines: [
-          archetypes[0].essenceLine,
-          archetypes[1].essenceLine,
-          archetypes[2].essenceLine,
+        names: archetypesByGender['male'].map((a) => a.name) as [
+          string,
+          string,
+          string
+        ],
+        essenceLines: archetypesByGender['male'].map((a) => a.essenceLine) as [
+          string,
+          string,
+          string
         ],
       });
 
@@ -317,7 +361,7 @@ export class ArchetypeService {
     const descVirtueResponse = await this.context
       .api()
       .callTogether.single(descVirtueMessages, {
-        options: { temperature: 0.5 },
+        options: { temperature: 0.3 },
       });
     if (!descVirtueResponse) {
       await this.log('error', 'No response for descriptions and virtues', {
@@ -339,106 +383,78 @@ export class ArchetypeService {
 
     for (let i = 0; i < 3; i++) {
       const index = (i + 1).toString();
-      const enId = `${combinationString}:${gender}:${index}`;
-      const ptId = `${combinationString}:${gender}:${index}:pt`;
-
-      // Update English entry (en-us)
-      if (language === 'en-us') {
-        const enExisting = archetypes.find((a) => a.id === enId);
-        if (
-          !override &&
-          enExisting?.description &&
-          enExisting.virtues !== '[]'
-        ) {
+      for (const g of allGenders) {
+        const archetype = archetypesByGender[g][i];
+        if (!archetype || archetype.archetypeIndex !== index) {
           await this.log(
-            'debug',
-            `Skipping existing description and virtues for ${enId}`,
+            'error',
+            `Archetype index mismatch for gender ${g} at position ${i + 1}`,
             {
-              description: enExisting.description,
-              virtues: enExisting.virtues,
+              expectedIndex: index,
+              actualIndex: archetype?.archetypeIndex,
+              archetypeId: archetype?.id,
             }
           );
-        } else {
-          await this.log(
-            'debug',
-            `Updating description and virtues for ${enId}`,
-            {
-              description: parsedDescVirtues[i].descriptionEN,
-              virtues: parsedDescVirtues[i].virtuesEN,
-            }
+          throw new Error(
+            `Archetype index mismatch for gender ${g}: expected ${index}, got ${archetype?.archetypeIndex}`
           );
-          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 ${enId}`);
         }
-      }
 
-      // Update Portuguese entries (pt-br)
-      if (language === 'pt-br') {
-        for (const ptGender of ['male', 'female']) {
-          const ptExisting = archetypes.find(
-            (a) => a.id === ptId && a.gender === ptGender
-          );
-          if (
-            !override &&
-            ptExisting?.description &&
-            ptExisting.virtues !== '[]'
-          ) {
-            await this.log(
-              'debug',
-              `Skipping existing description and virtues for ${ptId} (${ptGender})`,
-              {
-                description: ptExisting.description,
-                virtues: ptExisting.virtues,
-              }
-            );
-            continue;
-          }
-
-          const description =
-            ptGender === 'male'
-              ? parsedDescVirtues[i].descriptionPTM
-              : parsedDescVirtues[i].descriptionPTF;
+        const id = `${combinationString}:${g}:${index}${
+          language === 'pt-br' ? ':pt' : ''
+        }`;
+        if (!override && archetype.description && archetype.virtues !== '[]') {
           await this.log(
             'debug',
-            `Updating description and virtues for ${ptId} (${ptGender})`,
+            `Skipping existing description and virtues for ${id}`,
             {
-              description,
-              virtues: parsedDescVirtues[i].virtuesPT,
+              description: archetype.description,
+              virtues: archetype.virtues,
+              archetypeIndex: index,
+              gender: g,
+              language,
             }
           );
-          await db
-            .update(schema.archetypesData)
-            .set({
-              description,
-              virtues: JSON.stringify(parsedDescVirtues[i].virtuesPT),
-              updatedAt: new Date().getTime(),
-            })
-            .where(
-              and(
-                eq(schema.archetypesData.id, ptId),
-                eq(schema.archetypesData.language, 'pt-br'),
-                eq(schema.archetypesData.gender, ptGender)
-              )
-            )
-            .execute();
-          await this.log(
-            'info',
-            `Updated description and virtues for ${ptId} (${ptGender})`
-          );
+          continue;
         }
+
+        const description =
+          language === 'en-us'
+            ? parsedDescVirtues[i].descriptionEN
+            : g === 'male'
+            ? parsedDescVirtues[i].descriptionPTM
+            : parsedDescVirtues[i].descriptionPTF;
+        const virtues =
+          language === 'en-us'
+            ? parsedDescVirtues[i].virtuesEN
+            : parsedDescVirtues[i].virtuesPT;
+
+        await this.log('debug', `Updating description and virtues for ${id}`, {
+          description,
+          virtues,
+          archetypeIndex: index,
+          gender: g,
+          language,
+        });
+
+        await db
+          .update(schema.archetypesData)
+          .set({
+            description,
+            virtues: JSON.stringify(virtues),
+            updatedAt: new Date().getTime(),
+          })
+          .where(
+            and(
+              eq(schema.archetypesData.id, id),
+              eq(schema.archetypesData.language, language),
+              eq(schema.archetypesData.gender, g),
+              eq(schema.archetypesData.archetypeIndex, index)
+            )
+          )
+          .execute();
+
+        await this.log('info', `Updated description and virtues for ${id}`);
       }
     }
 
@@ -488,6 +504,22 @@ export class ArchetypeService {
         lines,
       });
 
+      if (lines[0] !== `${entryIndex + 1}.`) {
+        this.log(
+          'error',
+          `Invalid archetype index in entry ${entryIndex + 1}`,
+          {
+            expected: `${entryIndex + 1}.`,
+            found: lines[0],
+          }
+        );
+        throw new Error(
+          `Invalid archetype index in entry ${entryIndex + 1}: expected ${
+            entryIndex + 1
+          }, got ${lines[0]}`
+        );
+      }
+
       let descriptionEN = '';
       let descriptionPTM = '';
       let descriptionPTF = '';
@@ -495,18 +527,10 @@ export class ArchetypeService {
       let virtuesPT: string[] = [];
       let currentField = '';
 
-      for (let i = 0; i < lines.length; i++) {
+      for (let i = 1; i < lines.length; i++) {
         let line = lines[i];
         line = line.replace(/\*\*(.*?)\*\*/g, '$1');
 
-        if (
-          line.startsWith('1.') ||
-          line.startsWith('2.') ||
-          line.startsWith('3.')
-        ) {
-          continue;
-        }
-
         if (line.startsWith('• Description EN:')) {
           currentField = 'descriptionEN';
           descriptionEN = line.split('• Description EN:')[1]?.trim() || '';
@@ -612,7 +636,7 @@ export class ArchetypeService {
         virtuesPT.length !== 3
       ) {
         this.log(
-          'warn',
+          'error',
           `Malformed description and virtues response for entry ${
             entryIndex + 1
           }`,
@@ -632,13 +656,19 @@ export class ArchetypeService {
         );
       }
 
-      return {
+      const parsed = {
         descriptionEN,
         descriptionPTM,
         descriptionPTF,
         virtuesEN,
         virtuesPT,
       };
+      this.log(
+        'debug',
+        `Parsed description and virtues for archetypeIndex ${entryIndex + 1}`,
+        { parsed }
+      );
+      return parsed;
     });
 
     this.log('info', 'Completed parseDescriptionAndVirtuesResponse', {
@@ -649,7 +679,7 @@ export class ArchetypeService {
 
   async generateContent(
     combinationString: string,
-    gender: Gender,
+    gender: Gender, // Used for compatibility, but processes both genders
     language: string,
     descriptions: Array<{ descriptionEN: string }>,
     override: boolean = false
@@ -662,19 +692,32 @@ export class ArchetypeService {
     });
 
     const db = this.context.drizzle();
-    const archetypes = await db
-      .select()
-      .from(schema.archetypesData)
-      .where(
-        and(
-          eq(schema.archetypesData.combination, combinationString),
-          eq(schema.archetypesData.gender, gender),
-          eq(schema.archetypesData.language, language)
+    const allGenders: Gender[] = ['male', 'female'];
+    const archetypesByGender: Record<Gender, any[]> = { male: [], female: [] };
+
+    for (const g of allGenders) {
+      const archetypes = await db
+        .select()
+        .from(schema.archetypesData)
+        .where(
+          and(
+            eq(schema.archetypesData.combination, combinationString),
+            eq(schema.archetypesData.gender, g),
+            eq(schema.archetypesData.language, language)
+          )
         )
-      )
-      .execute();
+        .orderBy(schema.archetypesData.archetypeIndex)
+        .execute();
+      archetypesByGender[g] = archetypes;
+    }
 
-    if (!override && archetypes.every((a) => a.content !== '[]')) {
+    const needsGeneration = allGenders.some(
+      (g) =>
+        archetypesByGender[g].length !== 3 ||
+        archetypesByGender[g].some((a) => a.content === '[]')
+    );
+
+    if (!override && !needsGeneration) {
       await this.log('info', 'Skipping content generation', {
         reason: 'Content already exists for all archetypes',
       });
@@ -682,122 +725,159 @@ export class ArchetypeService {
     }
 
     await this.log('info', 'Fetched archetypes for content generation', {
-      archetypesCount: archetypes.length,
-      names: archetypes.map((a) => a.name),
+      maleArchetypes: archetypesByGender['male'].map((a) => ({
+        id: a.id,
+        name: a.name,
+        index: a.archetypeIndex,
+      })),
+      femaleArchetypes: archetypesByGender['female'].map((a) => ({
+        id: a.id,
+        name: a.name,
+        index: a.archetypeIndex,
+      })),
     });
 
     const contentResults = [];
     for (let i = 0; i < 3; i++) {
       const index = (i + 1).toString();
-      const id = `${combinationString}:${gender}:${index}${
-        language === 'pt-br' ? ':pt' : ''
-      }`;
-      const existing = archetypes.find((a) => a.id === id);
-
-      if (!override && existing && existing?.content !== '[]') {
-        await this.log('debug', `Skipping existing content for ${id}`, {
-          content: existing.content,
-        });
-        contentResults.push({}); // Placeholder
-        continue;
-      }
+      for (const g of allGenders) {
+        const archetype = archetypesByGender[g][i];
+        if (!archetype || archetype.archetypeIndex !== index) {
+          await this.log(
+            'error',
+            `Archetype index mismatch for gender ${g} at position ${i + 1}`,
+            {
+              expectedIndex: index,
+              actualIndex: archetype?.archetypeIndex,
+              archetypeId: archetype?.id,
+            }
+          );
+          throw new Error(
+            `Archetype index mismatch for gender ${g}: expected ${index}, got ${archetype?.archetypeIndex}`
+          );
+        }
 
-      await this.log('debug', `Generating content for archetype ${i + 1}`, {
-        name: archetypes[i].name,
-      });
-      const contentMessages = this.context
-        .buildLLMMessages()
-        .generateCosmicMirrorArchetypeContent({
-          combination: combinationString,
-          name: archetypes[i].name,
-          description: descriptions[i].descriptionEN,
-        });
+        const id = `${combinationString}:${g}:${index}${
+          language === 'pt-br' ? ':pt' : ''
+        }`;
+        if (!override && archetype.content !== '[]') {
+          await this.log('debug', `Skipping existing content for ${id}`, {
+            content: archetype.content,
+            archetypeIndex: index,
+            gender: g,
+            language,
+          });
+          if (g === 'male') contentResults.push({}); // Placeholder for male only
+          continue;
+        }
 
-      await this.log('debug', `Calling API for content of archetype ${i + 1}`, {
-        messages: contentMessages,
-      });
-      const contentResponse = await this.context
-        .api()
-        .callTogether.single(contentMessages, {});
-      if (!contentResponse) {
         await this.log(
-          'error',
-          `No response for content of archetype ${i + 1}`,
+          'debug',
+          `Generating content for archetype ${index} (${g})`,
+          { name: archetype.name }
+        );
+        const contentMessages = this.context
+          .buildLLMMessages()
+          .generateCosmicMirrorArchetypeContent({
+            combination: combinationString,
+            name: archetype.name,
+            description: descriptions[i].descriptionEN,
+          });
+
+        await this.log(
+          'debug',
+          `Calling API for content of archetype ${index} (${g})`,
+          { messages: contentMessages }
+        );
+        const contentResponse = await this.context
+          .api()
+          .callTogether.single(contentMessages, {});
+        if (!contentResponse) {
+          await this.log(
+            'error',
+            `No response for content of archetype ${index} (${g})`,
+            {
+              combinationString,
+              archetype: archetype.name,
+            }
+          );
+          throw new Error(
+            `Failed to generate content for archetype ${index} (${g}) of: ${combinationString}`
+          );
+        }
+        await this.log(
+          'info',
+          `Received content response for archetype ${index} (${g})`,
           {
-            combinationString,
-            archetype: archetypes[i].name,
+            responseLength: contentResponse.length,
+            rawResponse: contentResponse, // Log raw response for debugging
           }
         );
-        throw new Error(
-          `Failed to generate content for archetype ${
-            i + 1
-          } of: ${combinationString}`
+
+        await this.log(
+          'debug',
+          `Parsing content response for archetype ${index} (${g})`
         );
-      }
-      await this.log(
-        'info',
-        `Received content response for archetype ${i + 1}`,
-        {
-          responseLength: contentResponse.length,
-        }
-      );
+        const parsedContent = this.parseContentResponse(contentResponse);
+        if (g === 'male') contentResults.push(parsedContent);
+        await this.log('info', `Parsed content for archetype ${index} (${g})`, {
+          parsedContent,
+        });
 
-      await this.log(
-        'debug',
-        `Parsing content response for archetype ${i + 1}`
-      );
-      const parsedContent = this.parseContentResponse(contentResponse);
-      contentResults.push(parsedContent);
-      await this.log('info', `Parsed content for archetype ${i + 1}`, {
-        parsedContent,
-      });
+        const contentLangIndex =
+          language === 'en-us' ? 0 : g === 'male' ? 1 : 2;
+        const content = [
+          {
+            section: 'voiceOfTheSoul',
+            text: parsedContent[contentLangIndex].voiceOfTheSoul,
+          },
+          {
+            section: 'giftsYouBear',
+            text: parsedContent[contentLangIndex].giftsYouBear,
+          },
+          {
+            section: 'shadowsYouFace',
+            text: parsedContent[contentLangIndex].shadowsYouFace,
+          },
+          {
+            section: 'rhythmOfYourDays',
+            text: parsedContent[contentLangIndex].rhythmOfYourDays,
+          },
+          {
+            section: 'tiesThatBind',
+            text: parsedContent[contentLangIndex].tiesThatBind,
+          },
+          {
+            section: 'lightWithin',
+            text: parsedContent[contentLangIndex].lightWithin,
+          },
+        ];
+
+        await this.log('debug', `Updating content for ${id}`, {
+          content,
+          archetypeIndex: index,
+          gender: g,
+          language,
+        });
 
-      const contentLangIndex =
-        language === 'en-us' ? 0 : gender === 'male' ? 1 : 2;
-      const content = [
-        {
-          section: 'voiceOfTheSoul',
-          text: parsedContent[contentLangIndex].voiceOfTheSoul,
-        },
-        {
-          section: 'giftsYouBear',
-          text: parsedContent[contentLangIndex].giftsYouBear,
-        },
-        {
-          section: 'shadowsYouFace',
-          text: parsedContent[contentLangIndex].shadowsYouFace,
-        },
-        {
-          section: 'rhythmOfYourDays',
-          text: parsedContent[contentLangIndex].rhythmOfYourDays,
-        },
-        {
-          section: 'tiesThatBind',
-          text: parsedContent[contentLangIndex].tiesThatBind,
-        },
-        {
-          section: 'lightWithin',
-          text: parsedContent[contentLangIndex].lightWithin,
-        },
-      ];
-
-      await this.log('debug', `Updating content for ${id}`, { content });
-
-      await db
-        .update(schema.archetypesData)
-        .set({
-          content: JSON.stringify(content),
-          updatedAt: new Date().getTime(),
-        })
-        .where(
-          and(
-            eq(schema.archetypesData.id, id),
-            eq(schema.archetypesData.language, language)
+        await db
+          .update(schema.archetypesData)
+          .set({
+            content: JSON.stringify(content),
+            updatedAt: new Date().getTime(),
+          })
+          .where(
+            and(
+              eq(schema.archetypesData.id, id),
+              eq(schema.archetypesData.language, language),
+              eq(schema.archetypesData.gender, g),
+              eq(schema.archetypesData.archetypeIndex, index)
+            )
           )
-        )
-        .execute();
+          .execute();
 
-      await this.log('info', `Updated content for ${id}`);
+        await this.log('info', `Updated content for ${id}`);
+      }
     }
 
     await this.log('info', 'Completed generateContent', {
@@ -821,6 +901,14 @@ export class ArchetypeService {
       sectionsCount: sections.length,
     });
 
+    if (sections.length !== 3) {
+      this.log('error', 'Expected exactly 3 content sections', {
+        sectionsCount: sections.length,
+        response,
+      });
+      throw new Error(`Expected 3 content sections, got ${sections.length}`);
+    }
+
     const result = sections.map((section, sectionIndex) => {
       this.log('debug', `Processing section ${sectionIndex + 1}`, { section });
 
@@ -830,24 +918,28 @@ export class ArchetypeService {
         lines,
       });
 
+      const expectedHeader =
+        sectionIndex === 0 ? 'EN:' : sectionIndex === 1 ? 'PT-M:' : 'PT-F:';
+      const actualHeader = lines[0].trim(); // Trim the header to remove trailing spaces
+      if (actualHeader !== expectedHeader) {
+        this.log(
+          'error',
+          `Invalid language header in section ${sectionIndex + 1}`,
+          {
+            expected: expectedHeader,
+            found: actualHeader,
+          }
+        );
+        throw new Error(
+          `Invalid language header in section ${sectionIndex + 1}`
+        );
+      }
+
       const content: Record<string, string> = {};
       let currentSection = '';
       let currentText: string[] = [];
 
-      for (const line of lines) {
-        if (
-          line.startsWith('EN:') ||
-          line.startsWith('PT-M:') ||
-          line.startsWith('PT-F:')
-        ) {
-          this.log(
-            'debug',
-            `Skipping language header in section ${sectionIndex + 1}`,
-            { line }
-          );
-          continue;
-        }
-
+      for (const line of lines.slice(1)) {
         if (line.startsWith('#')) {
           if (currentSection && currentText.length > 0) {
             const key = currentSection
@@ -913,15 +1005,21 @@ export class ArchetypeService {
 
       if (Object.values(parsedContent).some((value) => !value)) {
         this.log(
-          'warn',
+          'error',
           `Malformed content response for section ${sectionIndex + 1}`,
           {
             parsedContent,
             response: section,
           }
         );
+        throw new Error(
+          `Malformed content response for section ${sectionIndex + 1}`
+        );
       }
 
+      this.log('debug', `Parsed content for section ${sectionIndex + 1}`, {
+        parsedContent,
+      });
       return parsedContent;
     });
 
@@ -931,7 +1029,7 @@ export class ArchetypeService {
 
   async generateLeonardoPrompts(
     combinationString: string,
-    gender: Gender,
+    gender: Gender, // Used for compatibility, but processes both genders
     language: string,
     descriptions: Array<{ descriptionEN: string }>,
     override: boolean = false
@@ -944,9 +1042,8 @@ export class ArchetypeService {
     });
 
     const db = this.context.drizzle();
-    type Binary = 'male' | 'female';
-    const allGenders: Binary[] = ['male', 'female'];
-    const archetypesByGender: Record<Binary, any[]> = { male: [], female: [] };
+    const allGenders: Gender[] = ['male', 'female'];
+    const archetypesByGender: Record<Gender, any[]> = { male: [], female: [] };
 
     for (const g of allGenders) {
       const archetypes = await db
@@ -959,30 +1056,18 @@ export class ArchetypeService {
             eq(schema.archetypesData.language, language)
           )
         )
+        .orderBy(schema.archetypesData.archetypeIndex)
         .execute();
       archetypesByGender[g] = archetypes;
     }
 
-    for (const g of allGenders) {
-      if (archetypesByGender[g].length !== 3) {
-        await this.log(
-          'error',
-          `Expected 3 archetypes for gender ${g}, but found ${archetypesByGender[g].length}`,
-          {
-            combinationString,
-            gender: g,
-          }
-        );
-        throw new Error(
-          `Expected 3 archetypes for gender ${g}, but found ${archetypesByGender[g].length}`
-        );
-      }
-    }
+    const needsGeneration = allGenders.some(
+      (g) =>
+        archetypesByGender[g].length !== 3 ||
+        archetypesByGender[g].some((a) => !a.leonardoPrompt)
+    );
 
-    if (
-      !override &&
-      archetypesByGender[gender as Binary].every((a) => a.leonardoPrompt)
-    ) {
+    if (!override && !needsGeneration) {
       await this.log('info', 'Skipping Leonardo prompts generation', {
         reason: 'Leonardo prompts already exist for all archetypes',
       });
@@ -990,12 +1075,16 @@ export class ArchetypeService {
     }
 
     await this.log('info', 'Fetched archetypes for Leonardo prompts', {
-      maleArchetypesCount: archetypesByGender['male'].length,
-      femaleArchetypesCount: archetypesByGender['female'].length,
-      names: {
-        male: archetypesByGender['male'].map((a) => a.name),
-        female: archetypesByGender['female'].map((a) => a.name),
-      },
+      maleArchetypes: archetypesByGender['male'].map((a) => ({
+        id: a.id,
+        name: a.name,
+        index: a.archetypeIndex,
+      })),
+      femaleArchetypes: archetypesByGender['female'].map((a) => ({
+        id: a.id,
+        name: a.name,
+        index: a.archetypeIndex,
+      })),
     });
 
     const promptMessages = this.context
@@ -1030,46 +1119,71 @@ export class ArchetypeService {
 
     for (const g of allGenders) {
       for (let i = 0; i < 3; i++) {
+        const archetype = archetypesByGender[g][i];
         const index = (i + 1).toString();
+        if (!archetype || archetype.archetypeIndex !== index) {
+          await this.log(
+            'error',
+            `Archetype index mismatch for gender ${g} at position ${i + 1}`,
+            {
+              expectedIndex: index,
+              actualIndex: archetype?.archetypeIndex,
+              archetypeId: archetype?.id,
+            }
+          );
+          throw new Error(
+            `Archetype index mismatch for gender ${g}: expected ${index}, got ${archetype?.archetypeIndex}`
+          );
+        }
+
         const leonardoPrompt =
           g === 'male'
             ? parsedPrompts[i].malePrompt
             : parsedPrompts[i].femalePrompt;
-
         const id = `${combinationString}:${g}:${index}${
           language === 'pt-br' ? ':pt' : ''
         }`;
-        const existing = archetypesByGender[g].find((a) => a.id === id);
-        if (!override && existing?.leonardoPrompt) {
+
+        if (!override && archetype.leonardoPrompt) {
           await this.log(
             'debug',
             `Skipping existing Leonardo prompt for ${id}`,
             {
-              leonardoPrompt: existing.leonardoPrompt,
+              leonardoPrompt: archetype.leonardoPrompt,
+              archetypeIndex: index,
+              gender: g,
+              language,
             }
           );
-        } else {
-          await this.log('debug', `Updating Leonardo prompt for ${id}`, {
+          continue;
+        }
+
+        await this.log('debug', `Updating Leonardo prompt for ${id}`, {
+          leonardoPrompt,
+          archetypeIndex: index,
+          gender: g,
+          language,
+        });
+
+        const updateResult = await db
+          .update(schema.archetypesData)
+          .set({
             leonardoPrompt,
-          });
-          const updateResult = await db
-            .update(schema.archetypesData)
-            .set({
-              leonardoPrompt,
-              updatedAt: new Date().getTime(),
-            })
-            .where(
-              and(
-                eq(schema.archetypesData.id, id),
-                eq(schema.archetypesData.language, language),
-                eq(schema.archetypesData.gender, g)
-              )
+            updatedAt: new Date().getTime(),
+          })
+          .where(
+            and(
+              eq(schema.archetypesData.id, id),
+              eq(schema.archetypesData.language, language),
+              eq(schema.archetypesData.gender, g),
+              eq(schema.archetypesData.archetypeIndex, index)
             )
-            .execute();
-          await this.log('info', `Updated Leonardo prompt for ${id}`, {
-            rowsAffected: updateResult.rowsAffected,
-          });
-        }
+          )
+          .execute();
+
+        await this.log('info', `Updated Leonardo prompt for ${id}`, {
+          rowsAffected: updateResult.rowsAffected,
+        });
       }
     }
 
@@ -1092,38 +1206,45 @@ export class ArchetypeService {
       lines,
     });
 
-    const prompts: LeonardoPrompt[] = [];
-    let currentArchetype = 0;
+    if (lines.length !== 12) {
+      this.log('error', 'Expected exactly 12 lines for 3 archetype prompts', {
+        linesCount: lines.length,
+        response,
+      });
+      throw new Error(
+        `Expected 12 lines for 3 archetype prompts, got ${lines.length}`
+      );
+    }
 
+    const prompts: LeonardoPrompt[] = [];
     for (let i = 0; i < lines.length; i += 4) {
+      const archetypeIndex = i / 4 + 1;
       const maleLabel = lines[i];
       const malePromptLine = lines[i + 1];
       const femaleLabel = lines[i + 2];
       const femalePromptLine = lines[i + 3];
 
-      currentArchetype++;
-      const expectedMaleLabel = `${currentArchetype}.m`;
-      const expectedFemaleLabel = `${currentArchetype}.f`;
+      const expectedMaleLabel = `${archetypeIndex}.m`;
+      const expectedFemaleLabel = `${archetypeIndex}.f`;
 
       if (
         !maleLabel?.startsWith(expectedMaleLabel) ||
         !femaleLabel?.startsWith(expectedFemaleLabel)
       ) {
         this.log(
-          'warn',
-          `Malformed Leonardo prompt format for archetype ${currentArchetype}`,
+          'error',
+          `Malformed Leonardo prompt format for archetype ${archetypeIndex}`,
           {
             maleLabel,
             malePromptLine,
             femaleLabel,
             femalePromptLine,
-            lines,
+            expectedMaleLabel,
+            expectedFemaleLabel,
           }
         );
         throw new Error(
-          `Expected ${expectedMaleLabel} and ${expectedFemaleLabel} at lines ${i} and ${
-            i + 2
-          }`
+          `Malformed prompt format for archetype ${archetypeIndex}`
         );
       }
 
@@ -1132,42 +1253,30 @@ export class ArchetypeService {
 
       if (!malePrompt || !femalePrompt) {
         this.log(
-          'warn',
-          `Empty Leonardo prompt for archetype ${currentArchetype}`,
+          'error',
+          `Empty Leonardo prompt for archetype ${archetypeIndex}`,
           {
             malePrompt,
             femalePrompt,
-            malePromptLine,
-            femalePromptLine,
           }
         );
-        throw new Error(`Empty prompt for archetype ${currentArchetype}`);
+        throw new Error(`Empty prompt for archetype ${archetypeIndex}`);
       }
 
       prompts.push({ malePrompt, femalePrompt });
-      this.log('debug', `Parsed prompts for archetype ${currentArchetype}`, {
+      this.log('debug', `Parsed prompts for archetypeIndex ${archetypeIndex}`, {
         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;
   }
 
   async fetchArchetypesFromDB(
     combinationString: string,
-    gender: Gender,
+    gender: Gender | null, // null to fetch both genders
     language: string
   ) {
     await this.log('debug', 'Executing fetchArchetypesFromDB', {
@@ -1176,20 +1285,23 @@ export class ArchetypeService {
       language,
     });
     const db = this.context.drizzle();
+    const conditions = [
+      eq(schema.archetypesData.combination, combinationString),
+      eq(schema.archetypesData.language, language),
+    ];
+    if (gender) {
+      conditions.push(eq(schema.archetypesData.gender, gender));
+    }
     const result = await db
       .select()
       .from(schema.archetypesData)
-      .where(
-        and(
-          eq(schema.archetypesData.combination, combinationString),
-          eq(schema.archetypesData.gender, gender),
-          eq(schema.archetypesData.language, language)
-        )
-      )
+      .where(and(...conditions))
+      .orderBy(schema.archetypesData.archetypeIndex)
       .execute();
     await this.log('debug', 'fetchArchetypesFromDB result', {
       resultCount: result.length,
-      result,
+      indexes: result.map((r) => r.archetypeIndex),
+      genders: result.map((r) => r.gender),
     });
     return result;
   }