@zodic/shared 0.0.319 → 0.0.320

package/app/services/ArchetypeService.ts

@@ -248,13 +248,13 @@ export class ArchetypeService {
     combinationString: string,
     gender: Gender,
     language: string
-  ) {
+  ): Promise<ParsedDescriptionAndVirtues[]> {
     await this.log('info', 'Starting generateDescriptionsAndVirtues', {
       combinationString,
       gender,
       language,
     });
-  
+
     const db = this.context.drizzle();
     const archetypes = await db
       .select()
@@ -267,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({
@@ -284,13 +284,17 @@ export class ArchetypeService {
           archetypes[2].essenceLine,
         ],
       });
-  
+
     await this.log('debug', 'Calling API for descriptions and virtues', {
       messages: descVirtueMessages,
     });
     const descVirtueResponse = await this.context
       .api()
-      .callTogether.single(descVirtueMessages, {});
+      .callTogether.single(descVirtueMessages, {
+        options: {
+          temperature: 0.5,
+        },
+      });
     if (!descVirtueResponse) {
       await this.log('error', 'No response for descriptions and virtues', {
         combinationString,
@@ -302,15 +306,16 @@ 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();
-      
+
       // Update English entry (en-us)
       const enId = `${combinationString}:${gender}:${index}`;
       await this.log('debug', `Updating description and virtues for ${enId}`, {
@@ -332,13 +337,17 @@ export class ArchetypeService {
         )
         .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 this.log(
+        'debug',
+        `Updating description and virtues for ${ptIdMale} (male)`,
+        {
+          description: parsedDescVirtues[i].descriptionPTM,
+          virtues: parsedDescVirtues[i].virtuesPT,
+        }
+      );
       await db
         .update(schema.archetypesData)
         .set({
@@ -354,13 +363,20 @@ export class ArchetypeService {
           )
         )
         .execute();
-      await this.log('info', `Updated description and virtues for ${ptIdMale} (male)`);
-  
+      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 this.log(
+        'debug',
+        `Updating description and virtues for ${ptIdFemale} (female)`,
+        {
+          description: parsedDescVirtues[i].descriptionPTF,
+          virtues: parsedDescVirtues[i].virtuesPT,
+        }
+      );
       await db
         .update(schema.archetypesData)
         .set({
@@ -376,9 +392,12 @@ export class ArchetypeService {
           )
         )
         .execute();
-      await this.log('info', `Updated description and virtues for ${ptIdFemale} (female)`);
+      await this.log(
+        'info',
+        `Updated description and virtues for ${ptIdFemale} (female)`
+      );
     }
-  
+
     await this.log('info', 'Completed generateDescriptionsAndVirtues', {
       combinationString,
       gender,
@@ -387,67 +406,89 @@ export class ArchetypeService {
     return parsedDescVirtues;
   }
 
-
-  private parseDescriptionAndVirtuesResponse(response: string): ParsedDescriptionAndVirtues[] {
+  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}`);
+      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').map((line) => line.trim()).filter((line) => line);
+
+      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 virtuesEN: string[] = [];
       let virtuesPT: string[] = [];
       let currentField = '';
-  
+
       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.')) {
+
+        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
@@ -456,7 +497,9 @@ export class ArchetypeService {
             .map((v) => v.trim())
             .filter((v) => v)
             .slice(0, 3);
-          this.log('debug', `Extracted virtuesEN for entry ${entryIndex + 1}`, { virtuesEN });
+          this.log('debug', `Extracted virtuesEN for entry ${entryIndex + 1}`, {
+            virtuesEN,
+          });
         } else if (line.startsWith('• Virtues PT:')) {
           currentField = 'virtuesPT';
           virtuesPT = line
@@ -465,7 +508,9 @@ export class ArchetypeService {
             .map((v) => v.trim())
             .filter((v) => v)
             .slice(0, 3);
-          this.log('debug', `Extracted virtuesPT for entry ${entryIndex + 1}`, { virtuesPT });
+          this.log('debug', `Extracted virtuesPT for entry ${entryIndex + 1}`, {
+            virtuesPT,
+          });
         } else if (line.startsWith('• Virtues:')) {
           // Fallback for older response format: use English virtues and attempt to translate
           currentField = 'virtuesEN';
@@ -475,8 +520,12 @@ export class ArchetypeService {
             .map((v) => v.trim())
             .filter((v) => v)
             .slice(0, 3);
-          this.log('debug', `Extracted virtuesEN (fallback) for entry ${entryIndex + 1}`, { virtuesEN });
-  
+          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',
@@ -485,38 +534,78 @@ export class ArchetypeService {
             // 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 });
+          this.log(
+            'debug',
+            `Generated virtuesPT (fallback) for entry ${entryIndex + 1}`,
+            { virtuesPT }
+          );
         } else if (currentField && !currentField.startsWith('virtues')) {
           if (currentField === 'descriptionEN') {
             descriptionEN += ' ' + line;
-            this.log('debug', `Appended to descriptionEN for entry ${entryIndex + 1}`, { descriptionEN });
+            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 });
+            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 });
+            this.log(
+              'debug',
+              `Appended to descriptionPTF for entry ${entryIndex + 1}`,
+              { descriptionPTF }
+            );
           }
         }
       }
-  
+
       // 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`);
+      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, virtuesEN, virtuesPT };
+
+      return {
+        descriptionEN,
+        descriptionPTM,
+        descriptionPTF,
+        virtuesEN,
+        virtuesPT,
+      };
+    });
+
+    this.log('info', 'Completed parseDescriptionAndVirtuesResponse', {
+      result,
     });
-  
-    this.log('info', 'Completed parseDescriptionAndVirtuesResponse', { result });
     return result;
   }
 
@@ -776,8 +865,8 @@ export class ArchetypeService {
 
   async generateLeonardoPrompts(
     combinationString: string,
-    gender: Gender,
-    language: string,
+    gender: Gender, // User's gender, used for filtering results in ArchetypeWorkflow.execute
+    language: string, // User's language, used for filtering results in ArchetypeWorkflow.execute
     descriptions: Array<{ descriptionEN: string }>
   ) {
     await this.log('info', 'Starting generateLeonardoPrompts', {
@@ -787,27 +876,63 @@ 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, 'en-us')
+
+    type Binary = 'male' | 'female'
+
+    // Fetch archetypes for male and female with language = 'en-us'
+    const allGenders: Binary[] = ['male', 'female'];
+    const archetypesByGender: Record<Binary, 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, 'en-us')
+          )
         )
-      )
-      .execute();
+        .execute();
+      archetypesByGender[g] = archetypes;
+    }
+
+    // Validate that we have archetypes for all genders (3 archetypes per gender)
+    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}`
+        );
+      }
+    }
 
     await this.log('info', 'Fetched archetypes for Leonardo prompts', {
-      archetypesCount: archetypes.length,
-      names: archetypes.map((a) => a.name),
+      maleArchetypesCount: archetypesByGender['male'].length,
+      femaleArchetypesCount: archetypesByGender['female'].length,
+      names: {
+        male: archetypesByGender['male'].map((a) => a.name),
+        female: archetypesByGender['female'].map((a) => a.name),
+      },
     });
 
+    // Since descriptions are provided as an input (from generateDescriptionsAndVirtues),
+    // we can use the same descriptions for all genders, as they are gender-neutral (en-us)
     const promptMessages = this.context
       .buildLLMMessages()
       .generateCosmicMirrorArchetypeLeonardoPrompts(
-        archetypes.map((arc, idx) => ({
+        archetypesByGender['male'].map((arc, idx) => ({
           name: arc.name,
           description: descriptions[idx].descriptionEN,
         }))
@@ -834,22 +959,26 @@ export class ArchetypeService {
     const parsedPrompts = this.parseLeonardoPromptResponse(promptResponse);
     await this.log('info', 'Parsed Leonardo prompts', { parsedPrompts });
 
-    for (let i = 0; i < 3; i++) {
-      const index = (i + 1).toString();
-      const leonardoPrompt =
-        gender === 'male'
-          ? parsedPrompts[i].malePrompt
-          : parsedPrompts[i].femalePrompt;
-
-      for (const lang of ['en-us', 'pt-br']) {
-        const id = `${combinationString}:${gender}:${index}${
-          lang === 'pt-br' ? ':pt' : ''
-        }`;
-        await this.log('debug', `Updating Leonardo prompt for ${id}`, {
-          leonardoPrompt,
-        });
+    // Update archetypes for all genders
+    for (const g of allGenders) {
+      for (let i = 0; i < 3; i++) {
+        const index = (i + 1).toString();
+        const leonardoPrompt =
+          g === 'male'
+            ? parsedPrompts[i].malePrompt
+            : parsedPrompts[i].femalePrompt;
+
+        // Update English entry (en-us)
+        const enId = `${combinationString}:${g}:${index}`;
+        await this.log(
+          'debug',
+          `Updating Leonardo prompt for ${enId} (en-us)`,
+          {
+            leonardoPrompt,
+          }
+        );
 
-        await db
+        const enUpdateResult = await db
           .update(schema.archetypesData)
           .set({
             leonardoPrompt,
@@ -857,13 +986,88 @@ export class ArchetypeService {
           })
           .where(
             and(
-              eq(schema.archetypesData.id, id),
-              eq(schema.archetypesData.language, lang)
+              eq(schema.archetypesData.id, enId),
+              eq(schema.archetypesData.language, 'en-us'),
+              eq(schema.archetypesData.gender, g)
             )
           )
           .execute();
 
-        await this.log('info', `Updated Leonardo prompt for ${id}`);
+        await this.log('info', `Updated Leonardo prompt for ${enId} (en-us)`, {
+          rowsAffected: enUpdateResult.rowsAffected,
+        });
+
+        if (enUpdateResult.rowsAffected === 0) {
+          await this.log(
+            'error',
+            `Failed to update Leonardo prompt for ${enId} (en-us)`,
+            {
+              enId,
+              language: 'en-us',
+              gender: g,
+            }
+          );
+          throw new Error(
+            `Failed to update Leonardo prompt for ${enId} (en-us)`
+          );
+        }
+
+        // Update Portuguese entries (pt-br) for male and female
+        const ptId = `${combinationString}:${g}:${index}:pt`;
+        const ptGenders = ['male', 'female'];
+
+        for (const ptGender of ptGenders) {
+          const ptLeonardoPrompt =
+            ptGender === 'male'
+              ? parsedPrompts[i].malePrompt
+              : parsedPrompts[i].femalePrompt;
+
+          await this.log(
+            'debug',
+            `Updating Leonardo prompt for ${ptId} (pt-br, gender: ${ptGender})`,
+            {
+              leonardoPrompt: ptLeonardoPrompt,
+            }
+          );
+
+          const ptUpdateResult = await db
+            .update(schema.archetypesData)
+            .set({
+              leonardoPrompt: ptLeonardoPrompt,
+              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 Leonardo prompt for ${ptId} (pt-br, gender: ${ptGender})`,
+            {
+              rowsAffected: ptUpdateResult.rowsAffected,
+            }
+          );
+
+          if (ptUpdateResult.rowsAffected === 0) {
+            await this.log(
+              'error',
+              `Failed to update Leonardo prompt for ${ptId} (pt-br, gender: ${ptGender})`,
+              {
+                ptId,
+                language: 'pt-br',
+                gender: ptGender,
+              }
+            );
+            throw new Error(
+              `Failed to update Leonardo prompt for ${ptId} (pt-br, gender: ${ptGender})`
+            );
+          }
+        }
       }
     }
 
@@ -879,63 +1083,83 @@ export class ArchetypeService {
     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: 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}`);
+
+      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', `Empty Leonardo prompt for archetype ${currentArchetype}`, {
-          malePrompt,
-          femalePrompt,
-          malePromptLine,
-          femalePromptLine,
-        });
+        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 });
+      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}`);
+      throw new Error(
+        `Expected exactly 3 archetype prompts, but got ${prompts.length}`
+      );
     }
-  
+
     this.log('info', 'Completed parseLeonardoPromptResponse', { prompts });
     return prompts;
   }

package/package.json

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