@zodic/shared 0.0.315 → 0.0.317

package/app/services/ArchetypeService.ts

@@ -1,431 +1,103 @@
-import { and, eq, sql } from 'drizzle-orm';
+import { and, eq } from 'drizzle-orm';
 import { inject, injectable } from 'inversify';
-import { ChatMessages, Composition, schema } from '../..';
-import { KVArchetype, ZodiacSignSlug } from '../../types/scopes/legacy';
+import { ChatMessages, schema } from '../..';
+import { Gender } from '../../types';
+import { ZodiacSignSlug } from '../../types/scopes/legacy';
 import { generateArchetypePrompt } from '../../utils/archetypeNamesMessages';
-import { duplicatedArchetypeNamePrompt } from '../../utils/duplicatedArchetypeNamePrompt';
-import { buildCosmicMirrorArchetypeKVKey } from '../../utils/KVKeysBuilders';
 import { AppContext } from '../base';
 
+interface ParsedDescriptionAndVirtues {
+  descriptionEN: string;
+  descriptionPTM: string;
+  descriptionPTF: string;
+  virtuesEN: string[];
+  virtuesPT: string[];
+}
+
+interface LeonardoPrompt {
+  malePrompt: string;
+  femalePrompt: string;
+}
+
 @injectable()
 export class ArchetypeService {
   constructor(@inject(AppContext) private context: AppContext) {}
 
-  async generateBasicInfo(combinationString: string): Promise<void> {
-    console.log(
-      `Generating basic info for archetypes of combination: ${combinationString}`
-    );
-
-    const [sun, ascendant, moon] = combinationString.split('-');
-
-    const messages = this.context
-      .buildLLMMessages()
-      .generateCosmicMirrorArchetypeBasicInfo({ sun, ascendant, moon });
-
-    const response = await this.context.api().callChatGPT.single(messages, {});
-
-    if (!response) {
-      throw new Error(
-        `Failed to generate basic info for archetypes: ${combinationString}`
-      );
-    }
-
-    const archetypes = this.parseArchetypeResponse(response);
-
-    await Promise.all(
-      archetypes.map(async (archetype, index) => {
-        const archetypeIndex = index + 1;
-
-        const maleKey = buildCosmicMirrorArchetypeKVKey(
-          'en-us',
-          combinationString,
-          'male',
-          archetypeIndex
-        );
-        const femaleKey = buildCosmicMirrorArchetypeKVKey(
-          'en-us',
-          combinationString,
-          'female',
-          archetypeIndex
-        );
-        const nonBinaryKey = buildCosmicMirrorArchetypeKVKey(
-          'en-us',
-          combinationString,
-          'non-binary',
-          archetypeIndex
-        );
-
-        const kvDataMale: KVArchetype = {
-          name: archetype.name,
-          description: archetype.descriptionMale,
-          visualDescription: archetype.visualRepresentation,
-          content: '',
-          leonardoPrompt: '',
-          virtues: archetype.virtues,
-          images: [],
-          status: 'idle',
-        };
-
-        const kvDataFemale: KVArchetype = {
-          name: archetype.name,
-          description: archetype.descriptionFemale,
-          visualDescription: archetype.visualRepresentation,
-          content: '',
-          leonardoPrompt: '',
-          virtues: archetype.virtues,
-          images: [],
-          status: 'idle',
-        };
-
-        await Promise.all([
-          this.context
-            .kvCosmicMirrorArchetypesStore()
-            .put(maleKey, JSON.stringify(kvDataMale)),
-          this.context
-            .kvCosmicMirrorArchetypesStore()
-            .put(femaleKey, JSON.stringify(kvDataFemale)),
-          this.context
-            .kvCosmicMirrorArchetypesStore()
-            .put(nonBinaryKey, JSON.stringify(kvDataFemale)),
-        ]);
-      })
-    );
-
-    console.log(
-      `Basic info stored for archetypes of combination: ${combinationString}`
-    );
-  }
-
-  private parseArchetypeResponse(response: string): Array<{
-    name: string;
-    descriptionMale: string;
-    descriptionFemale: string;
-    visualRepresentation: string;
-    virtues: string[];
-  }> {
-    console.log('Parsing archetype response from ChatGPT');
-
-    const archetypes: Array<{
-      name: string;
-      descriptionMale: string;
-      descriptionFemale: string;
-      visualRepresentation: string;
-      virtues: string[];
-    }> = [];
-
-    const entries = response.split(/\n\d+\.\n/).filter(Boolean);
-
-    for (const entry of entries) {
-      const nameMatch = entry.match(/- Name: (.+)/);
-      const descriptionMaleMatch = entry.match(
-        /- Narrative Description \(Male\): (.+)/
-      );
-      const descriptionFemaleMatch = entry.match(
-        /- Narrative Description \(Female\): (.+)/
-      );
-      const visualRepresentationMatch = entry.match(
-        /- Visual Representation: (.+)/
-      );
-      const virtuesMatch = entry.match(/- Virtues: (.+)/);
-
-      if (
-        nameMatch &&
-        descriptionMaleMatch &&
-        descriptionFemaleMatch &&
-        visualRepresentationMatch &&
-        virtuesMatch
-      ) {
-        archetypes.push({
-          name: nameMatch[1].trim(),
-          descriptionMale: descriptionMaleMatch[1].trim(),
-          descriptionFemale: descriptionFemaleMatch[1].trim(),
-          visualRepresentation: visualRepresentationMatch[1].trim(),
-          virtues: virtuesMatch[1].split(',').map((virtue) => virtue.trim()),
-        });
-      }
-    }
-
-    return archetypes;
-  }
-
-  async generatePrompts(combinationString: string): Promise<void> {
-    console.log(
-      `Generating Leonardo.ai prompts for archetypes of: ${combinationString}`
-    );
-
-    const kvStore = this.context.kvCosmicMirrorArchetypesStore();
-
-    const kvKeys = [1, 2, 3].map((index) =>
-      buildCosmicMirrorArchetypeKVKey('en-us', combinationString, 'male', index)
-    );
-
-    const archetypeEntries = await Promise.all(
-      kvKeys.map((key) => kvStore.get<KVArchetype>(key))
-    );
-
-    if (archetypeEntries.some((entry) => !entry)) {
-      throw new Error(
-        `Missing archetype data for combination: ${combinationString}`
-      );
-    }
-
-    const messages = this.context
-      .buildLLMMessages()
-      .generateCosmicMirrorArchetypesLeonardoPrompts(
-        archetypeEntries.map((entry) => ({
-          name: entry!.name,
-          visualDescription: entry!.visualDescription, // Using visual description for prompt
-        }))
-      );
-
-    const response = await this.context.api().callChatGPT.single(messages, {});
-    if (!response) {
-      throw new Error(
-        `Failed to generate Leonardo prompts for: ${combinationString}`
-      );
-    }
-
-    const parsedPrompts = this.parseLeonardoPromptResponse(response);
-
-    await Promise.all(
-      parsedPrompts.map(async (promptData, index) => {
-        const archetypeIndex = index + 1;
-
-        const maleKey = buildCosmicMirrorArchetypeKVKey(
-          'en-us',
-          combinationString,
-          'male',
-          archetypeIndex
-        );
-        const femaleKey = buildCosmicMirrorArchetypeKVKey(
-          'en-us',
-          combinationString,
-          'female',
-          archetypeIndex
-        );
-        const nonBinaryKey = buildCosmicMirrorArchetypeKVKey(
-          'en-us',
-          combinationString,
-          'non-binary',
-          archetypeIndex
-        );
-
-        const updateKV = async (key: string, updatedPrompt: string) => {
-          const existingEntry = await kvStore.get<KVArchetype>(key);
-          if (existingEntry) {
-            await kvStore.put(
-              key,
-              JSON.stringify({
-                ...existingEntry,
-                leonardoPrompt: updatedPrompt,
-              })
-            );
-          }
-        };
-
-        await Promise.all([
-          updateKV(maleKey, promptData.malePrompt),
-          updateKV(femaleKey, promptData.femalePrompt),
-          updateKV(nonBinaryKey, promptData.nonBinaryPrompt),
-        ]);
-      })
-    );
-
-    console.log(
-      `Leonardo prompts stored for archetypes of: ${combinationString}`
-    );
-  }
-
-  private parseLeonardoPromptResponse(response: string): Array<{
-    malePrompt: string;
-    femalePrompt: string;
-    nonBinaryPrompt: string;
-  }> {
-    console.log('Parsing Leonardo prompt response from ChatGPT');
-
-    const parsedPrompts: Array<{
-      malePrompt: string;
-      femalePrompt: string;
-      nonBinaryPrompt: string;
-    }> = [];
-
-    const entries = response.split(/\n\d+\.\w{1,2}\n/).filter(Boolean);
-
-    for (let i = 0; i < entries.length; i += 3) {
-      const malePrompt = entries[i]?.trim();
-      const femalePrompt = entries[i + 1]?.trim();
-      const nonBinaryPrompt = entries[i + 2]?.trim();
+  private async log(
+    level: 'info' | 'debug' | 'warn' | 'error',
+    message: string,
+    context: Record<string, any> = {}
+  ) {
+    const logId = `archetype-service:${Date.now()}`;
+    const logMessage = `[${level.toUpperCase()}] ${message}`;
 
-      if (malePrompt && femalePrompt && nonBinaryPrompt) {
-        parsedPrompts.push({ malePrompt, femalePrompt, nonBinaryPrompt });
-      }
+    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,
+      });
     }
-
-    return parsedPrompts;
-  }
-
-  async generateImages(combinationString: string): Promise<void> {
-    const kvBaseKey = `archetypes:${combinationString}`;
-    console.log(
-      `Generating images for archetypes of combination: ${combinationString}`
-    );
-
-    await Promise.all(
-      [1, 2, 3].map(async (index) => {
-        const kvKey = `${kvBaseKey}:${index}`;
-        const archetype = await this.context
-          .kvCosmicMirrorArchetypesStore()
-          .get<KVArchetype>(kvKey, 'json');
-        if (!archetype || !archetype.leonardoPrompt) {
-          throw new Error(
-            `Missing Leonardo prompt for archetype ${index} of combination: ${combinationString}`
-          );
-        }
-        // Add image generation logic
-      })
-    );
   }
 
