@zodic/shared 0.0.383 → 0.0.385

package/app/services/ArchetypeService.ts

@@ -1,7 +1,8 @@
-import { and, eq } from 'drizzle-orm';
+import { and, eq, inArray } from 'drizzle-orm';
 import { inject, injectable } from 'inversify';
 import { ChatMessages, schema } from '../..';
-import { Gender } from '../../types';
+import { astroPlanets } from '../../db/schema';
+import { Gender, Languages, VALID_GENDERS } from '../../types';
 import { ZodiacSignSlug } from '../../types/scopes/legacy';
 import { generateArchetypePrompt } from '../../utils/archetypeNamesMessages';
 import { AppContext } from '../base';
@@ -690,11 +691,11 @@ export class ArchetypeService {
       language,
       override,
     });
-  
+
     const db = this.context.drizzle();
     const allGenders: Gender[] = ['male', 'female'];
     const archetypesByGender: Record<Gender, any[]> = { male: [], female: [] };
-  
+
     for (const g of allGenders) {
       const archetypes = await db
         .select()
@@ -710,20 +711,20 @@ export class ArchetypeService {
         .execute();
       archetypesByGender[g] = archetypes;
     }
-  
+
     const needsGeneration = allGenders.some(
       (g) =>
         archetypesByGender[g].length !== 3 ||
         archetypesByGender[g].some((a) => a.content === '[]')
     );
-  
+
     if (!override && !needsGeneration) {
       await this.log('info', 'Skipping content generation', {
         reason: 'Content already exists for all archetypes',
       });
       return;
     }
-  
+
     await this.log('info', 'Fetched archetypes for content generation', {
       maleArchetypes: archetypesByGender['male'].map((a) => ({
         id: a.id,
@@ -736,29 +737,41 @@ export class ArchetypeService {
         index: a.archetypeIndex,
       })),
     });
-  
+
     const contentResults = [];
     for (let i = 0; i < 3; i++) {
       const index = (i + 1).toString();
       const archetype = archetypesByGender['male'][i];
       if (!archetype || archetype.archetypeIndex !== index) {
-        await this.log('error', `Archetype index mismatch at position ${i + 1}`, {
-          expectedIndex: index,
-          actualIndex: archetype?.archetypeIndex,
-          archetypeId: archetype?.id,
-        });
-        throw new Error(`Archetype index mismatch: expected ${index}, got ${archetype?.archetypeIndex}`);
+        await this.log(
+          'error',
+          `Archetype index mismatch at position ${i + 1}`,
+          {
+            expectedIndex: index,
+            actualIndex: archetype?.archetypeIndex,
+            archetypeId: archetype?.id,
+          }
+        );
+        throw new Error(
+          `Archetype index mismatch: expected ${index}, got ${archetype?.archetypeIndex}`
+        );
       }
-  
+
       // Generate EN content
-      const enId = `${combinationString}:male:${index}${language === 'en-us' ? '' : ':pt'}`;
+      const enId = `${combinationString}:male:${index}${
+        language === 'en-us' ? '' : ':pt'
+      }`;
       if (!override && archetypesByGender['male'][i].content !== '[]') {
         await this.log('debug', `Skipping existing EN content for ${enId}`, {
           content: archetypesByGender['male'][i].content,
           archetypeIndex: index,
         });
       } else {
-        await this.log('debug', `Generating EN content for archetype ${index}`, { name: archetype.name });
+        await this.log(
+          'debug',
+          `Generating EN content for archetype ${index}`,
+          { name: archetype.name }
+        );
         const enMessages = this.context
           .buildLLMMessages()
           .generateCosmicMirrorArchetypeContentEN({
@@ -766,27 +779,48 @@ export class ArchetypeService {
             description: descriptions[i].descriptionEN,
             combination: combinationString,
           });
-  
-        await this.log('debug', `Calling API for EN content of archetype ${index}`, { messages: enMessages });
-        const enResponse = await this.context.api().callTogether.single(enMessages, {
-          options: { max_tokens: 4096 },
-        });
-        if (!enResponse) {
-          await this.log('error', `No response for EN content of archetype ${index}`, {
-            combinationString,
-            archetype: archetype.name,
+
+        await this.log(
+          'debug',
+          `Calling API for EN content of archetype ${index}`,
+          { messages: enMessages }
+        );
+        const enResponse = await this.context
+          .api()
+          .callTogether.single(enMessages, {
+            options: { max_tokens: 4096 },
           });
-          throw new Error(`Failed to generate EN content for archetype ${index} of: ${combinationString}`);
+        if (!enResponse) {
+          await this.log(
+            'error',
+            `No response for EN content of archetype ${index}`,
+            {
+              combinationString,
+              archetype: archetype.name,
+            }
+          );
+          throw new Error(
+            `Failed to generate EN content for archetype ${index} of: ${combinationString}`
+          );
         }
-        await this.log('info', `Received EN content response for archetype ${index}`, {
-          responseLength: enResponse.length,
-          rawResponse: enResponse,
-        });
-  
-        await this.log('debug', `Parsing EN content response for archetype ${index}`);
+        await this.log(
+          'info',
+          `Received EN content response for archetype ${index}`,
+          {
+            responseLength: enResponse.length,
+            rawResponse: enResponse,
+          }
+        );
+
+        await this.log(
+          'debug',
+          `Parsing EN content response for archetype ${index}`
+        );
         const enContent = this.parseContentResponse(enResponse, 'EN');
-        await this.log('info', `Parsed EN content for archetype ${index}`, { enContent });
-  
+        await this.log('info', `Parsed EN content for archetype ${index}`, {
+          enContent,
+        });
+
         const content = [
           { section: 'voiceOfTheSoul', text: enContent.voiceOfTheSoul },
           { section: 'giftsYouBear', text: enContent.giftsYouBear },
@@ -795,12 +829,12 @@ export class ArchetypeService {
           { section: 'tiesThatBind', text: enContent.tiesThatBind },
           { section: 'lightWithin', text: enContent.lightWithin },
         ];
-  
+
         await this.log('debug', `Updating EN content for ${enId}`, {
           content,
           archetypeIndex: index,
         });
-  
+
         await db
           .update(schema.archetypesData)
           .set({
@@ -816,24 +850,36 @@ export class ArchetypeService {
             )
           )
           .execute();
-  
+
         await this.log('info', `Updated EN content for ${enId}`);
         contentResults.push(enContent);
       }
-  
+
       // Generate PT content (both male and female)
       const ptIds = {
         male: `${combinationString}:male:${index}:pt`,
         female: `${combinationString}:female:${index}:pt`,
       };
-      if (!override && archetypesByGender['male'][i].content !== '[]' && archetypesByGender['female'][i].content !== '[]') {
-        await this.log('debug', `Skipping existing PT content for ${ptIds.male} and ${ptIds.female}`, {
-          maleContent: archetypesByGender['male'][i].content,
-          femaleContent: archetypesByGender['female'][i].content,
-          archetypeIndex: index,
-        });
+      if (
+        !override &&
+        archetypesByGender['male'][i].content !== '[]' &&
+        archetypesByGender['female'][i].content !== '[]'
+      ) {
+        await this.log(
+          'debug',
+          `Skipping existing PT content for ${ptIds.male} and ${ptIds.female}`,
+          {
+            maleContent: archetypesByGender['male'][i].content,
+            femaleContent: archetypesByGender['female'][i].content,
+            archetypeIndex: index,
+          }
+        );
       } else {
-        await this.log('debug', `Generating PT content for archetype ${index}`, { name: archetype.name });
+        await this.log(
+          'debug',
+          `Generating PT content for archetype ${index}`,
+          { name: archetype.name }
+        );
         const ptMessages = this.context
           .buildLLMMessages()
           .generateCosmicMirrorArchetypeContentPT({
@@ -841,49 +887,103 @@ export class ArchetypeService {
             description: descriptions[i].descriptionEN,
             combination: combinationString,
           });
-  
-        await this.log('debug', `Calling API for PT content of archetype ${index}`, { messages: ptMessages });
-        const ptResponse = await this.context.api().callTogether.single(ptMessages, {
-          options: { max_tokens: 8192 },
-        });
-        if (!ptResponse) {
-          await this.log('error', `No response for PT content of archetype ${index}`, {
-            combinationString,
-            archetype: archetype.name,
+
+        await this.log(
+          'debug',
+          `Calling API for PT content of archetype ${index}`,
+          { messages: ptMessages }
+        );
+        const ptResponse = await this.context
+          .api()
+          .callTogether.single(ptMessages, {
+            options: { max_tokens: 8192 },
           });
-          throw new Error(`Failed to generate PT content for archetype ${index} of: ${combinationString}`);
+        if (!ptResponse) {
+          await this.log(
+            'error',
+            `No response for PT content of archetype ${index}`,
+            {
+              combinationString,
+              archetype: archetype.name,
+            }
+          );
+          throw new Error(
+            `Failed to generate PT content for archetype ${index} of: ${combinationString}`
+          );
         }
-        await this.log('info', `Received PT content response for archetype ${index}`, {
-          responseLength: ptResponse.length,
-          rawResponse: ptResponse,
+        await this.log(
+          'info',
+          `Received PT content response for archetype ${index}`,
+          {
+            responseLength: ptResponse.length,
+            rawResponse: ptResponse,
+          }
+        );
+
+        await this.log(
+          'debug',
+          `Parsing PT-M content response for archetype ${index}`
+        );
+        const ptMaleContentParsed = this.parseContentResponse(
+          ptResponse,
+          'PT',
+          'male'
+        );
+        await this.log('info', `Parsed PT-M content for archetype ${index}`, {
+          ptMaleContentParsed,
         });
-  
-        await this.log('debug', `Parsing PT-M content response for archetype ${index}`);
-        const ptMaleContentParsed = this.parseContentResponse(ptResponse, 'PT', 'male');
-        await this.log('info', `Parsed PT-M content for archetype ${index}`, { ptMaleContentParsed });
-  
-        await this.log('debug', `Parsing PT-F content response for archetype ${index}`);
-        const ptFemaleContentParsed = this.parseContentResponse(ptResponse, 'PT', 'female');
-        await this.log('info', `Parsed PT-F content for archetype ${index}`, { ptFemaleContentParsed });
-  
+
+        await this.log(
+          'debug',
+          `Parsing PT-F content response for archetype ${index}`
+        );
+        const ptFemaleContentParsed = this.parseContentResponse(
+          ptResponse,
+          'PT',
+          'female'
+        );
+        await this.log('info', `Parsed PT-F content for archetype ${index}`, {
+          ptFemaleContentParsed,
+        });
+
         const ptMaleContent = [
-          { section: 'voiceOfTheSoul', text: ptMaleContentParsed.voiceOfTheSoul },
+          {
+            section: 'voiceOfTheSoul',
+            text: ptMaleContentParsed.voiceOfTheSoul,
+          },
           { section: 'giftsYouBear', text: ptMaleContentParsed.giftsYouBear },
-          { section: 'shadowsYouFace', text: ptMaleContentParsed.shadowsYouFace },
-          { section: 'rhythmOfYourDays', text: ptMaleContentParsed.rhythmOfYourDays },
+          {
+            section: 'shadowsYouFace',
+            text: ptMaleContentParsed.shadowsYouFace,
+          },
+          {
+            section: 'rhythmOfYourDays',
+            text: ptMaleContentParsed.rhythmOfYourDays,
+          },
           { section: 'tiesThatBind', text: ptMaleContentParsed.tiesThatBind },
           { section: 'lightWithin', text: ptMaleContentParsed.lightWithin },
         ];
         const ptFemaleContent = [
-          { section: 'voiceOfTheSoul', text: ptFemaleContentParsed.voiceOfTheSoul },
+          {
+            section: 'voiceOfTheSoul',
+            text: ptFemaleContentParsed.voiceOfTheSoul,
+          },
           { section: 'giftsYouBear', text: ptFemaleContentParsed.giftsYouBear },
-          { section: 'shadowsYouFace', text: ptFemaleContentParsed.shadowsYouFace },
-          { section: 'rhythmOfYourDays', text: ptFemaleContentParsed.rhythmOfYourDays },
+          {
+            section: 'shadowsYouFace',
+            text: ptFemaleContentParsed.shadowsYouFace,
+          },
+          {
+            section: 'rhythmOfYourDays',
+            text: ptFemaleContentParsed.rhythmOfYourDays,
+          },
           { section: 'tiesThatBind', text: ptFemaleContentParsed.tiesThatBind },
           { section: 'lightWithin', text: ptFemaleContentParsed.lightWithin },
         ];
-  
-        await this.log('debug', `Updating PT-M content for ${ptIds.male}`, { content: ptMaleContent });
+
+        await this.log('debug', `Updating PT-M content for ${ptIds.male}`, {
+          content: ptMaleContent,
+        });
         await db
           .update(schema.archetypesData)
           .set({
@@ -900,8 +1000,10 @@ export class ArchetypeService {
           )
           .execute();
         await this.log('info', `Updated PT-M content for ${ptIds.male}`);
-  
-        await this.log('debug', `Updating PT-F content for ${ptIds.female}`, { content: ptFemaleContent });
+
+        await this.log('debug', `Updating PT-F content for ${ptIds.female}`, {
+          content: ptFemaleContent,
+        });
         await db
           .update(schema.archetypesData)
           .set({
@@ -920,89 +1022,153 @@ export class ArchetypeService {
         await this.log('info', `Updated PT-F content for ${ptIds.female}`);
       }
     }
-  
-    await this.log('info', 'Completed generateContent', { combinationString, gender, language });
+
+    await this.log('info', 'Completed generateContent', {
+      combinationString,
+      gender,
+      language,
+    });
     return contentResults;
   }
 
-  private parseContentResponse(response: string, section: string, gender: Gender | null = null) {
-    this.log('debug', 'Starting parseContentResponse', { responseLength: response.length, section, gender });
-  
-    const lines = response.split('\n').map(line => line.trim());
-    this.log('debug', 'Split response into lines', { linesCount: lines.length, lines });
-  
+  private parseContentResponse(
+    response: string,
+    section: string,
+    gender: Gender | null = null
+  ) {
+    this.log('debug', 'Starting parseContentResponse', {
+      responseLength: response.length,
+      section,
+      gender,
+    });
+
+    const lines = response.split('\n').map((line) => line.trim());
+    this.log('debug', 'Split response into lines', {
+      linesCount: lines.length,
+      lines,
+    });
+
     // Skip initial --- and empty lines
     let startIndex = 0;
-    while (startIndex < lines.length && (lines[startIndex] === '---' || lines[startIndex] === '')) {
+    while (
+      startIndex < lines.length &&
+      (lines[startIndex] === '---' || lines[startIndex] === '')
+    ) {
       startIndex++;
     }
-  
+
     if (startIndex >= lines.length) {
-      this.log('error', `No content found after skipping delimiters for ${section}`, { response });
-      throw new Error(`No content found after skipping delimiters for ${section}`);
+      this.log(
+        'error',
+        `No content found after skipping delimiters for ${section}`,
+        { response }
+      );
+      throw new Error(
+        `No content found after skipping delimiters for ${section}`
+      );
     }
-  
-    const content: Record<string, Record<string, string>> = { 'PT-M:': {}, 'PT-F:': {}, 'EN:': {} };
+
+    const content: Record<string, Record<string, string>> = {
+      'PT-M:': {},
+      'PT-F:': {},
+      'EN:': {},
+    };
     let currentSectionHeader = '';
     let currentSection = '';
     let currentText: string[] = [];
     let currentLang = '';
-  
+
     for (let i = startIndex; i < lines.length; i++) {
       const line = lines[i];
-  
+
       if (line === '---') {
         if (currentSection && currentText.length > 0) {
-          const key = currentSection.toLowerCase().replace(/\s+/g, '').replace(/([A-Z])/g, (match) => match.toLowerCase());
+          const key = currentSection
+            .toLowerCase()
+            .replace(/\s+/g, '')
+            .replace(/([A-Z])/g, (match) => match.toLowerCase());
           content[currentLang][key] = currentText.join(' ').trim();
-          this.log('debug', `Extracted section ${currentSection} for ${currentLang}`, { key, text: content[currentLang][key] });
+          this.log(
+            'debug',
+            `Extracted section ${currentSection} for ${currentLang}`,
+            { key, text: content[currentLang][key] }
+          );
         }
         currentSection = '';
         currentText = [];
         // Look for the next header
-        while (i + 1 < lines.length && (lines[i + 1] === '' || lines[i + 1] === '---')) {
+        while (
+          i + 1 < lines.length &&
+          (lines[i + 1] === '' || lines[i + 1] === '---')
+        ) {
           i++;
         }
-        if (i + 1 < lines.length && (lines[i + 1] === 'PT-M:' || lines[i + 1] === 'PT-F:' || lines[i + 1] === 'EN:')) {
+        if (
+          i + 1 < lines.length &&
+          (lines[i + 1] === 'PT-M:' ||
+            lines[i + 1] === 'PT-F:' ||
+            lines[i + 1] === 'EN:')
+        ) {
           i++;
           currentLang = lines[i];
           this.log('debug', `Found new language section: ${currentLang}`);
         }
         continue;
       }
-  
+
       if (line === 'PT-M:' || line === 'PT-F:' || line === 'EN:') {
         currentLang = line;
         this.log('debug', `Starting language section: ${currentLang}`);
         continue;
       }
-  
+
       if (line.startsWith('#')) {
         if (currentSection && currentText.length > 0) {
-          const key = currentSection.toLowerCase().replace(/\s+/g, '').replace(/([A-Z])/g, (match) => match.toLowerCase());
+          const key = currentSection
+            .toLowerCase()
+            .replace(/\s+/g, '')
+            .replace(/([A-Z])/g, (match) => match.toLowerCase());
           content[currentLang][key] = currentText.join(' ').trim();
-          this.log('debug', `Extracted section ${currentSection} for ${currentLang}`, { key, text: content[currentLang][key] });
+          this.log(
+            'debug',
+            `Extracted section ${currentSection} for ${currentLang}`,
+            { key, text: content[currentLang][key] }
+          );
         }
         currentSection = line.replace('# ', '');
         currentSectionHeader = currentSection.toLowerCase();
         currentText = [];
-        this.log('debug', `Starting new section ${currentSection} for ${currentLang}`);
+        this.log(
+          'debug',
+          `Starting new section ${currentSection} for ${currentLang}`
+        );
       } else if (line) {
         currentText.push(line);
-        this.log('debug', `Adding line to ${currentSection} for ${currentLang}`, { line });
+        this.log(
+          'debug',
+          `Adding line to ${currentSection} for ${currentLang}`,
+          { line }
+        );
       }
     }
-  
+
     // Handle the last section
     if (currentSection && currentText.length > 0) {
-      const key = currentSection.toLowerCase().replace(/\s+/g, '').replace(/([A-Z])/g, (match) => match.toLowerCase());
+      const key = currentSection
+        .toLowerCase()
+        .replace(/\s+/g, '')
+        .replace(/([A-Z])/g, (match) => match.toLowerCase());
       content[currentLang][key] = currentText.join(' ').trim();
-      this.log('debug', `Extracted final section ${currentSection} for ${currentLang}`, { key, text: content[currentLang][key] });
+      this.log(
+        'debug',
+        `Extracted final section ${currentSection} for ${currentLang}`,
+        { key, text: content[currentLang][key] }
+      );
     }
-  
+
     // Log the full content object for debugging
     this.log('debug', `Full parsed content before selection`, { content });
-  
+
     // Determine which content to return based on section and gender
     let targetLang = section;
     if (section === 'PT') {
@@ -1010,31 +1176,58 @@ export class ArchetypeService {
     } else {
       targetLang = `${section}:`;
     }
-  
+
     const targetContent = content[targetLang];
     if (!targetContent) {
-      this.log('error', `No content found for target ${targetLang}`, { response, section, gender });
+      this.log('error', `No content found for target ${targetLang}`, {
+        response,
+        section,
+        gender,
+      });
       throw new Error(`No content found for target ${targetLang}`);
     }
-  
+
     const parsedContent = {
-      voiceOfTheSoul: targetContent['thevoiceofthesoul'] || targetContent['avozdaalma'] || '',
-      giftsYouBear: targetContent['thegiftsyoubear'] || targetContent['osdonsquevocêcarrega'] || '',
-      shadowsYouFace: targetContent['theshadowsyouface'] || targetContent['assombrasqueenfrenta'] || '',
-      rhythmOfYourDays: targetContent['therhythmofyourdays'] || targetContent['oritmodosseusdias'] || '',
-      tiesThatBind: targetContent['thetiesthatbind'] || targetContent['oslaçosqueteconectam'] || '',
-      lightWithin: targetContent['thelightwithin'] || targetContent['aluzinterior'] || '',
+      voiceOfTheSoul:
+        targetContent['thevoiceofthesoul'] || targetContent['avozdaalma'] || '',
+      giftsYouBear:
+        targetContent['thegiftsyoubear'] ||
+        targetContent['osdonsquevocêcarrega'] ||
+        '',
+      shadowsYouFace:
+        targetContent['theshadowsyouface'] ||
+        targetContent['assombrasqueenfrenta'] ||
+        '',
+      rhythmOfYourDays:
+        targetContent['therhythmofyourdays'] ||
+        targetContent['oritmodosseusdias'] ||
+        '',
+      tiesThatBind:
+        targetContent['thetiesthatbind'] ||
+        targetContent['oslaçosqueteconectam'] ||
+        '',
+      lightWithin:
+        targetContent['thelightwithin'] || targetContent['aluzinterior'] || '',
     };
-  
+
     // Log the parsed content before validation
-    this.log('debug', `Parsed content before validation for ${targetLang}`, { parsedContent });
-  
+    this.log('debug', `Parsed content before validation for ${targetLang}`, {
+      parsedContent,
+    });
+
     if (Object.values(parsedContent).some((value) => !value)) {
-      this.log('error', `Malformed content response for ${targetLang}`, { parsedContent, response });
+      this.log('error', `Malformed content response for ${targetLang}`, {
+        parsedContent,
+        response,
+      });
       throw new Error(`Malformed content response for ${targetLang}`);
     }
-  
-    this.log('info', 'Completed parseContentResponse', { parsedContent, section, gender });
+
+    this.log('info', 'Completed parseContentResponse', {
+      parsedContent,
+      section,
+      gender,
+    });
     return parsedContent;
   }
 
@@ -1316,4 +1509,118 @@ export class ArchetypeService {
     });
     return result;
   }
+
+  async queueArchetypeGeneration(userId: string) {
+    const drizzle = this.context.drizzle();
+    try {
+      await this.log('info', 'Starting archetype generation queuing for user', {
+        userId,
+      });
+
+      // Query astro_planets for Sun, Ascendant, and Moon signs
+      const planets = await drizzle
+        .select()
+        .from(astroPlanets)
+        .where(
+          and(
+            eq(astroPlanets.userId, userId),
+            inArray(
+              astroPlanets.name,
+              ['sun', 'ascendant', 'moon'] // Assuming these are the exact names
+            )
+          )
+        );
+
+      if (planets.length !== 3) {
+        this.log('warn', 'Incomplete planetary data for archetype generation', {
+          userId,
+          found: planets.map((p) => p.name),
+        });
+        return;
+      }
+
+      const sun = planets.find((p) => p.name === 'sun')?.sign;
+      const ascendant = planets.find((p) => p.name === 'ascendant')?.sign;
+      const moon = planets.find((p) => p.name === 'moon')?.sign;
+
+      if (!sun || !ascendant || !moon) {
+        await this.log('warn', 'Missing Sun, Ascendant, or Moon data', {
+          sun,
+          ascendant,
+          moon,
+        });
+        return;
+      }
+
+      const combinationString = [sun, ascendant, moon].join('-');
+      await this.log(
+        'info',
+        'Generated combination string from astro_planets',
+        { combinationString }
+      );
+
+      // Fetch user details for gender and language
+      const [user] = await drizzle
+        .select({
+          gender: schema.users.gender,
+          lang: schema.users.language,
+        })
+        .from(schema.users)
+        .where(eq(schema.users.id, userId))
+        .limit(1);
+
+      if (!user || !VALID_GENDERS.has(user.gender as Gender)) {
+        await this.log('error', 'Invalid or missing gender', {
+          userId,
+          gender: user?.gender || 'null',
+        });
+        return;
+      }
+
+      const gender = user.gender as Gender;
+      const lang = user.lang as Languages;
+
+      // Check if archetypes already exist to avoid redundant queuing
+      const existingArchetypes = await drizzle
+        .select()
+        .from(schema.archetypesData)
+        .where(
+          and(
+            eq(schema.archetypesData.combination, combinationString),
+            eq(schema.archetypesData.gender, gender),
+            eq(schema.archetypesData.language, lang)
+          )
+        );
+
+      if (
+        existingArchetypes.length > 0 &&
+        existingArchetypes.every((a) => a.status === 'completed')
+      ) {
+        await this.log('info', 'Archetypes already exist and completed', {
+          count: existingArchetypes.length,
+        });
+        return;
+      }
+
+      // Queue the archetype generation
+      const queuePayload = {
+        combinationString,
+        gender,
+        language: lang,
+        userId,
+        override: false,
+      };
+      await this.log('info', 'Queuing archetype generation', { queuePayload });
+      await this.context.env.ARCHETYPE_POPULATION_QUEUE.send(queuePayload);
+      await this.log(
+        'info',
+        'Queued archetype generation successfully for user signup'
+      );
+    } catch (error) {
+      await this.log('error', 'Error queuing archetype generation', {
+        userId,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
 }

package/package.json

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

package/utils/buildMessages.ts

@@ -24,6 +24,8 @@ export const buildLLMMessages = (env: BackendBindings) => ({
         role: 'system',
         content: `
   You are a gifted fantasy writer and astrologer. Your task is to write mystical **narrative descriptions** and **core virtues** for three archetypes, based on their names, essence lines, and astrological combination.
+
+  Your response must be insightful, symbolic, and restrained. Focus on personality traits, behaviors, and subtle symbolic elements inspired by the archetypal energies of the Sun, Ascendant, and Moon signs, conveyed through elegant metaphors and thoughtful storytelling. Avoid overly fantastical or magical imagery like glowing lights, ethereal realms, or supernatural abilities, and instead emphasize a grounded, sober tone while maintaining a mystical depth.
   
   Each archetype is influenced by the zodiac combination (Sun, Ascendant, Moon), and each one emphasizes one of those signs respectively. The signs and the archetype name should not be mentioned in the description. Use only their abstract representation and symbolism.