@zodic/shared 0.0.313 → 0.0.315

package/app/workflow/ArchetypeWorkflow.ts

@@ -1,7 +1,7 @@
+import { and, eq } from 'drizzle-orm';
 import { inject, injectable } from 'inversify';
+import { schema } from '../..';
 import { Gender } from '../../types';
-import { KVArchetype } from '../../types/scopes/legacy';
-import { buildCosmicMirrorArchetypeKVKey } from '../../utils/KVKeysBuilders';
 import { AppContext } from '../base/AppContext';
 import { ArchetypeService } from '../services/ArchetypeService';
 import { LeonardoService } from '../services/LeonardoService';
@@ -14,176 +14,728 @@ export class ArchetypeWorkflow {
     @inject(LeonardoService) private leonardoService: LeonardoService
   ) {}
 
-  async execute(combinationString: string, gender: Gender) {
-    console.log('Starting ArchetypeWorkflow for:', {
+  private async log(
+    level: 'info' | 'debug' | 'warn' | 'error',
+    message: string,
+    context: Record<string, any> = {}
+  ) {
+    const logId = `archetype-workflow:${Date.now()}`;
+    const logMessage = `[${level.toUpperCase()}] ${message}`;
+
+    console[level](logMessage, context);
+
+    const db = this.context.drizzle();
+    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,
+      });
+    }
+  }
+
+  async execute(
+    combinationString: string,
+    gender: Gender,
+    language: string = 'en-us'
+  ) {
+    await this.log('info', 'Starting ArchetypeWorkflow', {
       combinationString,
       gender,
+      language,
     });
 
-    const archetypes = await this.fetchArchetypesFromKV(
+    // Fetch archetypes from archetypes_data
+    await this.log('debug', 'Fetching archetypes from database', {
+      combinationString,
+      gender,
+      language,
+    });
+    const archetypes = await this.fetchArchetypesFromDB(
       combinationString,
-      gender
+      gender,
+      language
     );
+    await this.log('info', 'Fetched archetypes', {
+      archetypesCount: archetypes.length,
+      archetypeIds: archetypes.map((a) => a.id),
+    });
 
-    if (archetypes.some((arc) => arc.status === 'generating')) {
-      console.log(
-        `Archetypes are already being processed for ${combinationString}, gender: ${gender}`
+    // 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),
+          eq(schema.generations.conceptCombinationId, combinationString)
+        )
+      )
+      .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),
+        }
       );
       return { message: 'Images are being processed, please try again later.' };
     }
+    await this.log('info', 'No in-progress image generations found', {
+      combinationString,
+      gender,
+    });
 
-    if (archetypes.some((arc) => !arc.name || arc.images.length < 3)) {
-      console.log(
-        `Generating missing basic info for: ${combinationString}, gender: ${gender}`
-      );
-      await this.archetypeService.generateBasicInfo(combinationString);
+    // Step 1: 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', {
+        combinationString,
+        gender,
+        language,
+        archetypesNeedingTextCount: archetypesNeedingText.length,
+        archetypeIds: archetypesNeedingText.map((a) => a.id),
+      });
+      await this.generateTextualContent(combinationString, gender, language);
+    } else {
+      await this.log('info', 'No textual content generation needed', {
+        combinationString,
+        gender,
+        language,
+      });
     }
 