+  // Replace generateArchetypeNames and generateArchetypeNamesBatch
   async generateArchetypeNames(
-    combination: string,
+    combinationString: string,
     overrideExisting: boolean = false,
-    indexesToGenerate?: number[]
+    indexesToGenerate: number[] = [1, 2, 3]
   ) {
-    const db = this.context.drizzle();
-    console.log(
-      `🚀 [Single] Starting generation for combination: ${combination} | Override: ${overrideExisting}`
-    );
+    await this.log('info', 'Starting generateArchetypeNames', {
+      combinationString,
+      overrideExisting,
+      indexesToGenerate,
+    });
 
-    const [sun, ascendant, moon] = combination.split('-') as ZodiacSignSlug[];
+    const [sun, ascendant, moon] = combinationString.split(
+      '-'
+    ) as ZodiacSignSlug[];
     const prompt = generateArchetypePrompt([
-      {
-        sun,
-        ascendant,
-        moon,
-        indexesToGenerate: indexesToGenerate ?? [1, 2, 3],
-      },
+      { sun, ascendant, moon, indexesToGenerate },
     ]);
     const messages: ChatMessages = [{ role: 'user', content: prompt }];
-    const response = await this.context.api().callTogether.single(messages, {});
 
+    await this.log('debug', 'Calling API to generate archetype names', {
+      messages,
+    });
+    const response = await this.context.api().callTogether.single(messages, {});
     if (!response) {
-      console.error(`❌ [Single] No response for: ${combination}`);
-      return;
+      await this.log('error', 'No response for archetype names generation', {
+        combinationString,
+      });
+      throw new Error(
+        `Failed to generate archetype names for: ${combinationString}`
+      );
     }
+    await this.log('info', 'Received archetype names response', {
+      responseLength: response.length,
+    });
 
     const { english: englishNames, portuguese: portugueseVariants } =
       this.parseArchetypeNameBlocks(response);
-
-    async function isEnglishNameDuplicate(name: string): Promise<boolean> {
-      const result = await db
-        .select({ name: schema.archetypesData.name })
-        .from(schema.archetypesData)
-        .where(
-          and(
-            eq(schema.archetypesData.language, 'en-us'),
-            eq(schema.archetypesData.name, name)
-          )
-        )
-        .limit(1)
-        .execute();
-
-      return result.length > 0;
-    }
-
-    await Promise.all(
-      englishNames.map(async (entry, i) => {
-        const index = (i + 1).toString();
-        const ptVariant = portugueseVariants[i];
-
-        if (await isEnglishNameDuplicate(entry.name)) {
-          console.warn(`⚠️ [Single] Duplicate name skipped: ${entry.name}`);
-          return;
-        }
-
-        for (const gender of ['male', 'female']) {
-          const enId = `${combination}:${gender}:${index}`;
-          const ptId = `${combination}:${gender}:${index}:pt`;
-          const ptName = gender === 'female' ? ptVariant.fem : ptVariant.masc;
-
-          await db
-            .insert(schema.archetypesData)
-            .values({
-              id: enId,
-              combination,
-              gender,
-              archetypeIndex: index,
-              language: 'en-us',
-              name: entry.name,
-              essenceLine: entry.essenceLine,
-              status: 'idle',
-            })
-            .onConflictDoUpdate({
-              target: [schema.archetypesData.id],
-              set: {
-                name: entry.name,
-                essenceLine: entry.essenceLine,
-                updatedAt: new Date().getTime(),
-              },
-            });
-
-          await db
-            .insert(schema.archetypesData)
-            .values({
-              id: ptId,
-              combination,
-              gender,
-              archetypeIndex: index,
-              language: 'pt-br',
-              name: ptName,
-              essenceLine: ptVariant.essenceLine,
-              status: 'idle',
-            })
-            .onConflictDoUpdate({
-              target: [schema.archetypesData.id],
-              set: {
-                name: ptName,
-                essenceLine: ptVariant.essenceLine,
-                updatedAt: new Date().getTime(),
-              },
-            });
-
-          console.log(
-            `✅ [Single] Saved archetype ${index} (${gender}) for ${combination}`
-          );
-        }
-      })
-    );
-
-    console.log(`🏁 [Single] Done generating names for ${combination}`);
-  }
-
-  async generateArchetypeNamesBatch(
-    entries: Array<{ combination: string }>,
-    overrideExisting: boolean = false
-  ) {
-    const db = this.context.drizzle();
-    console.log(
-      `🚀 [Batch] Starting generation for ${entries.length} combinations | Override: ${overrideExisting}`
-    );
-
-    const prompts = entries.map(({ combination }) => {
-      const [sun, ascendant, moon] = combination.split('-') as ZodiacSignSlug[];
-      return { sun, ascendant, moon };
+    await this.log('debug', 'Parsed archetype names', {
+      englishNames,
+      portugueseVariants,
     });
 
-    const prompt = generateArchetypePrompt(prompts);
-    const messages: ChatMessages = [{ role: 'user', content: prompt }];
-    const response = await this.context.api().callTogether.single(messages, {});
-
-    if (!response) {
-      console.error(`❌ [Batch] No response from model`);
-      return;
-    }
-
-    const blocks = response
-      .split(/Composition \d+/)
-      .slice(1)
-      .map((b) => b.trim());
+    const db = this.context.drizzle();
 
     async function isEnglishNameDuplicate(name: string): Promise<boolean> {
       const result = await db
@@ -439,967 +111,861 @@ export class ArchetypeService {
         )
         .limit(1)
         .execute();
-
       return result.length > 0;
     }
 
-    for (let i = 0; i < entries.length; i++) {
-      const { combination } = entries[i];
-      const block = blocks[i];
-      console.log(`📦 [Batch] Processing: ${combination}`);
-
-      const { english, portuguese } = this.parseArchetypeNameBlocks(block);
+    for (let i = 0; i < englishNames.length; i++) {
+      const index = (i + 1).toString();
+      const entry = englishNames[i];
+      const ptVariant = portugueseVariants[i];
 
-      // Check if parsing produced the expected number of entries
-      if (english.length !== 3 || portuguese.length !== 3) {
-        console.error(
-          `[Batch] Parsing failed for ${combination}. Expected 3 entries, got English: ${english.length}, Portuguese: ${portuguese.length}`
+      if (!indexesToGenerate.includes(parseInt(index))) {
+        await this.log(
+          'debug',
+          `Skipping index ${index} as it is not in indexesToGenerate`,
+          { index, indexesToGenerate }
         );
-        continue; // Skip this combination if parsing failed
+        continue;
       }
 
-      for (let j = 0; j < 3; j++) {
-        const index = (j + 1).toString();
-        const englishEntry = english[j];
-        const ptEntry = portuguese[j];
-
-        // Skip if either entry is missing (shouldn't happen with the above check, but added for safety)
-        if (!englishEntry || !ptEntry) {
-          console.warn(
-            `[Batch] Skipping index ${index} for ${combination} due to missing parsed data. English: ${JSON.stringify(
-              englishEntry
-            )}, Portuguese: ${JSON.stringify(ptEntry)}`
-          );
-          continue;
-        }
-
-        // if (await isEnglishNameDuplicate(englishEntry.name)) {
-        //   console.warn(
-        //     `⚠️ [Batch] Duplicate name skipped: ${englishEntry.name}`
-        //   );
-        //   continue;
-        // }
-
-        for (const gender of ['male', 'female']) {
-          const enId = `${combination}:${gender}:${index}`;
-          const ptId = `${combination}:${gender}:${index}:pt`;
-          const ptName = gender === 'female' ? ptEntry.fem : ptEntry.masc;
+      if (await isEnglishNameDuplicate(entry.name)) {
+        await this.log('warn', `Duplicate name skipped: ${entry.name}`, {
+          combinationString,
+          index,
+        });
+        continue;
+      }
 
-          await db
-            .insert(schema.archetypesData)
-            .values({
-              id: enId,
-              combination,
-              gender,
-              archetypeIndex: index,
-              language: 'en-us',
-              name: englishEntry.name,
-              essenceLine: englishEntry.essenceLine,
-              status: 'idle',
-            })
-            .onConflictDoUpdate({
-              target: [schema.archetypesData.id],
-              set: {
-                name: englishEntry.name,
-                essenceLine: englishEntry.essenceLine,
-                updatedAt: new Date().getTime(),
-              },
-            });
+      for (const gender of ['male', 'female']) {
+        for (const lang of ['en-us', 'pt-br']) {
+          const id = `${combinationString}:${gender}:${index}${
+            lang === 'pt-br' ? ':pt' : ''
+          }`;
+          const name =
+            lang === 'en-us'
+              ? entry.name
+              : gender === 'female'
+              ? ptVariant.fem
+              : ptVariant.masc;
+          const essenceLine =
+            lang === 'en-us' ? entry.essenceLine : ptVariant.essenceLine;
+
+          await this.log('debug', `Saving archetype name for ${id}`, {
+            name,
+            essenceLine,
+          });
 
           await db
             .insert(schema.archetypesData)
             .values({
-              id: ptId,
-              combination,
+              id,
+              combination: combinationString,
               gender,
               archetypeIndex: index,
-              language: 'pt-br',
-              name: ptName,
-              essenceLine: ptEntry.essenceLine,
+              language: lang,
+              name,
+              essenceLine,
               status: 'idle',
             })
             .onConflictDoUpdate({
               target: [schema.archetypesData.id],
               set: {
-                name: ptName,
-                essenceLine: ptEntry.essenceLine,
+                name,
+                essenceLine,
                 updatedAt: new Date().getTime(),
               },
             });
 
-          console.log(
-            `✅ [Batch] Saved archetype ${index} (${gender}) for ${combination}`
+          await this.log(
+            'info',
+            `Saved archetype ${index} (${gender}, ${lang}) for ${combinationString}`
           );
         }
       }
-
-      console.log(`🏁 [Batch] Finished combination: ${combination}`);
-    }
-
-    console.log(
-      `🎉 [Batch] Completed processing for all ${entries.length} combinations`
-    );
-  }
-
-  async findIncompleteCombinations(): Promise<
-    Array<{ combination: string; count: number }>
-  > {
-    const db = this.context.drizzle();
-
-    const result = await db
-      .select({
-        combination: schema.archetypesData.combination,
-        count: sql<number>`count(*)`.as('count'),
-      })
-      .from(schema.archetypesData)
-      .groupBy(schema.archetypesData.combination)
-      .having(sql`count(*) < 12`)
-      .limit(400)
-      .execute();
-
-    const typedResult = result.map((row) => ({
-      combination: row.combination,
-      count: Number(row.count),
-    }));
-
-    console.log(`🔍 Found ${typedResult.length} incomplete combinations`);
-    return typedResult;
-  }
-
-  async regenerateMissingArchetypeNames(overrideExisting: boolean = false) {
-    const incomplete = await this.findIncompleteCombinations();
-    console.log(
-      `🔁 Starting regeneration for ${incomplete.length} combinations`
-    );
-
-    for (const { combination, count } of incomplete) {
-      const indexesToGenerate: number[] = [];
-
-      const db = this.context.drizzle();
-      const existing = await db
-        .select({
-          archetypeIndex: schema.archetypesData.archetypeIndex,
-          language: schema.archetypesData.language,
-          gender: schema.archetypesData.gender,
-        })
-        .from(schema.archetypesData)
-        .where(eq(schema.archetypesData.combination, combination))
-        .execute();
-
-      for (let i = 1; i <= 3; i++) {
-        const hasAll =
-          existing.filter((e) => e.archetypeIndex === i.toString()).length ===
-          4;
-        if (!hasAll) indexesToGenerate.push(i);
-      }
-
-      if (indexesToGenerate.length > 0) {
-        console.log(
-          `🧩 Regenerating indexes ${indexesToGenerate.join(
-            ','
-          )} for ${combination}`
-        );
-        await this.generateArchetypeNames(
-          combination,
-          overrideExisting,
-          indexesToGenerate
-        );
-      }
     }
 
-    console.log(`✅ Done regenerating missing archetype names`);
+    await this.log('info', 'Completed generateArchetypeNames', {
+      combinationString,
+    });
   }
 
-  async regenerateMissingArchetypeNamesBatch(compositions: Composition[]) {
-    if (compositions.length === 0) {
-      console.log('✅ [Batch] No combinations provided for regeneration');
-      return;
-    }
-
-    console.log(
-      `🔁 [Batch] Starting regeneration for ${compositions.length} combinations`
-    );
-
-    const prompt = generateArchetypePrompt(compositions);
-    const messages: ChatMessages = [{ role: 'user', content: prompt }];
-    const response = await this.context.api().callTogether.single(messages, {});
-
-    if (!response) {
-      console.error(`❌ [Batch] No response from model during regeneration`);
-      return;
-    }
-
-    // Clean up the response by removing unexpected suffixes
-    const cleanedResponse = response
-      .replace(/###|---\s*###|-\s*###/g, '')
-      .trim();
-
-    const blocks = cleanedResponse
-      .split(/Composition \d+/)
-      .slice(1)
-      .map((b) => b.trim());
+  private parseArchetypeNameBlocks(response: string): {
+    english: Array<{ name: string; essenceLine: string }>;
+    portuguese: Array<{ masc: string; fem: string; essenceLine: string }>;
+  } {
+    this.log('debug', 'Starting parseArchetypeNameBlocks', {
+      responseLength: response.length,
+    });
 
-    for (let i = 0; i < compositions.length; i++) {
-      const comp = compositions[i];
-      const combination = [comp.sun, comp.ascendant, comp.moon].join('-');
-      const block = blocks[i];
-      const indexes = comp.indexesToGenerate ?? [1, 2, 3];
+    const blocks = response.split(/\n\d+\.\n/).filter(Boolean);
+    this.log('debug', 'Split response into blocks', {
+      blocksCount: blocks.length,
+    });
 
-      console.log(`🔄 [Batch] Processing: ${combination}`);
+    const english: Array<{ name: string; essenceLine: string }> = [];
+    const portuguese: Array<{
+      masc: string;
+      fem: string;
+      essenceLine: string;
+    }> = [];
 
-      const { english, portuguese } = this.parseArchetypeNameBlocks(block);
+    for (const block of blocks) {
+      const nameMatch = block.match(/- Name: (.+)/);
+      const essenceLineMatch = block.match(/- Essence Line: (.+)/);
+      const ptMascMatch = block.match(/- Portuguese \(Masc\): (.+)/);
+      const ptFemMatch = block.match(/- Portuguese \(Fem\): (.+)/);
+      const ptEssenceLineMatch = block.match(/- Portuguese Essence Line: (.+)/);
 
       if (
-        english.length !== indexes.length ||
-        portuguese.length !== indexes.length
+        nameMatch &&
+        essenceLineMatch &&
+        ptMascMatch &&
+        ptFemMatch &&
+        ptEssenceLineMatch
       ) {
-        console.error(`❌ [Batch] Parsing failed for: ${combination}`);
-        await this.context
-          .drizzle()
-          .insert(schema.archetypeNameDumps)
-          .values({
-            id: `${combination}:${Date.now()}`,
-            combination,
-            rawText: block,
-            parsedSuccessfully: 0,
-            createdAt: Date.now(),
-          });
-        continue;
-      }
-
-      for (const index of indexes) {
-        const idx = index - 1;
-        const englishEntry = english[idx];
-        const ptEntry = portuguese[idx];
-
-        if (!englishEntry || !ptEntry) {
-          await this.context
-            .drizzle()
-            .insert(schema.archetypeNameDumps)
-            .values({
-              id: `${combination}:${index}:${Date.now()}`,
-              combination,
-              rawText: block,
-              parsedSuccessfully: 0,
-              createdAt: Date.now(),
-            });
-          console.warn(
-            `⚠️ [Batch] Skipping index ${index} for ${combination} due to missing parsed block`
-          );
-          continue;
-        }
-
-        for (const gender of ['male', 'female']) {
-          const enId = `${combination}:${gender}:${index}`;
-          const ptId = `${combination}:${gender}:${index}:pt`;
-          const ptName = gender === 'female' ? ptEntry.fem : ptEntry.masc;
-
-          await this.context
-            .drizzle()
-            .insert(schema.archetypesData)
-            .values({
-              id: enId,
-              combination,
-              gender,
-              archetypeIndex: index.toString(),
-              language: 'en-us',
-              name: englishEntry.name,
-              essenceLine: englishEntry.essenceLine,
-              status: 'idle',
-            })
-            .onConflictDoUpdate({
-              target: [schema.archetypesData.id],
-              set: {
-                name: englishEntry.name,
-                essenceLine: englishEntry.essenceLine,
-                updatedAt: new Date().getTime(),
-              },
-            });
-
-          await this.context
-            .drizzle()
-            .insert(schema.archetypesData)
-            .values({
-              id: ptId,
-              combination,
-              gender,
-              archetypeIndex: index.toString(),
-              language: 'pt-br',
-              name: ptName,
-              essenceLine: ptEntry.essenceLine,
-              status: 'idle',
-            })
-            .onConflictDoUpdate({
-              target: [schema.archetypesData.id],
-              set: {
-                name: ptName,
-                essenceLine: ptEntry.essenceLine,
-                updatedAt: new Date().getTime(),
-              },
-            });
-
-          console.log(
-            `✅ [Batch] Saved archetype ${index} (${gender}) for ${combination}`
-          );
-        }
+        english.push({
+          name: nameMatch[1].trim(),
+          essenceLine: essenceLineMatch[1].trim(),
+        });
+        portuguese.push({
+          masc: ptMascMatch[1].trim(),
+          fem: ptFemMatch[1].trim(),
+          essenceLine: ptEssenceLineMatch[1].trim(),
+        });
+      } else {
+        this.log('warn', 'Malformed archetype name block', { block });
       }
-
-      console.log(`🏁 [Batch] Finished combination: ${combination}`);
     }
 
-    console.log(
-      `🎉 [Batch] Completed regenerating ${compositions.length} combinations`
-    );
+    this.log('info', 'Completed parseArchetypeNameBlocks', {
+      english,
+      portuguese,
+    });
+    return { english, portuguese };
   }
 
-  async regenerateDuplicateArchetypeNamesBatch(
-    entriesByCombination: Record<string, any[]>
+  async generateDescriptionsAndVirtues(
+    combinationString: string,
+    gender: Gender,
+    language: string
   ) {
+    await this.log('info', 'Starting generateDescriptionsAndVirtues', {
+      combinationString,
+      gender,
+      language,
+    });
+  
     const db = this.context.drizzle();
-    console.log(
-      `[RegenerateDuplicatesBatch] Processing batch with ${
-        Object.keys(entriesByCombination).length
-      } combinations`
-    );
-
-    // Process each combination in the batch
-    for (const [combination, entries] of Object.entries(entriesByCombination)) {
-      console.log(
-        `[RegenerateDuplicatesBatch] Processing combination: ${combination}`
+    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 archetypes for description generation', {
+      archetypesCount: archetypes.length,
+      names: archetypes.map((a) => a.name),
+    });
+  
+    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 descriptions and virtues', {
+      messages: descVirtueMessages,
+    });
+    const descVirtueResponse = await this.context
+      .api()
+      .callTogether.single(descVirtueMessages, {});
+    if (!descVirtueResponse) {
+      await this.log('error', 'No response for descriptions and virtues', {
+        combinationString,
+      });
+      throw new Error(
+        `Failed to generate descriptions and virtues for: ${combinationString}`
       );
-
-      // Fetch all existing English names for this combination (across all archetypeIndex, gender, language)
-      const existingNamesResult = await db
-        .selectDistinct({ name: schema.archetypesData.name })
-        .from(schema.archetypesData)
+    }
+    await this.log('info', 'Received descriptions and virtues response', {
+      responseLength: descVirtueResponse.length,
+    });
+  
+    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}`, {
+        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.combination, combination),
+            eq(schema.archetypesData.id, enId),
             eq(schema.archetypesData.language, 'en-us')
           )
         )
         .execute();
+      await this.log('info', `Updated description and virtues for ${enId}`);
+  
+      // Update Portuguese entries (pt-br) 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 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,
+      });
+      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', {
+      combinationString,
+      gender,
+      language,
+    });
+    return parsedDescVirtues;
+  }
 
-      let existingNames = existingNamesResult.map((r) => r.name);
-      console.log(
-        `[RegenerateDuplicatesBatch] Existing names for ${combination}: ${existingNames.join(
-          ', '
-        )}`
-      );
-
-      // Process each entry with the duplicate name in this combination
-      for (const entry of entries) {
-        const { archetypeIndex, essenceLine } = entry;
-        console.log(
-          `[RegenerateDuplicatesBatch] Regenerating name for ${combination} (archetypeIndex: ${archetypeIndex})`
-        );
-
-        let newName: {
-          name_en: string;
-          name_pt_male: string;
-          name_pt_female: string;
-        } | null = null;
-        let attempts = 0;
-        const maxAttempts = 5;
-
-        // Generate a new name until a unique one is found
-        while (attempts < maxAttempts) {
-          attempts++;
-          console.log(
-            `[RegenerateDuplicatesBatch] Attempt ${attempts} to generate a new name for ${combination} (archetypeIndex: ${archetypeIndex})`
-          );
-
-          // Build the prompt
-          const prompt = duplicatedArchetypeNamePrompt({
-            combination,
-            essenceLine: essenceLine || 'A unique and meaningful archetype', // Fallback for null essenceLine
-            existingNames,
-          });
-
-          // Send the request to the AI
-          const messages: ChatMessages = [{ role: 'user', content: prompt }];
-          const response = await this.context
-            .api()
-            .callTogether.single(messages, {});
-
-          if (!response) {
-            console.error(
-              `[RegenerateDuplicatesBatch] No response from model for ${combination} (archetypeIndex: ${archetypeIndex})`
-            );
-            continue;
-          }
-
-          // Parse the response
-          try {
-            newName = JSON.parse(response);
-            console.log(
-              `[RegenerateDuplicatesBatch] Generated new name: ${JSON.stringify(
-                newName,
-                null,
-                2
-              )}`
-            );
-
-            // Validate the response format
-            if (
-              !newName ||
-              !newName.name_en ||
-              !newName.name_pt_male ||
-              !newName.name_pt_female
-            ) {
-              console.error(
-                `[RegenerateDuplicatesBatch] Invalid response format for ${combination} (archetypeIndex: ${archetypeIndex}): ${response}`
-              );
-              newName = null;
-              continue;
-            }
-          } catch (error) {
-            console.error(
-              `[RegenerateDuplicatesBatch] Failed to parse AI response for ${combination} (archetypeIndex: ${archetypeIndex}): ${response}`,
-              error
-            );
-            continue;
-          }
-
-          // Check if the new name is unique (globally across all combinations)
-          const isDuplicate = await db
-            .select({ name: schema.archetypesData.name })
-            .from(schema.archetypesData)
-            .where(
-              and(
-                eq(schema.archetypesData.language, 'en-us'),
-                eq(schema.archetypesData.name, newName.name_en)
-              )
-            )
-            .limit(1)
-            .execute();
-
-          if (isDuplicate.length > 0) {
-            console.warn(
-              `[RegenerateDuplicatesBatch] Generated name "${newName.name_en}" is already used. Adding to existing names and retrying.`
-            );
-            existingNames.push(newName.name_en);
-            newName = null;
-            continue;
-          }
-
-          // If we reach here, the name is unique
-          break;
-        }
 
-        if (!newName) {
-          console.error(
-            `[RegenerateDuplicatesBatch] Failed to generate a unique name for ${combination} (archetypeIndex: ${archetypeIndex}) after ${maxAttempts} attempts`
-          );
-          continue;
+  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}`);
+    }
+  
+    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);
+      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.')) {
+          continue; // Skip entry number lines
         }
-
-        // Update the database with the new names
-        for (const gender of ['male', 'female']) {
-          const enId = `${combination}:${gender}:${archetypeIndex}`;
-          const ptId = `${combination}:${gender}:${archetypeIndex}:pt`;
-
-          // Update English entry
-          await db
-            .update(schema.archetypesData)
-            .set({
-              name: newName.name_en,
-              updatedAt: new Date().getTime(),
-            })
-            .where(
-              and(
-                eq(schema.archetypesData.id, enId),
-                eq(schema.archetypesData.language, 'en-us')
-              )
-            )
-            .execute();
-
-          // Update Portuguese entry
-          const ptName =
-            gender === 'female' ? newName.name_pt_female : newName.name_pt_male;
-          await db
-            .update(schema.archetypesData)
-            .set({
-              name: ptName,
-              updatedAt: new Date().getTime(),
-            })
-            .where(
-              and(
-                eq(schema.archetypesData.id, ptId),
-                eq(schema.archetypesData.language, 'pt-br')
-              )
-            )
-            .execute();
-
-          console.log(
-            `[RegenerateDuplicatesBatch] Updated ${combination} (archetypeIndex: ${archetypeIndex}, gender: ${gender}) with new name - English: ${newName.name_en}, Portuguese: ${ptName}`
-          );
+  
+        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 EN:')) {
+          currentField = 'virtuesEN';
+          virtuesEN = line
+            .split('• Virtues EN:')[1]
+            ?.split(',')
+            .map((v) => v.trim())
+            .filter((v) => v)
+            .slice(0, 3);
+          this.log('debug', `Extracted virtuesEN for entry ${entryIndex + 1}`, { virtuesEN });
+        } else if (line.startsWith('• Virtues PT:')) {
+          currentField = 'virtuesPT';
+          virtuesPT = line
+            .split('• Virtues PT:')[1]
+            ?.split(',')
+            .map((v) => v.trim())
+            .filter((v) => v)
+            .slice(0, 3);
+          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';
+          virtuesEN = line
+            .split('• Virtues:')[1]
+            ?.split(',')
+            .map((v) => v.trim())
+            .filter((v) => v)
+            .slice(0, 3);
+          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',
+            Intuition: 'Intuição',
+            Grace: 'Graça',
+            // 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 });
+        } else if (currentField && !currentField.startsWith('virtues')) {
+          if (currentField === 'descriptionEN') {
+            descriptionEN += ' ' + line;
+            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 });
+          } else if (currentField === 'descriptionPTF') {
+            descriptionPTF += ' ' + line;
+            this.log('debug', `Appended to descriptionPTF for entry ${entryIndex + 1}`, { descriptionPTF });
+          }
         }
       }
-    }
-
-    console.log(`✅ [RegenerateDuplicatesBatch] Finished processing batch`);
+  
+      // 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`);
+      }
+  
+      return { descriptionEN, descriptionPTM, descriptionPTF, virtuesEN, virtuesPT };
+    });
+  
+    this.log('info', 'Completed parseDescriptionAndVirtuesResponse', { result });
+    return result;
   }
 
-  async recycleArchetypeNameDumpsBatch(
-    compositions: Composition[]
-  ): Promise<void> {
-    console.log('🔁 [Recycle] Starting recycling of archetype name dumps');
+  async generateContent(
+    combinationString: string,
+    gender: Gender,
+    language: string,
+    descriptions: Array<{ descriptionEN: string }>
+  ) {
+    await this.log('info', 'Starting generateContent', {
+      combinationString,
+      gender,
+      language,
+    });
 
-    if (compositions.length === 0) {
-      console.log('✅ [Recycle] No compositions provided for recycling');
-      return;
-    }
+    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')
+        )
+      )
+      .execute();
+
+    await this.log('info', 'Fetched archetypes for content generation', {
+      archetypesCount: archetypes.length,
+      names: archetypes.map((a) => a.name),
+    });
 
-    console.log(
-      `📦 [Recycle] Total compositions to recycle: ${compositions.length}`
-    );
+    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: descriptions[i].descriptionEN,
+        });
 
-    // Step 1: Process each composition
-    const db = this.context.drizzle();
-    for (const comp of compositions) {
-      const combination = [comp.sun, comp.ascendant, comp.moon].join('-');
-      const indexes = comp.indexesToGenerate ?? [1, 2, 3];
-
-      console.log(
-        `🔄 [Recycle] Processing combination: ${combination} with indexes: [${indexes.join(
-          ', '
-        )}]`
+      await this.log('debug', `Calling API for content of archetype ${i + 1}`, {
+        messages: contentMessages,
+      });
+      const contentResponse = await this.context
+        .api()
+        .callTogether.single(contentMessages, {});
+      if (!contentResponse) {
+        await this.log(
+          'error',
+          `No response for content of archetype ${i + 1}`,
+          { combinationString, archetype: archetypes[i].name }
+        );
+        throw new Error(
+          `Failed to generate content for archetype ${
+            i + 1
+          } of: ${combinationString}`
+        );
+      }
+      await this.log(
+        'info',
+        `Received content response for archetype ${i + 1}`,
+        { responseLength: contentResponse.length }
       );
 
-      // Fetch all dump entries for this combination
-      const dumpEntries = await db
-        .select({
-          id: schema.archetypeNameDumps.id,
-          rawText: schema.archetypeNameDumps.rawText,
-        })
-        .from(schema.archetypeNameDumps)
-        .where(eq(schema.archetypeNameDumps.combination, combination))
-        .execute();
-
-      console.log(
-        `[Recycle] Retrieved ${
-          dumpEntries.length
-        } dump entries for ${combination}: ${JSON.stringify(
-          dumpEntries,
-          null,
-          2
-        )}`
+      await this.log(
+        'debug',
+        `Parsing content response for archetype ${i + 1}`
       );
+      const parsedContent = this.parseContentResponse(contentResponse);
+      contentResults.push(parsedContent);
+      await this.log('info', `Parsed content for archetype ${i + 1}`, {
+        parsedContent,
+      });
+
+      const 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 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)
+            )
+          )
+          .execute();
 
