@zodic/shared 0.0.315 → 0.0.317

package/app/workflow/ArchetypeWorkflow.ts

@@ -2,7 +2,7 @@ import { and, eq } from 'drizzle-orm';
 import { inject, injectable } from 'inversify';
 import { schema } from '../..';
 import { Gender } from '../../types';
-import { AppContext } from '../base/AppContext';
+import { AppContext } from '../base';
 import { ArchetypeService } from '../services/ArchetypeService';
 import { LeonardoService } from '../services/LeonardoService';
 
@@ -23,7 +23,6 @@ export class ArchetypeWorkflow {
     const logMessage = `[${level.toUpperCase()}] ${message}`;
 
     console[level](logMessage, context);
-
     const db = this.context.drizzle();
     try {
       await db
@@ -57,23 +56,31 @@ export class ArchetypeWorkflow {
       language,
     });
 
-    // Fetch archetypes from archetypes_data
-    await this.log('debug', 'Fetching archetypes from database', {
-      combinationString,
-      gender,
-      language,
-    });
-    const archetypes = await this.fetchArchetypesFromDB(
+    // Step 1: Check if archetypes exist, if not, generate names
+    let archetypes = await this.archetypeService.fetchArchetypesFromDB(
       combinationString,
       gender,
       language
     );
+    if (archetypes.length === 0) {
+      await this.log('info', 'No archetypes found, generating names', {
+        combinationString,
+        gender,
+        language,
+      });
+      await this.archetypeService.generateArchetypeNames(combinationString);
+      archetypes = await this.archetypeService.fetchArchetypesFromDB(
+        combinationString,
+        gender,
+        language
+      );
+    }
     await this.log('info', 'Fetched archetypes', {
       archetypesCount: archetypes.length,
       archetypeIds: archetypes.map((a) => a.id),
     });
 
-    // Check if any archetypes are already being processed (images are generating)
+    // 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,
@@ -86,7 +93,7 @@ export class ArchetypeWorkflow {
         and(
           eq(schema.generations.status, 'pending'),
           eq(schema.generations.gender, gender),
-          eq(schema.generations.conceptCombinationId, combinationString)
+          eq(schema.generations.archetypeDataId, combinationString)
         )
       )
       .execute();
@@ -107,7 +114,7 @@ export class ArchetypeWorkflow {
       gender,
     });
 
-    // Step 1: Generate missing textual content (description, virtues, content, leonardoPrompt)
+    // Step 3: Generate missing textual content (description, virtues, content, leonardoPrompt)
     const archetypesNeedingText = archetypes.filter(
       (arc) =>
         !arc.description ||
@@ -124,7 +131,25 @@ export class ArchetypeWorkflow {
         archetypesNeedingTextCount: archetypesNeedingText.length,
         archetypeIds: archetypesNeedingText.map((a) => a.id),
       });
-      await this.generateTextualContent(combinationString, gender, language);
+
+      const descVirtues =
+        await this.archetypeService.generateDescriptionsAndVirtues(
+          combinationString,
+          gender,
+          language
+        );
+      await this.archetypeService.generateContent(
+        combinationString,
+        gender,
+        language,
+        descVirtues
+      );
+      await this.archetypeService.generateLeonardoPrompts(
+        combinationString,
+        gender,
+        language,
+        descVirtues
+      );
     } else {
       await this.log('info', 'No textual content generation needed', {
         combinationString,
@@ -134,12 +159,7 @@ export class ArchetypeWorkflow {
     }
 
     // Refetch archetypes after generating textual content
-    await this.log(
-      'debug',
-      'Refetching archetypes after textual content generation',
-      { combinationString, gender, language }
-    );
-    const updatedArchetypes = await this.fetchArchetypesFromDB(
+    const updatedArchetypes = await this.archetypeService.fetchArchetypesFromDB(
       combinationString,
       gender,
       language
@@ -149,7 +169,7 @@ export class ArchetypeWorkflow {
       archetypeIds: updatedArchetypes.map((a) => a.id),
     });
 
-    // Step 2: Queue image generation if needed
+    // Step 4: Queue image generation if needed
     const archetypesNeedingImages = updatedArchetypes.filter(
       (arc) => JSON.parse(arc.images).length < 3
     );
@@ -164,7 +184,6 @@ export class ArchetypeWorkflow {
         }
       );
 
-      // Queue image generation for all archetypes needing images
       const batch = archetypesNeedingImages.map((arc) => ({
         body: {
           archetypeDataId: arc.id,
@@ -201,541 +220,4 @@ export class ArchetypeWorkflow {
       ),
     };
   }
-
-  private async fetchArchetypesFromDB(
-    combinationString: string,
-    gender: Gender,
-    language: string
-  ) {
-    await this.log('debug', 'Executing fetchArchetypesFromDB', {
-      combinationString,
-      gender,
-      language,
-    });
-    const db = this.context.drizzle();
-    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)
-        )
-      )
-      .execute();
-    await this.log('debug', 'fetchArchetypesFromDB result', {
-      resultCount: result.length,
-      result,
-    });
-    return result;
-  }
-
-  private async generateTextualContent(
-    combinationString: string,
-    gender: Gender,
-    language: string
-  ) {
-    await this.log('info', 'Starting generateTextualContent', {
-      combinationString,
-      gender,
-      language,
-    });
-
-    const db = this.context.drizzle();
-
-    // Fetch English archetypes to get names and essence lines
-    await this.log(
-      'debug',
-      'Fetching English archetypes for names and essence lines',
-      { combinationString, gender }
-    );
-    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')
-        )
-      )
-      .execute();
-    await this.log('info', 'Fetched English archetypes', {
-      archetypesCount: archetypes.length,
-      names: archetypes.map((a) => a.name),
-      essenceLines: archetypes.map((a) => a.essenceLine),
-    });
-
-    // Step 1: Generate description and virtues
-    await this.log('debug', 'Generating description and virtues', {
-      combinationString,
-    });
-    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,
-        ],
-      });
-
-    await this.log('debug', 'Calling API for description and virtues', {
-      messages: descVirtueMessages,
-    });
-    const descVirtueResponse = await this.context
-      .api()
-      .callTogether.single(descVirtueMessages, {});
-    await this.log('info', 'Received description and virtues response', {
-      responseLength: descVirtueResponse.length,
-    });
-
-    await this.log('debug', 'Parsing description and virtues response');
-    const parsedDescVirtues =
-      this.parseDescriptionAndVirtuesResponse(descVirtueResponse);
-    await this.log('info', 'Parsed description and virtues', {
-      parsedDescVirtues,
-    });
-
-    // Step 2: Generate content for each archetype
-    const contentResults = [];
-    for (let i = 0; i < 3; i++) {
-      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: parsedDescVirtues[i].descriptionEN,
-        });
-
-      await this.log('debug', `Calling API for content of archetype ${i + 1}`, {
-        messages: contentMessages,
-      });
-      const contentResponse = await this.context
-        .api()
-        .callTogether.single(contentMessages, {});
-      await this.log(
-        'info',
-        `Received content response for archetype ${i + 1}`,
-        { responseLength: contentResponse.length }
-      );
-
-      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,
-      });
-    }
-
-    // Step 3: Generate Leonardo prompts for all archetypes
-    await this.log('debug', 'Generating Leonardo prompts for all archetypes');
-    const promptMessages = this.context
-      .buildLLMMessages()
-      .generateCosmicMirrorArchetypeLeonardoPrompts(
-        archetypes.map((arc, idx) => ({
-          name: arc.name,
-          description: parsedDescVirtues[idx].descriptionEN,
-        }))
-      );
-
-    await this.log('debug', 'Calling API for Leonardo prompts', {
-      messages: promptMessages,
-    });
-    const promptResponse = await this.context
-      .api()
-      .callTogether.single(promptMessages, {});
-    await this.log('info', 'Received Leonardo prompts response', {
-      responseLength: promptResponse.length,
-    });
-
-    await this.log('debug', 'Parsing Leonardo prompts response');
-    const parsedPrompts = this.parseLeonardoPromptResponse(promptResponse);
-    await this.log('info', 'Parsed Leonardo prompts', { parsedPrompts });
-
-    // Update archetypes_data with the generated content
-    for (let i = 0; i < 3; i++) {
-      const archetype = archetypes[i];
-      const index = (i + 1).toString();
-
-      for (const lang of ['en-us', 'pt-br']) {
-        const descriptionField =
-          lang === 'en-us'
-            ? parsedDescVirtues[i].descriptionEN
-            : gender === 'male'
-            ? parsedDescVirtues[i].descriptionPTM
-            : parsedDescVirtues[i].descriptionPTF;
-
-        const contentLangIndex =
-          lang === 'en-us' ? 0 : gender === 'male' ? 1 : 2;
-        const content = [
-          {
-            section: 'voiceOfTheSoul',
-            text: contentResults[i][contentLangIndex].voiceOfTheSoul,
-          },
-          {
-            section: 'giftsYouBear',
-            text: contentResults[i][contentLangIndex].giftsYouBear,
-          },
-          {
-            section: 'shadowsYouFace',
-            text: contentResults[i][contentLangIndex].shadowsYouFace,
-          },
-          {
-            section: 'rhythmOfYourDays',
-            text: contentResults[i][contentLangIndex].rhythmOfYourDays,
-          },
-          {
-            section: 'tiesThatBind',
-            text: contentResults[i][contentLangIndex].tiesThatBind,
-          },
-          {
-            section: 'lightWithin',
-            text: contentResults[i][contentLangIndex].lightWithin,
-          },
-        ];
-
-        const leonardoPrompt =
-          gender === 'male'
-            ? parsedPrompts[i].malePrompt
-            : parsedPrompts[i].femalePrompt;
-
-        await this.log(
-          'debug',
-          `Updating archetypes_data for archetype ${index}, language: ${lang}`,
-          {
-            descriptionField,
-            content,
-            leonardoPrompt,
-          }
-        );
-
-        await db
-          .update(schema.archetypesData)
-          .set({
-            description: descriptionField,
-            virtues: JSON.stringify(parsedDescVirtues[i].virtues),
-            content: JSON.stringify(content),
-            leonardoPrompt,
-            updatedAt: new Date().getTime(),
-          })
-          .where(
-            and(
-              eq(schema.archetypesData.combination, combinationString),
-              eq(schema.archetypesData.gender, gender),
-              eq(schema.archetypesData.language, lang),
-              eq(schema.archetypesData.archetypeIndex, index)
-            )
-          )
-          .execute();
-
-        await this.log(
-          'info',
-          `Updated archetypes_data for archetype ${index}, language: ${lang}`
-        );
-      }
-    }
-
-    await this.log('info', 'Completed generateTextualContent', {
-      combinationString,
-      gender,
-      language,
-    });
-  }
-
-  private parseDescriptionAndVirtuesResponse(response: string) {
-    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,
-    });
-
-    const result = entries.map((entry, entryIndex) => {
-      this.log('debug', `Processing entry ${entryIndex + 1}`, { entry });
-
-      const lines = entry.split('\n').filter((line) => line.trim());
-      this.log('debug', `Split entry ${entryIndex + 1} into lines`, {
-        linesCount: lines.length,
-        lines,
-      });
-
-      let descriptionEN = '';
-      let descriptionPTM = '';
-      let descriptionPTF = '';
-      let virtues: string[] = [];
-      let currentField = '';
-
-      for (const line of 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 }
-          );
-        } 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 }
-          );
-        } 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 }
-          );
-        } else if (line.startsWith('• Virtues:')) {
-          currentField = 'virtues';
-          virtues =
-            line
-              .split('• Virtues:')[1]
-              ?.split(',')
-              .map((v) => v.trim())
-              .filter((v) => v) || [];
-          this.log('debug', `Extracted virtues for entry ${entryIndex + 1}`, {
-            virtues,
-          });
-        } else if (currentField && currentField !== 'virtues') {
-          if (currentField === 'descriptionEN') {
-            descriptionEN += ' ' + line.trim();
-            this.log(
-              'debug',
-              `Appended to descriptionEN for entry ${entryIndex + 1}`,
-              { descriptionEN }
-            );
-          }
-          if (currentField === 'descriptionPTM') {
-            descriptionPTM += ' ' + line.trim();
-            this.log(
-              'debug',
-              `Appended to descriptionPTM for entry ${entryIndex + 1}`,
-              { descriptionPTM }
-            );
-          }
-          if (currentField === 'descriptionPTF') {
-            descriptionPTF += ' ' + line.trim();
-            this.log(
-              'debug',
-              `Appended to descriptionPTF for entry ${entryIndex + 1}`,
-              { descriptionPTF }
-            );
-          }
-        }
-      }
-
-      if (
-        !descriptionEN ||
-        !descriptionPTM ||
-        !descriptionPTF ||
-        virtues.length !== 3
-      ) {
-        this.log(
-          'warn',
-          `Malformed description and virtues response for entry ${
-            entryIndex + 1
-          }`,
-          {
-            descriptionEN,
-            descriptionPTM,
-            descriptionPTF,
-            virtues,
-            response: entry,
-          }
-        );
-      }
-
-      return { descriptionEN, descriptionPTM, descriptionPTF, virtues };
-    });
-
-    this.log('info', 'Completed parseDescriptionAndVirtuesResponse', {
-      result,
-    });
-    return result;
-  }
-
-  private parseContentResponse(response: string) {
-    this.log('debug', 'Starting parseContentResponse', {
-      responseLength: response.length,
-    });
-
-    const sections = response
-      .split(/---/)
-      .map((block) => block.trim())
-      .filter((block) => block.length > 0);
-    this.log('debug', 'Split response into sections', {
-      sectionsCount: sections.length,
-    });
-
-    const result = sections.map((section, sectionIndex) => {
-      this.log('debug', `Processing section ${sectionIndex + 1}`, { section });
-
-      const lines = section.split('\n').filter((line) => line.trim());
-      this.log('debug', `Split section ${sectionIndex + 1} into lines`, {
-        linesCount: lines.length,
-        lines,
-      });
-
-      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;
-        }
-
-        if (line.startsWith('#')) {
-          if (currentSection && currentText.length > 0) {
-            const key = currentSection
-              .toLowerCase()
-              .replace(/\s+/g, '')
-              .replace(/([A-Z])/g, (match) => match.toLowerCase());
-            content[key] = currentText.join(' ').trim();
-            this.log(
-              'debug',
-              `Extracted section ${currentSection} in section ${
-                sectionIndex + 1
-              }`,
-              { key, text: content[key] }
-            );
-          }
-          currentSection = line.replace('# ', '');
-          currentText = [];
-          this.log(
-            'debug',
-            `Starting new section ${currentSection} in section ${
-              sectionIndex + 1
-            }`
-          );
-        } else {
-          currentText.push(line);
-        }
-      }
-
-      if (currentSection && currentText.length > 0) {
-        const key = currentSection
-          .toLowerCase()
-          .replace(/\s+/g, '')
-          .replace(/([A-Z])/g, (match) => match.toLowerCase());
-        content[key] = currentText.join(' ').trim();
-        this.log(
-          'debug',
-          `Extracted final section ${currentSection} in section ${
-            sectionIndex + 1
-          }`,
-          { key, text: content[key] }
-        );
-      }
-
-      const parsedContent = {
-        voiceOfTheSoul:
-          content['thevoiceofthesoul'] || content['avozdaalma'] || '',
-        giftsYouBear:
-          content['thegiftsyoubear'] || content['osdonsquevocêcarrega'] || '',
-        shadowsYouFace:
-          content['theshadowsyouface'] || content['assombrasqueenfrenta'] || '',
-        rhythmOfYourDays:
-          content['therhythmofyourdays'] || content['oritmodosseusdias'] || '',
-        tiesThatBind:
-          content['thetiesthatbind'] || content['oslaçosqueteconectam'] || '',
-        lightWithin: content['thelightwithin'] || content['aluzinterior'] || '',
-      };
-
-      if (Object.values(parsedContent).some((value) => !value)) {
-        this.log(
-          'warn',
-          `Malformed content response for section ${sectionIndex + 1}`,
-          {
-            parsedContent,
-            response: section,
-          }
-        );
-      }
-
-      return parsedContent;
-    });
-
-    this.log('info', 'Completed parseContentResponse', { result });
-    return result;
-  }
-
-  private parseLeonardoPromptResponse(response: string) {
-    this.log('debug', 'Starting parseLeonardoPromptResponse', {
-      responseLength: response.length,
-    });
-
-    const lines = response.split('\n').filter((line) => line.trim());
-    this.log('debug', 'Split response into lines', {
-      linesCount: lines.length,
-      lines,
-    });
-
-    const prompts: Array<{ malePrompt: string; femalePrompt: string }> = [];
-
-    for (let i = 0; i < lines.length; i += 2) {
-      const maleLine = lines[i];
-      const femaleLine = lines[i + 1];
-
-      const malePrompt = maleLine.startsWith(`${Math.floor(i / 2) + 1}.m`)
-        ? maleLine.split(`${Math.floor(i / 2) + 1}.m`)[1]?.trim()
-        : '';
-      const femalePrompt = femaleLine.startsWith(`${Math.floor(i / 2) + 1}.f`)
-        ? femaleLine.split(`${Math.floor(i / 2) + 1}.f`)[1]?.trim()
-        : '';
-
-      prompts.push({ malePrompt, femalePrompt });
-      this.log(
-        'debug',
-        `Parsed prompts for archetype ${Math.floor(i / 2) + 1}`,
-        { malePrompt, femalePrompt }
-      );
-
-      if (!malePrompt || !femalePrompt) {
-        this.log(
-          'warn',
-          `Malformed Leonardo prompt for archetype ${Math.floor(i / 2) + 1}`,
-          {
-            malePrompt,
-            femalePrompt,
-            maleLine,
-            femaleLine,
-          }
-        );
-      }
-    }
-
-    this.log('info', 'Completed parseLeonardoPromptResponse', { prompts });
-    return prompts;
-  }
 }

package/package.json

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