-    const updatedArchetypes = await this.fetchArchetypesFromKV(
+    // Refetch archetypes after generating textual content
+    await this.log(
+      'debug',
+      'Refetching archetypes after textual content generation',
+      { combinationString, gender, language }
+    );
+    const updatedArchetypes = await this.fetchArchetypesFromDB(
       combinationString,
-      gender
+      gender,
+      language
     );
+    await this.log('info', 'Refetched archetypes', {
+      updatedArchetypesCount: updatedArchetypes.length,
+      archetypeIds: updatedArchetypes.map((a) => a.id),
+    });
 
-    if (updatedArchetypes.some((arc) => !arc.leonardoPrompt)) {
-      console.log('Generating missing Leonardo prompts...');
-      await this.leonardoService.processArchetypesPrompts(combinationString);
-    }
-
+    // Step 2: Queue image generation if needed
     const archetypesNeedingImages = updatedArchetypes.filter(
-      (arc) => arc.images.length < 3
+      (arc) => JSON.parse(arc.images).length < 3
     );
 
     if (archetypesNeedingImages.length > 0) {
-      console.log('Queuing image generation for missing archetypes...');
-      await this.updateArchetypeStatus(updatedArchetypes, 'generating', gender);
+      await this.log(
+        'info',
+        'Queuing image generation for missing archetypes',
+        {
+          archetypesNeedingImagesCount: archetypesNeedingImages.length,
+          archetypeIds: archetypesNeedingImages.map((a) => a.id),
+        }
+      );
 
-      try {
-        await this.leonardoService.queueImagesForArchetypes(
-          combinationString,
-          gender
-        );
-      } catch (error) {
-        console.error('Error queuing image generation:', error);
-        await this.updateArchetypeStatus(updatedArchetypes, 'idle', gender);
-        throw error;
-      }
+      // Queue image generation for all archetypes needing images
+      const batch = archetypesNeedingImages.map((arc) => ({
+        body: {
+          archetypeDataId: arc.id,
+          combination: combinationString,
+          gender,
+          language,
+          archetypeIndex: arc.archetypeIndex,
+        },
+      }));
+      await this.log('debug', 'Sending batch to ARCHETYPE_POPULATION_QUEUE', {
+        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.' };
     }
 
-    await this.updateArchetypeStatus(updatedArchetypes, 'idle', gender);
-
-    console.log('Archetypes fully processed and ready:', updatedArchetypes);
+    await this.log('info', 'Archetypes fully processed and ready', {
+      updatedArchetypes,
+    });
     return {
       archetypes: updatedArchetypes.map(
-        ({ name, content, description, virtues, images }) => ({
+        ({ name, essenceLine, description, virtues, images }) => ({
           name,
-          content,
+          essenceLine,
           description,
-          virtues,
-          images,
+          virtues: JSON.parse(virtues),
+          images: JSON.parse(images),
         })
       ),
     };
   }
 
-  async generateNames({
-    combinations,
-    overrideExisting,
-  }: {
-    combinations: string[];
-    overrideExisting?: boolean;
-  }): Promise<void> {
-    if (combinations.length === 0) return;
-
-    if (combinations.length === 1) {
-      await this.archetypeService.generateArchetypeNames(
-        combinations[0],
-        overrideExisting
+  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 }
       );
-    } else {
-      const entries = combinations.map((combination) => ({
-        combination,
-      }));
 
-      await this.archetypeService.generateArchetypeNamesBatch(
-        entries,
-        overrideExisting
+      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,
+      });
     }
-  }
 
-  /**
-   * Fetch all three archetypes from KV for a given combination and gender.
-   */
-  private async fetchArchetypesFromKV(
-    combinationString: string,
-    gender: Gender
-  ): Promise<KVArchetype[]> {
-    return Promise.all(
-      Array.from({ length: 3 }, (_, i) => i + 1).map(async (index) => {
-        const kvKey = buildCosmicMirrorArchetypeKVKey(
-          'en-us',
-          combinationString,
-          gender,
-          index
+    // 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,
+          }
         );
-        console.log(`Fetching archetype from KV: ${kvKey}`);
 
-        try {
-          return (
-            (await this.context
-              .kvCosmicMirrorArchetypesStore()
-              .get<KVArchetype>(kvKey, 'json')) || this.createEmptyArchetype()
+        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 }
           );
-        } catch (error) {
-          console.error(
-            `Error fetching archetype KV for index ${index}:`,
-            error
+        } 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 }
           );
-          return this.createEmptyArchetype();
+        } 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;
   }
 
-  /**
-   * Update the status of archetypes in KV.
-   */
-  private async updateArchetypeStatus(
-    archetypes: KVArchetype[],
-    status: 'idle' | 'generating',
-    gender: Gender
-  ): Promise<void> {
-    await Promise.all(
-      archetypes.map(async (archetype, index) => {
-        const kvKey = buildCosmicMirrorArchetypeKVKey(
-          'en-us',
-          archetype.name,
-          gender,
-          index + 1
+  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] }
         );
-        archetype.status = status;
-        await this.context
-          .kvCosmicMirrorArchetypesStore()
-          .put(kvKey, JSON.stringify(archetype));
-      })
-    );
+      }
+
+      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;
   }
 
-  /**
-   * Create an empty KVArchetype object when KV data is missing.
-   */
-  private createEmptyArchetype(): KVArchetype {
-    return {
-      name: '',
-      description: '',
-      content: '',
-      leonardoPrompt: '',
-      visualDescription: '',
-      virtues: [],
-      images: [],
-      status: 'idle',
-    };
+  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;
   }
 }