-      if (dumpEntries.length === 0) {
-        console.log(
-          `⚠️ [Recycle] No dump entries found for combination: ${combination}`
-        );
-        continue;
+        await this.log('info', `Updated content for ${id}`);
       }
+    }
 
-      // Step 2: Process each missing index
-      for (const index of indexes) {
-        console.log(`[Recycle] Processing index ${index} for ${combination}`);
-
-        // Find a dump entry that contains the specific index
-        let rawText: string | null = null;
-        let selectedEntryId: string | null = null;
-        for (const entry of dumpEntries) {
-          if (entry.rawText && entry.rawText.includes(`-EN ${index}.`)) {
-            rawText = entry.rawText;
-            selectedEntryId = entry.id;
-            console.log(
-              `[Recycle] Selected dump entry for index ${index} with id ${selectedEntryId}: ${rawText}`
-            );
-            break;
-          }
-        }
+    await this.log('info', 'Completed generateContent', {
+      combinationString,
+      gender,
+      language,
+    });
+    return contentResults;
+  }
 
-        if (!rawText) {
-          console.log(
-            `⚠️ [Recycle] No dump entry contains index ${index} for combination: ${combination}`
-          );
-          continue;
-        }
+  private parseContentResponse(response: string) {
+    this.log('debug', 'Starting parseContentResponse', {
+      responseLength: response.length,
+    });
 
-        // Clean up the raw text
-        console.log(
-          `[Recycle] Cleaning rawText for index ${index}: ${rawText}`
-        );
-        const cleanedText = rawText
-          .replace(/###|---\s*###|-\s*###/g, '')
-          .trim();
-        console.log(
-          `[Recycle] Cleaned text for index ${index}: ${cleanedText}`
-        );
+    const sections = response
+      .split(/---/)
+      .map((block) => block.trim())
+      .filter((block) => block.length > 0);
+    this.log('debug', 'Split response into sections', {
+      sectionsCount: sections.length,
+    });
 
-        // Extract the specific index sections
-        const enSectionMatch = cleanedText.match(
-          new RegExp(`-EN ${index}\\.\\s*[^-]*(?=-EN|-PT|$)`, 's')
-        );
-        const ptSectionMatch = cleanedText.match(
-          new RegExp(`-PT ${index}\\.\\s*[^-]*(?=-EN|-PT|$)`, 's')
-        );
+    const result = sections.map((section, sectionIndex) => {
+      this.log('debug', `Processing section ${sectionIndex + 1}`, { section });
 
-        console.log(
-          `[Recycle] Extracted sections for index ${index} - enSectionMatch: ${JSON.stringify(
-            enSectionMatch
-          )}, ptSectionMatch: ${JSON.stringify(ptSectionMatch)}`
-        );
+      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 (
-          !enSectionMatch ||
-          !ptSectionMatch ||
-          !enSectionMatch[0] ||
-          !ptSectionMatch[0]
+          line.startsWith('EN:') ||
+          line.startsWith('PT-M:') ||
+          line.startsWith('PT-F:')
         ) {
-          console.log(
-            `⚠️ [Recycle] Could not extract index ${index} sections for combination: ${combination}. enSectionMatch: ${JSON.stringify(
-              enSectionMatch
-            )}, ptSectionMatch: ${JSON.stringify(ptSectionMatch)}`
+          this.log(
+            'debug',
+            `Skipping language header in section ${sectionIndex + 1}`,
+            { line }
           );
           continue;
         }
 
-        // Combine the extracted sections into a block for parsing
-        const block = `-EN\n${enSectionMatch[0]
-          .replace(/-EN\s*/, '')
-          .trim()}\n\n-PT\n${ptSectionMatch[0].replace(/-PT\s*/, '').trim()}`;
-        console.log(`[Recycle] Constructed block for index ${index}: ${block}`);
-
-        // Step 3: Parse the block
-        const { english, portuguese } = this.parseArchetypeNameBlocks(block);
-        console.log(
-          `[Recycle] Parsed results for index ${index} - English: ${JSON.stringify(
-            english,
-            null,
-            2
-          )}, Portuguese: ${JSON.stringify(portuguese, null, 2)}`
-        );
-
-        if (english.length === 0 || portuguese.length === 0) {
-          console.error(
-            `❌ [Recycle] Parsing failed for index ${index} of combination: ${combination}. Block: ${block}`
-          );
-          if (block) {
-            await this.context
-              .drizzle()
-              .insert(schema.archetypeNameDumps)
-              .values({
-                id: `${combination}:${index}:${Date.now()}`,
-                combination,
-                rawText: block,
-                parsedSuccessfully: 0,
-                createdAt: Date.now(),
-              });
-            console.log(
-              `[Recycle] Logged failed parse to archetype_name_dumps for index ${index} of ${combination}`
-            );
-          } else {
-            console.error(
-              `❌ [Recycle] Cannot log failed parse to archetype_name_dumps: block is undefined`
+        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] }
             );
           }
-          continue;
-        }
-
-        const englishEntry = english[0];
-        const ptEntry = portuguese[0];
-
-        console.log(
-          `[Recycle] Extracted entries for index ${index} - englishEntry: ${JSON.stringify(
-            englishEntry,
-            null,
-            2
-          )}, ptEntry: ${JSON.stringify(ptEntry, null, 2)}`
-        );
-
-        if (!englishEntry || !ptEntry) {
-          console.warn(
-            `⚠️ [Recycle] Skipping index ${index} for ${combination} due to missing parsed data. englishEntry: ${JSON.stringify(
-              englishEntry
-            )}, ptEntry: ${JSON.stringify(ptEntry)}`
+          currentSection = line.replace('# ', '');
+          currentText = [];
+          this.log(
+            'debug',
+            `Starting new section ${currentSection} in section ${
+              sectionIndex + 1
+            }`
           );
-          continue;
+        } else {
+          currentText.push(line);
         }
+      }
 
-        // Step 4: Insert the parsed data into archetypes_data
-        for (const gender of ['male', 'female']) {
-          const enId = `${combination}:${gender}:${index}`;
-          const ptId = `${combination}:${gender}:${index}:pt`;
-          const ptName = gender === 'female' ? ptEntry.fem : ptEntry.masc;
-
-          console.log(
-            `[Recycle] Inserting English entry for ${combination}, index ${index}, gender ${gender}: id=${enId}, name=${englishEntry.name}, essenceLine=${englishEntry.essenceLine}`
-          );
-          await this.context
-            .drizzle()
-            .insert(schema.archetypesData)
-            .values({
-              id: enId,
-              combination,
-              gender,
-              archetypeIndex: index.toString(),
-              language: 'en-us',
-              name: englishEntry.name,
-              essenceLine: englishEntry.essenceLine,
-              status: 'idle',
-            })
-            .onConflictDoUpdate({
-              target: [schema.archetypesData.id],
-              set: {
-                name: englishEntry.name,
-                essenceLine: englishEntry.essenceLine,
-                updatedAt: new Date().getTime(),
-              },
-            });
-
-          console.log(
-            `[Recycle] Inserting Portuguese entry for ${combination}, index ${index}, gender ${gender}: id=${ptId}, name=${ptName}, essenceLine=${ptEntry.essenceLine}`
-          );
-          await this.context
-            .drizzle()
-            .insert(schema.archetypesData)
-            .values({
-              id: ptId,
-              combination,
-              gender,
-              archetypeIndex: index.toString(),
-              language: 'pt-br',
-              name: ptName,
-              essenceLine: ptEntry.essenceLine,
-              status: 'idle',
-            })
-            .onConflictDoUpdate({
-              target: [schema.archetypesData.id],
-              set: {
-                name: ptName,
-                essenceLine: ptEntry.essenceLine,
-                updatedAt: new Date().getTime(),
-              },
-            });
+      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] }
+        );
+      }
 
