@zodic/shared 0.0.373 → 0.0.375

package/app/services/LeonardoService.ts

@@ -2,7 +2,6 @@ import { eq } from 'drizzle-orm';
 import { inject, injectable } from 'inversify';
 import 'reflect-metadata';
 import { schema } from '../..';
-import { Gender } from '../../types';
 import { AppContext } from '../base/AppContext';
 
 interface QueueMessage {
@@ -48,12 +47,11 @@ export class LeonardoService {
   /**
    * Processes a message from ARCHETYPE_POPULATION_QUEUE to ensure the archetype has three images.
    */
-  async processArchetypePopulation(message: QueueMessage): Promise<void> {
-    const { archetypeDataId } = message;
+  async processArchetypePopulation(archetypeDataId: string): Promise<void> {
     await this.log('info', 'Processing archetype population', {
       archetypeDataId,
     });
-  
+
     const db = this.context.drizzle();
     const archetype = await db
       .select({
@@ -69,14 +67,21 @@ export class LeonardoService {
       .where(eq(schema.archetypesData.id, archetypeDataId))
       .limit(1)
       .execute();
-  
+
     if (!archetype[0]) {
       await this.log('error', 'Archetype not found', { archetypeDataId });
       throw new Error(`Archetype not found: ${archetypeDataId}`);
     }
-  
-    const { combination, gender, language, archetypeIndex, leonardoPrompt, images } = archetype[0];
-  
+
+    const {
+      combination,
+      gender,
+      language,
+      archetypeIndex,
+      leonardoPrompt,
+      images,
+    } = archetype[0];
+
     await this.log('info', 'Fetched archetype details', {
       archetypeDataId,
       combination,
@@ -84,7 +89,7 @@ export class LeonardoService {
       language,
       archetypeIndex,
     });
-  
+
     const parsedImages = JSON.parse(images || '[]');
     if (parsedImages.length >= 3) {
       await this.log('info', 'Archetype already has sufficient images', {
@@ -93,7 +98,7 @@ export class LeonardoService {
       });
       return;
     }
-  
+
     if (!leonardoPrompt) {
       await this.log('error', 'Missing Leonardo prompt for archetype', {
         archetypeDataId,
@@ -102,21 +107,21 @@ export class LeonardoService {
         `Missing Leonardo prompt for archetype: ${archetypeDataId}`
       );
     }
-  
+
     await this.log('debug', 'Generating images for archetype', {
       archetypeDataId,
       prompt: leonardoPrompt,
     });
-  
+
     const generationResponse = await this.context
       .api()
       .callLeonardo.generateImage({
         prompt: leonardoPrompt,
         width: 512,
         height: 640,
-        quantity: 3 - parsedImages.length,
+        // quantity: 3 - parsedImages.length,
       });
-  
+
     const generationId = generationResponse.sdGenerationJob.generationId;
     if (!generationId) {
       await this.log(
@@ -126,7 +131,7 @@ export class LeonardoService {
       );
       throw new Error('Leonardo generation failed to return a valid ID');
     }
-  
+
     await db.insert(schema.generations).values({
       id: generationId,
       archetypeIndex: parseInt(archetypeIndex),
@@ -136,7 +141,7 @@ export class LeonardoService {
       gender,
       createdAt: new Date(),
     });
-  
+
     await this.log('info', 'Queued image generation', {
       generationId,
       archetypeDataId,

package/app/workflow/ArchetypeWorkflow.ts

@@ -1,10 +1,8 @@
-import { and, eq } from 'drizzle-orm';
 import { inject, injectable } from 'inversify';
-import { schema } from '../..';
-import { Gender } from '../../types';
 import { AppContext } from '../base';
-import { ArchetypeService } from '../services/ArchetypeService';
-import { LeonardoService } from '../services/LeonardoService';
+import { Gender, Languages } from '../../types';
+import { ArchetypeService, LeonardoService, schema } from '../..';
+import { and, eq } from 'drizzle-orm';
 
 @injectable()
 export class ArchetypeWorkflow {
@@ -19,266 +17,210 @@ export class ArchetypeWorkflow {
     message: string,
     context: Record<string, any> = {}
   ) {
-    const logId = `archetype-workflow:${Date.now()}`;
     const logMessage = `[${new Date().toISOString()}] [${level.toUpperCase()}] ${message}`;
-
     console[level](logMessage, context);
-    const db = this.context.drizzle();
-    try {
-      await db
-        .insert(schema.logs)
-        .values({
-          id: logId,
-          level,
-          message,
-          context: JSON.stringify(context),
-          createdAt: new Date().getTime(),
-        })
-        .execute();
-    } catch (error) {
-      console.error('[ERROR] Failed to persist log to database:', {
-        error,
-        logId,
-        message,
-        context,
-      });
-    }
   }
 
   async execute(
     combinationString: string,
     gender: Gender,
-    language: string = 'en-us',
-    override: boolean = false
+    language: Languages,
+    override: boolean = false,
+    userId?: string
   ) {
-    await this.log('info', 'Starting ArchetypeWorkflow', {
+    await this.log('info', 'Starting ArchetypeWorkflow.execute', {
       combinationString,
       gender,
       language,
       override,
+      userId,
     });
 
-    // Step 1: Fetch existing archetypes
-    let archetypes = await this.archetypeService.fetchArchetypesFromDB(
-      combinationString,
-      gender,
-      language
-    );
-    await this.log('info', 'Fetched existing archetypes', {
-      archetypesCount: archetypes.length,
-      archetypeIds: archetypes.map((a) => a.id),
-    });
+    try {
+      // Step 1: Generate archetype names for both genders
+      await this.log('debug', 'Generating archetype names', { combinationString, override, userId });
+      await this.archetypeService.generateArchetypeNames(combinationString, override);
 
-    // Step 2: Generate or update archetype names and essence lines
-    if (
-      override ||
-      archetypes.length === 0 ||
-      archetypes.some((a) => !a.name || !a.essenceLine)
-    ) {
-      await this.log('info', 'Generating or updating archetype names', {
+      // Step 2: Generate descriptions and virtues for both genders
+      await this.log('debug', 'Generating descriptions and virtues', {
         combinationString,
         gender,
         language,
         override,
+        userId,
       });
-      await this.archetypeService.generateArchetypeNames(
+      const descriptions = await this.archetypeService.generateDescriptionsAndVirtues(
         combinationString,
+        gender, // Service processes both genders internally
+        language,
         override
       );
-      archetypes = await this.archetypeService.fetchArchetypesFromDB(
-        combinationString,
-        gender,
-        language
-      );
-      await this.log('info', 'Refetched archetypes after name generation', {
-        archetypesCount: archetypes.length,
-        archetypeIds: archetypes.map((a) => a.id),
-      });
-    } else {
-      await this.log('info', 'Skipping archetype names generation', {
-        reason: 'Names and essence lines already exist',
-      });
-    }
 
-    // Step 3: Generate or update descriptions and virtues
-    let descVirtues: any[] = [];
-    if (
-      override ||
-      archetypes.some((a) => !a.description || a.virtues === '[]')
-    ) {
-      await this.log('info', 'Generating or updating descriptions and virtues', {
+      // Step 3: Generate content for both genders
+      await this.log('debug', 'Generating content', {
         combinationString,
         gender,
         language,
         override,
+        userId,
       });
-      descVirtues = await this.archetypeService.generateDescriptionsAndVirtues(
+      await this.archetypeService.generateContent(
         combinationString,
-        gender,
+        gender, // Service processes both genders internally
         language,
+        descriptions,
         override
       );
-      archetypes = await this.archetypeService.fetchArchetypesFromDB(
-        combinationString,
-        gender,
-        language
-      );
-      await this.log('info', 'Refetched archetypes after descriptions and virtues', {
-        archetypesCount: archetypes.length,
-        archetypeIds: archetypes.map((a) => a.id),
-      });
-    } else {
-      await this.log('info', 'Skipping descriptions and virtues generation', {
-        reason: 'Descriptions and virtues already exist',
-      });
-    }
 
-    // Step 4: Generate or update content
-    if (override || archetypes.some((a) => a.content === '[]')) {
-      await this.log('info', 'Generating or updating content', {
+      // Step 4: Generate Leonardo prompts for both genders
+      await this.log('debug', 'Generating Leonardo prompts', {
         combinationString,
         gender,
         language,
         override,
+        userId,
       });
-      await this.archetypeService.generateContent(
+      await this.archetypeService.generateLeonardoPrompts(
         combinationString,
-        gender,
+        gender, // Service processes both genders internally
         language,
-        descVirtues,
+        descriptions,
         override
       );
-      archetypes = await this.archetypeService.fetchArchetypesFromDB(
-        combinationString,
-        gender,
-        language
-      );
-      await this.log('info', 'Refetched archetypes after content generation', {
-        archetypesCount: archetypes.length,
-        archetypeIds: archetypes.map((a) => a.id),
-      });
-    } else {
-      await this.log('info', 'Skipping content generation', {
-        reason: 'Content already exists',
-      });
-    }
 
-    // Step 5: Generate or update Leonardo prompts
-    if (override || archetypes.some((a) => !a.leonardoPrompt)) {
-      await this.log('info', 'Generating or updating Leonardo prompts', {
+      // Step 5: Fetch archetypes for the requested gender only for image generation
+      await this.log('debug', 'Fetching archetypes for image generation', {
         combinationString,
         gender,
         language,
-        override,
+        userId,
       });
-      await this.archetypeService.generateLeonardoPrompts(
+      const archetypes = await this.archetypeService.fetchArchetypesFromDB(
         combinationString,
-        gender,
-        language,
-        descVirtues,
-        override
-      );
-      archetypes = await this.archetypeService.fetchArchetypesFromDB(
-        combinationString,
-        gender,
+        gender, // Fetch only the requested gender
         language
       );
-      await this.log('info', 'Refetched archetypes after Leonardo prompts', {
-        archetypesCount: archetypes.length,
-        archetypeIds: archetypes.map((a) => a.id),
-      });
-    } else {
-      await this.log('info', 'Skipping Leonardo prompts generation', {
-        reason: 'Leonardo prompts already exist',
-      });
-    }
 
-    // Step 6: Process image generation if needed
-    const archetypesNeedingImages = archetypes.filter(
-      (arc) => JSON.parse(arc.images).length < 3 || (override && arc.images !== '[]')
-    );
+      if (archetypes.length !== 3) {
+        await this.log('error', `Expected 3 archetypes for ${gender}, found ${archetypes.length}`, {
+          combinationString,
+          gender,
+          language,
+          userId,
+        });
+        throw new Error(
+          `Expected 3 archetypes for combination ${combinationString}, gender ${gender}, language ${language}, but found ${archetypes.length}`
+        );
+      }
 
-    if (archetypesNeedingImages.length > 0) {
-      await this.log('info', 'Processing image generation for archetypes', {
-        archetypesNeedingImagesCount: archetypesNeedingImages.length,
-        archetypeIds: archetypesNeedingImages.map((a) => a.id),
-      });
+      // Step 6: Process image generation only for the requested gender
+      await this.log('info', `Processing image generation for gender ${gender}`, {
+        archetypeIds: archetypes.map((a) => a.id),
+        archetypeIndexes: archetypes.map((a) => a.archetypeIndex),
+        userId,
+      });
+      for (const archetype of archetypes) {
+        if (!archetype.leonardoPrompt) {
+          await this.log('warn', `No Leonardo prompt for archetype ${archetype.id}`, {
+            archetypeIndex: archetype.archetypeIndex,
+            gender,
+            language,
+            userId,
+          });
+          continue;
+        }
 
-      for (const archetype of archetypesNeedingImages) {
-        await this.log('debug', 'Processing image generation', {
-          archetypeId: archetype.id,
-          leonardoPrompt: archetype.leonardoPrompt,
-        });
+        if (override || !archetype.images || archetype.images === '[]') {
+          await this.log('debug', `Queueing image generation for archetype ${archetype.id}`, {
+            archetypeIndex: archetype.archetypeIndex,
+            gender,
+            language,
+            userId,
+          });
+          await this.leonardoService.processArchetypePopulation(archetype.id);
+        } else {
+          await this.log('debug', `Skipping image generation for archetype ${archetype.id}`, {
+            reason: 'Images already exist and override is false',
+            archetypeIndex: archetype.archetypeIndex,
+            gender,
+            language,
+            userId,
+          });
+        }
+      }
 
-        // Reset images and status if override is true
-        if (override) {
-          await this.context.drizzle()
+      // Step 7: Update status to 'completed' for archetypes with at least 3 images
+      await this.log('debug', 'Updating status for archetypes with images', {
+        combinationString,
+        gender,
+        language,
+        userId,
+      });
+      const db = this.context.drizzle();
+      for (const archetype of archetypes) {
+        let imageCount = 0;
+        try {
+          const images = archetype.images ? JSON.parse(archetype.images) : [];
+          imageCount = Array.isArray(images) ? images.length : 0;
+        } catch (error) {
+          await this.log('warn', `Failed to parse images for archetype ${archetype.id}`, {
+            archetypeIndex: archetype.archetypeIndex,
+            gender,
+            language,
+            userId,
+            error: error instanceof Error ? error.message : String(error),
+          });
+          continue;
+        }
+
+        if (imageCount >= 3) {
+          await db
             .update(schema.archetypesData)
             .set({
-              images: '[]',
-              status: 'idle',
+              status: 'completed',
               updatedAt: new Date().getTime(),
             })
-            .where(eq(schema.archetypesData.id, archetype.id))
-            .execute();
-          await this.log('info', 'Reset images and status for archetype', {
-            archetypeId: archetype.id,
+            .where(
+              and(
+                eq(schema.archetypesData.id, archetype.id),
+                eq(schema.archetypesData.gender, gender),
+                eq(schema.archetypesData.language, language),
+                eq(schema.archetypesData.archetypeIndex, archetype.archetypeIndex)
+              )
+            );
+          await this.log('info', `Updated status to 'completed' for archetype ${archetype.id}`, {
+            archetypeIndex: archetype.archetypeIndex,
+            gender,
+            language,
+            imageCount,
+            userId,
+          });
+        } else {
+          await this.log('debug', `Skipping status update for archetype ${archetype.id}`, {
+            reason: `Fewer than 3 images (found ${imageCount})`,
+            archetypeIndex: archetype.archetypeIndex,
+            gender,
+            language,
+            userId,
           });
         }
-
-        // Process image generation directly
-        await this.leonardoService.processArchetypePopulation({
-          archetypeDataId: archetype.id,
-        });
-
-        // Note: processArchetypePopulation sets status to 'pending' in the generations table
-        // Update archetype status to 'pending' for consistency
-        await this.context.drizzle()
-          .update(schema.archetypesData)
-          .set({
-            status: 'pending',
-            updatedAt: new Date().getTime(),
-          })
-          .where(eq(schema.archetypesData.id, archetype.id))
-          .execute();
       }
 
-      await this.log('info', 'Image generation processing initiated', {
-        archetypesProcessed: archetypesNeedingImages.length,
+      await this.log('info', 'Completed ArchetypeWorkflow.execute', {
+        combinationString,
+        gender,
+        language,
+        userId,
       });
-      return {
-        message: 'Image generation has been queued. Please try again later.',
-      };
-    }
-
-    // Step 7: Verify all archetypes are complete
-    const incompleteArchetypes = archetypes.filter((a) => a.status !== 'generated');
-    if (incompleteArchetypes.length > 0) {
-      await this.log('warn', 'Some archetypes are not complete', {
-        incompleteArchetypeIds: incompleteArchetypes.map((a) => a.id),
-        statuses: incompleteArchetypes.map((a) => a.status),
+    } catch (error) {
+      await this.log('error', 'Error in ArchetypeWorkflow.execute', {
+        combinationString,
+        gender,
+        language,
+        userId,
+        error: error instanceof Error ? error.message : String(error),
       });
-      return {
-        message: 'Archetype generation is still in progress. Please try again later.',
-      };
+      throw error;
     }
-
-    await this.log('info', 'All archetypes are complete', {
-      archetypesCount: archetypes.length,
-      archetypeIds: archetypes.map((a) => a.id),
-    });
-
-    return {
-      archetypes: archetypes.map(
-        ({ id, name, essenceLine, description, virtues, images }) => ({
-          id,
-          name,
-          essenceLine,
-          description,
-          virtues: JSON.parse(virtues),
-          images: JSON.parse(images),
-        })
-      ),
-    };
   }
 }

package/package.json

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

package/types/scopes/generic.ts

@@ -31,7 +31,7 @@ export type PlacementType =
   | 'karmic_point'
   | 'arabic_part';
 
-export const VALID_GENDERS_ARRAY = ['male', 'female', 'non-binary'] as const;
+export const VALID_GENDERS_ARRAY = ['male', 'female'] as const;
 
 export type Gender = (typeof VALID_GENDERS_ARRAY)[number];
 

package/utils/buildMessages.ts

@@ -25,7 +25,7 @@ export const buildLLMMessages = (env: BackendBindings) => ({
         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.
   
-  Each archetype is influenced by the zodiac combination (Sun, Ascendant, Moon), and each one emphasizes one of those signs respectively.
+  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.
   
   Please provide: