@zodic/shared 0.0.372 → 0.0.373

package/app/services/ArchetypeService.ts

@@ -28,42 +28,41 @@ export class ArchetypeService {
     message: string,
     context: Record<string, any> = {}
   ) {
-    const logMessage = `[${level.toUpperCase()}] ${message}`;
-
-    console.log(logMessage, context);
-    // try {
-    //   await db
-    //     .insert(schema.logs)
-    //     .values({
-    //       id: logId,
-    //       level,
-    //       message,
-    //       context: JSON.stringify(context),
-    //       createdAt: new Date().getTime(),
-    //     })
-    //     .execute();
-    // } catch (error) {
-    //   console.error('[ERROR] Failed to persist log to database:', {
-    //     error,
-    //     logId,
-    //     message,
-    //     context,
-    //   });
-    // }
+    const logMessage = `[${new Date().toISOString()}] [${level.toUpperCase()}] ${message}`;
+
+    console[level](logMessage, context);
   }
 
-  // Replace generateArchetypeNames and generateArchetypeNamesBatch
   async generateArchetypeNames(
     combinationString: string,
-    overrideExisting: boolean = false,
+    override: boolean = false,
     indexesToGenerate: number[] = [1, 2, 3]
   ) {
     await this.log('info', 'Starting generateArchetypeNames', {
       combinationString,
-      overrideExisting,
+      override,
       indexesToGenerate,
     });
 
+    const db = this.context.drizzle();
+    const existingArchetypes = await db
+      .select()
+      .from(schema.archetypesData)
+      .where(eq(schema.archetypesData.combination, combinationString))
+      .execute();
+
+    if (
+      !override &&
+      existingArchetypes.length >= 3 * 2 * 2 && // 3 indexes * 2 genders * 2 languages
+      existingArchetypes.every((a) => a.name && a.essenceLine)
+    ) {
+      await this.log('info', 'Skipping archetype names generation', {
+        reason: 'All archetypes have names and essence lines',
+        existingCount: existingArchetypes.length,
+      });
+      return;
+    }
+
     const [sun, ascendant, moon] = combinationString.split(
       '-'
     ) as ZodiacSignSlug[];
@@ -95,8 +94,6 @@ export class ArchetypeService {
       portugueseVariants,
     });
 
-    const db = this.context.drizzle();
-
     async function isEnglishNameDuplicate(name: string): Promise<boolean> {
       const result = await db
         .select({ name: schema.archetypesData.name })
@@ -121,7 +118,10 @@ export class ArchetypeService {
         await this.log(
           'debug',
           `Skipping index ${index} as it is not in indexesToGenerate`,
-          { index, indexesToGenerate }
+          {
+            index,
+            indexesToGenerate,
+          }
         );
         continue;
       }
@@ -148,6 +148,15 @@ export class ArchetypeService {
           const essenceLine =
             lang === 'en-us' ? entry.essenceLine : ptVariant.essenceLine;
 
+          const existing = existingArchetypes.find((a) => a.id === id);
+          if (existing && !override && existing.name && existing.essenceLine) {
+            await this.log('debug', `Skipping existing archetype ${id}`, {
+              name: existing.name,
+              essenceLine: existing.essenceLine,
+            });
+            continue;
+          }
+
           await this.log('debug', `Saving archetype name for ${id}`, {
             name,
             essenceLine,
@@ -171,6 +180,7 @@ export class ArchetypeService {
                 name,
                 essenceLine,
                 updatedAt: new Date().getTime(),
+                status: 'idle',
               },
             });
 
@@ -245,12 +255,14 @@ export class ArchetypeService {
   async generateDescriptionsAndVirtues(
     combinationString: string,
     gender: Gender,
-    language: string
+    language: string,
+    override: boolean = false
   ): Promise<ParsedDescriptionAndVirtues[]> {
     await this.log('info', 'Starting generateDescriptionsAndVirtues', {
       combinationString,
       gender,
       language,
+      override,
     });
 
     const db = this.context.drizzle();
@@ -261,11 +273,27 @@ export class ArchetypeService {
         and(
           eq(schema.archetypesData.combination, combinationString),
           eq(schema.archetypesData.gender, gender),
-          eq(schema.archetypesData.language, 'en-us')
+          eq(schema.archetypesData.language, language)
         )
       )
       .execute();
 
+    if (
+      !override &&
+      archetypes.every((a) => a.description && a.virtues !== '[]')
+    ) {
+      await this.log('info', 'Skipping descriptions and virtues generation', {
+        reason: 'Descriptions and virtues already exist for all archetypes',
+      });
+      return archetypes.map((a) => ({
+        descriptionEN: a.description || '',
+        descriptionPTM: a.description || '',
+        descriptionPTF: a.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),
@@ -289,9 +317,7 @@ export class ArchetypeService {
     const descVirtueResponse = await this.context
       .api()
       .callTogether.single(descVirtueMessages, {
-        options: {
-          temperature: 0.5,
-        },
+        options: { temperature: 0.5 },
       });
     if (!descVirtueResponse) {
       await this.log('error', 'No response for descriptions and virtues', {
@@ -313,87 +339,107 @@ export class ArchetypeService {
 
     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}`, {
-        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 ${enId}`);
+      const ptId = `${combinationString}:${gender}:${index}:pt`;
 
-      // 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,
+      // Update English entry (en-us)
+      if (language === 'en-us') {
+        const enExisting = archetypes.find((a) => a.id === enId);
+        if (
+          !override &&
+          enExisting?.description &&
+          enExisting.virtues !== '[]'
+        ) {
+          await this.log(
+            'debug',
+            `Skipping existing description and virtues for ${enId}`,
+            {
+              description: enExisting.description,
+              virtues: enExisting.virtues,
+            }
+          );
+        } else {
+          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 ${enId}`);
         }
-      );
-      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,
+      // 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;
+          await this.log(
+            'debug',
+            `Updating description and virtues for ${ptId} (${ptGender})`,
+            {
+              description,
+              virtues: parsedDescVirtues[i].virtuesPT,
+            }
+          );
+          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})`
+          );
         }
-      );
-      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', {
@@ -451,8 +497,6 @@ export class ArchetypeService {
 
       for (let i = 0; i < lines.length; i++) {
         let line = lines[i];
-
-        // Remove markdown bold (**...**) from field names
         line = line.replace(/\*\*(.*?)\*\*/g, '$1');
 
         if (
@@ -460,7 +504,7 @@ export class ArchetypeService {
           line.startsWith('2.') ||
           line.startsWith('3.')
         ) {
-          continue; // Skip entry number lines
+          continue;
         }
 
         if (line.startsWith('• Description EN:')) {
@@ -510,7 +554,6 @@ export class ArchetypeService {
             virtuesPT,
           });
         } else if (line.startsWith('• Virtues:')) {
-          // Fallback for older response format: use English virtues and attempt to translate
           currentField = 'virtuesEN';
           virtuesEN = line
             .split('• Virtues:')[1]
@@ -524,14 +567,12 @@ export class ArchetypeService {
             { 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
+          virtuesPT = virtuesEN.map((v) => virtueTranslations[v] || v);
           this.log(
             'debug',
             `Generated virtuesPT (fallback) for entry ${entryIndex + 1}`,
@@ -563,7 +604,6 @@ export class ArchetypeService {
         }
       }
 
-      // Validate the parsed data
       if (
         !descriptionEN ||
         !descriptionPTM ||
@@ -611,12 +651,14 @@ export class ArchetypeService {
     combinationString: string,
     gender: Gender,
     language: string,
-    descriptions: Array<{ descriptionEN: string }>
+    descriptions: Array<{ descriptionEN: string }>,
+    override: boolean = false
   ) {
     await this.log('info', 'Starting generateContent', {
       combinationString,
       gender,
       language,
+      override,
     });
 
     const db = this.context.drizzle();
@@ -627,11 +669,18 @@ export class ArchetypeService {
         and(
           eq(schema.archetypesData.combination, combinationString),
           eq(schema.archetypesData.gender, gender),
-          eq(schema.archetypesData.language, 'en-us')
+          eq(schema.archetypesData.language, language)
         )
       )
       .execute();
 
+    if (!override && archetypes.every((a) => a.content !== '[]')) {
+      await this.log('info', 'Skipping content generation', {
+        reason: 'Content already exists for all archetypes',
+      });
+      return;
+    }
+
     await this.log('info', 'Fetched archetypes for content generation', {
       archetypesCount: archetypes.length,
       names: archetypes.map((a) => a.name),
@@ -639,6 +688,20 @@ export class ArchetypeService {
 
     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;
+      }
+
       await this.log('debug', `Generating content for archetype ${i + 1}`, {
         name: archetypes[i].name,
       });
@@ -660,7 +723,10 @@ export class ArchetypeService {
         await this.log(
           'error',
           `No response for content of archetype ${i + 1}`,
-          { combinationString, archetype: archetypes[i].name }
+          {
+            combinationString,
+            archetype: archetypes[i].name,
+          }
         );
         throw new Error(
           `Failed to generate content for archetype ${
@@ -671,7 +737,9 @@ export class ArchetypeService {
       await this.log(
         'info',
         `Received content response for archetype ${i + 1}`,
-        { responseLength: contentResponse.length }
+        {
+          responseLength: contentResponse.length,
+        }
       );
 
       await this.log(
@@ -684,58 +752,52 @@ export class ArchetypeService {
         parsedContent,
       });
 
-      const index = (i + 1).toString();
-      for (const lang of ['en-us', 'pt-br']) {
-        const contentLangIndex =
-          lang === '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,
-          },
-        ];
+      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,
+        },
+      ];
 
-        const id = `${combinationString}:${gender}:${index}${
-          lang === 'pt-br' ? ':pt' : ''
-        }`;
-        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, lang)
-            )
+      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)
           )
-          .execute();
+        )
+        .execute();
 
-        await this.log('info', `Updated content for ${id}`);
-      }
+      await this.log('info', `Updated content for ${id}`);
     }
 
     await this.log('info', 'Completed generateContent', {
@@ -798,7 +860,10 @@ export class ArchetypeService {
               `Extracted section ${currentSection} in section ${
                 sectionIndex + 1
               }`,
-              { key, text: content[key] }
+              {
+                key,
+                text: content[key],
+              }
             );
           }
           currentSection = line.replace('# ', '');
@@ -825,7 +890,10 @@ export class ArchetypeService {
           `Extracted final section ${currentSection} in section ${
             sectionIndex + 1
           }`,
-          { key, text: content[key] }
+          {
+            key,
+            text: content[key],
+          }
         );
       }
 
@@ -863,26 +931,22 @@ export class ArchetypeService {
 
   async generateLeonardoPrompts(
     combinationString: 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 }>
+    gender: Gender,
+    language: string,
+    descriptions: Array<{ descriptionEN: string }>,
+    override: boolean = false
   ) {
     await this.log('info', 'Starting generateLeonardoPrompts', {
       combinationString,
       gender,
       language,
+      override,
     });
 
     const db = this.context.drizzle();
-
     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: [],
-    };
+    const archetypesByGender: Record<Binary, any[]> = { male: [], female: [] };
 
     for (const g of allGenders) {
       const archetypes = await db
@@ -892,14 +956,13 @@ export class ArchetypeService {
           and(
             eq(schema.archetypesData.combination, combinationString),
             eq(schema.archetypesData.gender, g),
-            eq(schema.archetypesData.language, 'en-us')
+            eq(schema.archetypesData.language, language)
           )
         )
         .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(
@@ -916,6 +979,16 @@ export class ArchetypeService {
       }
     }
 
+    if (
+      !override &&
+      archetypesByGender[gender as Binary].every((a) => a.leonardoPrompt)
+    ) {
+      await this.log('info', 'Skipping Leonardo prompts generation', {
+        reason: 'Leonardo prompts already exist for all archetypes',
+      });
+      return;
+    }
+
     await this.log('info', 'Fetched archetypes for Leonardo prompts', {
       maleArchetypesCount: archetypesByGender['male'].length,
       femaleArchetypesCount: archetypesByGender['female'].length,
@@ -925,8 +998,6 @@ export class ArchetypeService {
       },
     });
 
-    // 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(
@@ -957,7 +1028,6 @@ export class ArchetypeService {
     const parsedPrompts = this.parseLeonardoPromptResponse(promptResponse);
     await this.log('info', 'Parsed Leonardo prompts', { parsedPrompts });
 
-    // Update archetypes for all genders
     for (const g of allGenders) {
       for (let i = 0; i < 3; i++) {
         const index = (i + 1).toString();
@@ -966,105 +1036,39 @@ export class ArchetypeService {
             ? 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,
-          }
-        );
-
-        const enUpdateResult = await db
-          .update(schema.archetypesData)
-          .set({
-            leonardoPrompt,
-            updatedAt: new Date().getTime(),
-          })
-          .where(
-            and(
-              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 ${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;
-
+        const id = `${combinationString}:${g}:${index}${
+          language === 'pt-br' ? ':pt' : ''
+        }`;
+        const existing = archetypesByGender[g].find((a) => a.id === id);
+        if (!override && existing?.leonardoPrompt) {
           await this.log(
             'debug',
-            `Updating Leonardo prompt for ${ptId} (pt-br, gender: ${ptGender})`,
+            `Skipping existing Leonardo prompt for ${id}`,
             {
-              leonardoPrompt: ptLeonardoPrompt,
+              leonardoPrompt: existing.leonardoPrompt,
             }
           );
-
-          const ptUpdateResult = await db
+        } else {
+          await this.log('debug', `Updating Leonardo prompt for ${id}`, {
+            leonardoPrompt,
+          });
+          const updateResult = await db
             .update(schema.archetypesData)
             .set({
-              leonardoPrompt: ptLeonardoPrompt,
+              leonardoPrompt,
               updatedAt: new Date().getTime(),
             })
             .where(
               and(
-                eq(schema.archetypesData.id, ptId),
-                eq(schema.archetypesData.language, 'pt-br'),
-                eq(schema.archetypesData.gender, ptGender)
+                eq(schema.archetypesData.id, id),
+                eq(schema.archetypesData.language, language),
+                eq(schema.archetypesData.gender, g)
               )
             )
             .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})`
-            );
-          }
+          await this.log('info', `Updated Leonardo prompt for ${id}`, {
+            rowsAffected: updateResult.rowsAffected,
+          });
         }
       }
     }
@@ -1092,11 +1096,10 @@ export class ArchetypeService {
     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
+      const maleLabel = lines[i];
+      const malePromptLine = lines[i + 1];
+      const femaleLabel = lines[i + 2];
+      const femalePromptLine = lines[i + 3];
 
       currentArchetype++;
       const expectedMaleLabel = `${currentArchetype}.m`;

package/app/workflow/ArchetypeWorkflow.ts

@@ -1,4 +1,4 @@
-import { and, eq, inArray } from 'drizzle-orm';
+import { and, eq } from 'drizzle-orm';
 import { inject, injectable } from 'inversify';
 import { schema } from '../..';
 import { Gender } from '../../types';
@@ -20,7 +20,7 @@ export class ArchetypeWorkflow {
     context: Record<string, any> = {}
   ) {
     const logId = `archetype-workflow:${Date.now()}`;
-    const logMessage = `[${level.toUpperCase()}] ${message}`;
+    const logMessage = `[${new Date().toISOString()}] [${level.toUpperCase()}] ${message}`;
 
     console[level](logMessage, context);
     const db = this.context.drizzle();
@@ -48,167 +48,228 @@ export class ArchetypeWorkflow {
   async execute(
     combinationString: string,
     gender: Gender,
-    language: string = 'en-us'
+    language: string = 'en-us',
+    override: boolean = false
   ) {
     await this.log('info', 'Starting ArchetypeWorkflow', {
       combinationString,
       gender,
       language,
+      override,
     });
-  
-    // Step 1: Check if archetypes exist, if not, generate names
+
+    // Step 1: Fetch existing archetypes
     let archetypes = await this.archetypeService.fetchArchetypesFromDB(
       combinationString,
       gender,
       language
     );
-    if (archetypes.length === 0) {
-      await this.log('info', 'No archetypes found, generating names', {
+    await this.log('info', 'Fetched existing archetypes', {
+      archetypesCount: archetypes.length,
+      archetypeIds: archetypes.map((a) => a.id),
+    });
+
+    // Step 2: Generate or update archetype names and essence lines
+    if (
+      override ||
+      archetypes.length === 0 ||
+      archetypes.some((a) => !a.name || !a.essenceLine)
+    ) {
+      await this.log('info', 'Generating or updating archetype names', {
         combinationString,
         gender,
         language,
+        override,
       });
-      await this.archetypeService.generateArchetypeNames(combinationString);
+      await this.archetypeService.generateArchetypeNames(
+        combinationString,
+        override
+      );
       archetypes = await this.archetypeService.fetchArchetypesFromDB(
         combinationString,
         gender,
         language
       );
+      await this.log('info', 'Refetched archetypes after name generation', {
+        archetypesCount: archetypes.length,
+        archetypeIds: archetypes.map((a) => a.id),
+      });
+    } else {
+      await this.log('info', 'Skipping archetype names generation', {
+        reason: 'Names and essence lines already exist',
+      });
     }
-    await this.log('info', 'Fetched archetypes', {
-      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', {
-      combinationString,
-      gender,
-    });
-    const inProgressGenerations = await db
-      .select()
-      .from(schema.generations)
-      .where(
-        and(
-          eq(schema.generations.status, 'pending'),
-          eq(schema.generations.gender, gender),
-          inArray(
-            schema.generations.archetypeDataId,
-            archetypes.map((a) => a.id)
-          )
-        )
-      )
-      .execute();
-  
-    if (inProgressGenerations.length > 0) {
-      await this.log(
-        'warn',
-        `Images are already being processed for ${combinationString}, gender: ${gender}`,
-        {
-          inProgressGenerationsCount: inProgressGenerations.length,
-          generationIds: inProgressGenerations.map((g) => g.id),
-        }
+
+    // Step 3: Generate or update descriptions and virtues
+    let descVirtues: any[] = [];
+    if (
+      override ||
+      archetypes.some((a) => !a.description || a.virtues === '[]')
+    ) {
+      await this.log('info', 'Generating or updating descriptions and virtues', {
+        combinationString,
+        gender,
+        language,
+        override,
+      });
+      descVirtues = await this.archetypeService.generateDescriptionsAndVirtues(
+        combinationString,
+        gender,
+        language,
+        override
       );
-      return { message: 'Images are being processed, please try again later.' };
+      archetypes = await this.archetypeService.fetchArchetypesFromDB(
+        combinationString,
+        gender,
+        language
+      );
+      await this.log('info', 'Refetched archetypes after descriptions and virtues', {
+        archetypesCount: archetypes.length,
+        archetypeIds: archetypes.map((a) => a.id),
+      });
+    } else {
+      await this.log('info', 'Skipping descriptions and virtues generation', {
+        reason: 'Descriptions and virtues already exist',
+      });
     }
-    await this.log('info', 'No in-progress image generations found', {
-      combinationString,
-      gender,
-    });
-  
-    // Step 3: Generate missing textual content (description, virtues, content, leonardoPrompt)
-    const archetypesNeedingText = archetypes.filter(
-      (arc) =>
-        !arc.description ||
-        arc.virtues === '[]' ||
-        arc.content === '[]' ||
-        !arc.leonardoPrompt
-    );
-  
-    if (archetypesNeedingText.length > 0) {
-      await this.log('info', 'Generating missing textual content', {
+
+    // Step 4: Generate or update content
+    if (override || archetypes.some((a) => a.content === '[]')) {
+      await this.log('info', 'Generating or updating content', {
         combinationString,
         gender,
         language,
-        archetypesNeedingTextCount: archetypesNeedingText.length,
-        archetypeIds: archetypesNeedingText.map((a) => a.id),
-      });
-  
-      const descVirtues =
-        await this.archetypeService.generateDescriptionsAndVirtues(
-          combinationString,
-          gender,
-          language
-        );
+        override,
+      });
       await this.archetypeService.generateContent(
         combinationString,
         gender,
         language,
-        descVirtues
+        descVirtues,
+        override
       );
-      await this.archetypeService.generateLeonardoPrompts(
+      archetypes = await this.archetypeService.fetchArchetypesFromDB(
         combinationString,
         gender,
-        language,
-        descVirtues
+        language
       );
+      await this.log('info', 'Refetched archetypes after content generation', {
+        archetypesCount: archetypes.length,
+        archetypeIds: archetypes.map((a) => a.id),
+      });
     } else {
-      await this.log('info', 'No textual content generation needed', {
+      await this.log('info', 'Skipping content generation', {
+        reason: 'Content already exists',
+      });
+    }
+
+    // Step 5: Generate or update Leonardo prompts
+    if (override || archetypes.some((a) => !a.leonardoPrompt)) {
+      await this.log('info', 'Generating or updating Leonardo prompts', {
         combinationString,
         gender,
         language,
+        override,
+      });
+      await this.archetypeService.generateLeonardoPrompts(
+        combinationString,
+        gender,
+        language,
+        descVirtues,
+        override
+      );
+      archetypes = await this.archetypeService.fetchArchetypesFromDB(
+        combinationString,
+        gender,
+        language
+      );
+      await this.log('info', 'Refetched archetypes after Leonardo prompts', {
+        archetypesCount: archetypes.length,
+        archetypeIds: archetypes.map((a) => a.id),
+      });
+    } else {
+      await this.log('info', 'Skipping Leonardo prompts generation', {
+        reason: 'Leonardo prompts already exist',
       });
     }
-  
-    // Refetch archetypes after generating textual content
-    const updatedArchetypes = await this.archetypeService.fetchArchetypesFromDB(
-      combinationString,
-      gender,
-      language
-    );
-    await this.log('info', 'Refetched archetypes', {
-      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
+
+    // Step 6: Process image generation if needed
+    const archetypesNeedingImages = archetypes.filter(
+      (arc) => JSON.parse(arc.images).length < 3 || (override && arc.images !== '[]')
     );
-  
+
     if (archetypesNeedingImages.length > 0) {
-      await this.log(
-        'info',
-        'Queuing image generation for missing archetypes',
-        {
-          archetypesNeedingImagesCount: archetypesNeedingImages.length,
-          archetypeIds: archetypesNeedingImages.map((a) => a.id),
+      await this.log('info', 'Processing image generation for archetypes', {
+        archetypesNeedingImagesCount: archetypesNeedingImages.length,
+        archetypeIds: archetypesNeedingImages.map((a) => a.id),
+      });
+
+      for (const archetype of archetypesNeedingImages) {
+        await this.log('debug', 'Processing image generation', {
+          archetypeId: archetype.id,
+          leonardoPrompt: archetype.leonardoPrompt,
+        });
+
+        // Reset images and status if override is true
+        if (override) {
+          await this.context.drizzle()
+            .update(schema.archetypesData)
+            .set({
+              images: '[]',
+              status: 'idle',
+              updatedAt: new Date().getTime(),
+            })
+            .where(eq(schema.archetypesData.id, archetype.id))
+            .execute();
+          await this.log('info', 'Reset images and status for archetype', {
+            archetypeId: archetype.id,
+          });
         }
-      );
-  
-      const batch = archetypesNeedingImages.map((arc) => ({
-        body: {
-          archetypeDataId: arc.id,
-        },
-      }));
-      await this.log('debug', 'Sending batch to ARCHETYPE_POPULATION_QUEUE', {
-        batchCount: batch.length,
-        batch,
-      });
-      await this.context.env.ARCHETYPE_POPULATION_QUEUE.sendBatch(batch);
-      await this.log('info', 'Successfully queued image generation', {
-        batchCount: batch.length,
-      });
-  
-      return { message: 'Images are being processed, please try again later.' };
+
+        // Process image generation directly
+        await this.leonardoService.processArchetypePopulation({
+          archetypeDataId: archetype.id,
+        });
+
+        // Note: processArchetypePopulation sets status to 'pending' in the generations table
+        // Update archetype status to 'pending' for consistency
+        await this.context.drizzle()
+          .update(schema.archetypesData)
+          .set({
+            status: 'pending',
+            updatedAt: new Date().getTime(),
+          })
+          .where(eq(schema.archetypesData.id, archetype.id))
+          .execute();
+      }
+
+      await this.log('info', 'Image generation processing initiated', {
+        archetypesProcessed: archetypesNeedingImages.length,
+      });
+      return {
+        message: 'Image generation has been queued. Please try again later.',
+      };
+    }
+
+    // Step 7: Verify all archetypes are complete
+    const incompleteArchetypes = archetypes.filter((a) => a.status !== 'generated');
+    if (incompleteArchetypes.length > 0) {
+      await this.log('warn', 'Some archetypes are not complete', {
+        incompleteArchetypeIds: incompleteArchetypes.map((a) => a.id),
+        statuses: incompleteArchetypes.map((a) => a.status),
+      });
+      return {
+        message: 'Archetype generation is still in progress. Please try again later.',
+      };
     }
-  
-    await this.log('info', 'Archetypes fully processed and ready', {
-      updatedArchetypes,
+
+    await this.log('info', 'All archetypes are complete', {
+      archetypesCount: archetypes.length,
+      archetypeIds: archetypes.map((a) => a.id),
     });
+
     return {
-      archetypes: updatedArchetypes.map(
+      archetypes: archetypes.map(
         ({ id, name, essenceLine, description, virtues, images }) => ({
           id,
           name,
@@ -220,4 +281,4 @@ export class ArchetypeWorkflow {
       ),
     };
   }
-}
+}

package/package.json

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