-          // Delete the processed dump entry
-          if (selectedEntryId) {
-            console.log(
-              `[Recycle] Deleting dump entry with id ${selectedEntryId} for ${combination}, index ${index}`
-            );
-            await db
-              .delete(schema.archetypeNameDumps)
-              .where(eq(schema.archetypeNameDumps.id, selectedEntryId));
-            console.log(
-              `[Recycle] Successfully deleted dump entry with id ${selectedEntryId}`
-            );
-          } else {
-            console.warn(
-              `[Recycle] Could not delete dump entry for ${combination}, index ${index}: selectedEntryId is null`
-            );
+      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,
           }
-
-          console.log(
-            `✅ [Recycle] Saved archetype ${index} (${gender}) for ${combination}`
-          );
-        }
+        );
       }
 
-      console.log(`🏁 [Recycle] Finished combination: ${combination}`);
-    }
+      return parsedContent;
+    });
 
-    console.log(
-      `🎉 [Recycle] Completed recycling for ${compositions.length} combinations`
-    );
+    this.log('info', 'Completed parseContentResponse', { result });
+    return result;
   }
 
-  async fetchMissingArchetypeCompositions(): Promise<Composition[]> {
+  async generateLeonardoPrompts(
+    combinationString: string,
+    gender: Gender,
+    language: string,
+    descriptions: Array<{ descriptionEN: string }>
+  ) {
+    await this.log('info', 'Starting generateLeonardoPrompts', {
+      combinationString,
+      gender,
+      language,
+    });
+
     const db = this.context.drizzle();
-    const incomplete = await this.findIncompleteCombinations();
-    console.log(
-      `🔎 [Fetch] Retrieved ${incomplete.length} incomplete combinations`
-    );
-    const limited = incomplete.slice(0, 400);
-
-    const compositions: Composition[] = [];
-
-    for (const { combination } of limited) {
-      console.log(`🔍 [Fetch] Processing combination: ${combination}`);
-      const [sun, ascendant, moon] = combination.split('-') as ZodiacSignSlug[];
-
-      const existing = await db
-        .select({
-          archetypeIndex: schema.archetypesData.archetypeIndex,
-          language: schema.archetypesData.language,
-          gender: schema.archetypesData.gender,
-        })
-        .from(schema.archetypesData)
-        .where(eq(schema.archetypesData.combination, combination))
-        .execute();
+    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();
 
-      const indexesToGenerate: number[] = [];
+    await this.log('info', 'Fetched archetypes for Leonardo prompts', {
+      archetypesCount: archetypes.length,
+      names: archetypes.map((a) => a.name),
+    });
 
-      for (let i = 1; i <= 3; i++) {
-        const hasAll =
-          existing.filter((e) => e.archetypeIndex === i.toString()).length ===
-          4;
-        if (!hasAll) indexesToGenerate.push(i);
-      }
+    const promptMessages = this.context
+      .buildLLMMessages()
+      .generateCosmicMirrorArchetypeLeonardoPrompts(
+        archetypes.map((arc, idx) => ({
+          name: arc.name,
+          description: descriptions[idx].descriptionEN,
+        }))
+      );
 
-      if (indexesToGenerate.length > 0) {
-        compositions.push({
-          sun,
-          ascendant,
-          moon,
-          indexesToGenerate,
-        });
-        console.log(
-          `✅ [Fetch] Will regenerate indexes [${indexesToGenerate.join(
-            ', '
-          )}] for ${combination}`
-        );
-      }
+    await this.log('debug', 'Calling API for Leonardo prompts', {
+      messages: promptMessages,
+    });
+    const promptResponse = await this.context
+      .api()
+      .callTogether.single(promptMessages, {});
+    if (!promptResponse) {
+      await this.log('error', 'No response for Leonardo prompts', {
+        combinationString,
+      });
+      throw new Error(
+        `Failed to generate Leonardo prompts for: ${combinationString}`
+      );
     }
+    await this.log('info', 'Received Leonardo prompts response', {
+      responseLength: promptResponse.length,
+    });
 
-    console.log(
-      `📦 [Fetch] Total compositions to regenerate (limited to 400): ${compositions.length}`
-    );
+    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,
+        });
 
-    return compositions;
-  }
+        await db
+          .update(schema.archetypesData)
+          .set({
+            leonardoPrompt,
+            updatedAt: new Date().getTime(),
+          })
+          .where(
+            and(
+              eq(schema.archetypesData.id, id),
+              eq(schema.archetypesData.language, lang)
+            )
+          )
+          .execute();
 
-  parseArchetypeNameBlocks(block: string): {
-    english: any[];
-    portuguese: any[];
-  } {
-    console.log(`[Parse] Starting parsing of block: ${block}`);
-
-    // Split the block into sections based on -EN and -PT markers
-    const sections = block.split(/^-EN|^-PT/m).filter((s) => s.trim());
-    console.log(
-      `[Parse] Split block into ${sections.length} sections: ${JSON.stringify(
-        sections,
-        null,
-        2
-      )}`
-    );
-
-    const english: any[] = [];
-    const portuguese: any[] = [];
-
-    // Track whether we're in an EN or PT section
-    let currentLang: 'EN' | 'PT' | null = null;
-
-    for (let i = 0; i < block.length; i++) {
-      if (block.startsWith('-EN', i)) {
-        currentLang = 'EN';
-        i += 3; // Skip past "-EN"
-      } else if (block.startsWith('-PT', i)) {
-        currentLang = 'PT';
-        i += 3; // Skip past "-PT"
+        await this.log('info', `Updated Leonardo prompt for ${id}`);
       }
     }
 
-    // Process each section
-    for (let i = 0; i < sections.length; i++) {
-      const section = sections[i].trim();
-      console.log(`[Parse] Processing section: ${section}`);
-
-      // Determine the language based on the section's position relative to -EN and -PT markers
-      const lang = i === 0 ? 'EN' : 'PT'; // First section after -EN, second after -PT
-
-      // Split the section into individual entries based on numbered markers (1., 2., 3.)
-      const entries = section.split(/\n(?=\d+\.\s*)/).filter((e) => e.trim());
-      console.log(
-        `[Parse] Split section into ${entries.length} entries: ${JSON.stringify(
-          entries,
-          null,
-          2
-        )}`
-      );
-
-      for (const entry of entries) {
-        const lines = entry.split('\n').filter((l) => l.trim());
-        console.log(
-          `[Parse] Extracted ${lines.length} lines from entry: ${JSON.stringify(
-            lines,
-            null,
-            2
-          )}`
-        );
+    await this.log('info', 'Completed generateLeonardoPrompts', {
+      combinationString,
+      gender,
+      language,
+    });
+    return parsedPrompts;
+  }
 
-        if (lang === 'EN') {
-          const nameMatch = lines
-            .find((l) => l.includes('• Name:'))
-            ?.split('• Name:')[1]
-            ?.trim();
-          console.log(`[Parse] English nameMatch: ${nameMatch}`);
-
-          const essenceMatch = lines
-            .find((l) => l.includes('• Essence:'))
-            ?.split('• Essence:')[1]
-            ?.trim();
-          console.log(`[Parse] English essenceMatch: ${essenceMatch}`);
-
-          if (nameMatch && essenceMatch) {
-            const englishEntry = { name: nameMatch, essenceLine: essenceMatch };
-            english.push(englishEntry);
-            console.log(
-              `[Parse] Added English entry: ${JSON.stringify(
-                englishEntry,
-                null,
-                2
-              )}`
-            );
-          } else {
-            console.warn(
-              `[Parse] Skipping English entry due to missing fields. nameMatch: ${nameMatch}, essenceMatch: ${essenceMatch}`
-            );
-          }
-        } else if (lang === 'PT') {
-          const mascMatch = lines
-            .find((l) => l.includes('• Masculino:'))
-            ?.split('• Masculino:')[1]
-            ?.trim();
-          console.log(`[Parse] Portuguese mascMatch: ${mascMatch}`);
-
-          const femMatch = lines
-            .find((l) => l.includes('• Feminino:'))
-            ?.split('• Feminino:')[1]
-            ?.trim();
-          console.log(`[Parse] Portuguese femMatch: ${femMatch}`);
-
-          const essenceMatch = lines
-            .find((l) => l.includes('• Essência:'))
-            ?.split('• Essência:')[1]
-            ?.trim();
-          console.log(`[Parse] Portuguese essenceMatch: ${essenceMatch}`);
-
-          if (mascMatch && femMatch && essenceMatch) {
-            const ptEntry = {
-              masc: mascMatch,
-              fem: femMatch,
-              essenceLine: essenceMatch,
-            };
-            portuguese.push(ptEntry);
-            console.log(
-              `[Parse] Added Portuguese entry: ${JSON.stringify(
-                ptEntry,
-                null,
-                2
-              )}`
-            );
-          } else {
-            console.warn(
-              `[Parse] Skipping Portuguese entry due to missing fields. mascMatch: ${mascMatch}, femMatch: ${femMatch}, essenceMatch: ${essenceMatch}`
-            );
-          }
-        }
+  private parseLeonardoPromptResponse(response: string): LeonardoPrompt[] {
+    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}`);
+      }
+  
+      const malePrompt = malePromptLine?.trim() || '';
+      const femalePrompt = femalePromptLine?.trim() || '';
+  
+      if (!malePrompt || !femalePrompt) {
+        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 });
     }
+  
+    if (prompts.length !== 3) {
+      this.log('error', 'Expected exactly 3 archetype prompts', {
+        promptsCount: prompts.length,
+        response,
+      });
+      throw new Error(`Expected exactly 3 archetype prompts, but got ${prompts.length}`);
+    }
+  
+    this.log('info', 'Completed parseLeonardoPromptResponse', { prompts });
+    return prompts;
+  }
 
-    console.log(
-      `[Parse] Final parsed results - English: ${JSON.stringify(
-        english,
-        null,
-        2
-      )}, Portuguese: ${JSON.stringify(portuguese, null, 2)}`
-    );
-
-    return { english, portuguese };
+  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;
   }
 }