@zodic/shared 0.0.373 → 0.0.374

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.374",
   "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];