@zodic/shared 0.0.372 → 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, inArray } 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,205 +17,210 @@ export class ArchetypeWorkflow {
     message: string,
     context: Record<string, any> = {}
   ) {
-    const logId = `archetype-workflow:${Date.now()}`;
-    const logMessage = `[${level.toUpperCase()}] ${message}`;
-
+    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'
+    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: Check if archetypes exist, if not, generate names
-    let archetypes = await this.archetypeService.fetchArchetypesFromDB(
-      combinationString,
-      gender,
-      language
-    );
-    if (archetypes.length === 0) {
-      await this.log('info', 'No archetypes found, generating names', {
+
+    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 descriptions and virtues for both genders
+      await this.log('debug', 'Generating descriptions and virtues', {
         combinationString,
         gender,
         language,
+        override,
+        userId,
       });
-      await this.archetypeService.generateArchetypeNames(combinationString);
-      archetypes = await this.archetypeService.fetchArchetypesFromDB(
+      const descriptions = await this.archetypeService.generateDescriptionsAndVirtues(
         combinationString,
-        gender,
-        language
-      );
-    }
-    await this.log('info', 'Fetched archetypes', {
-      archetypesCount: archetypes.length,
-      archetypeIds: archetypes.map((a) => a.id),
-    });
-  
-    // Step 2: Check if any archetypes are already being processed (images are generating)
-    const db = this.context.drizzle();
-    await this.log('debug', 'Checking for in-progress image generations', {
-      combinationString,
-      gender,
-    });
-    const inProgressGenerations = await db
-      .select()
-      .from(schema.generations)
-      .where(
-        and(
-          eq(schema.generations.status, 'pending'),
-          eq(schema.generations.gender, gender),
-          inArray(
-            schema.generations.archetypeDataId,
-            archetypes.map((a) => a.id)
-          )
-        )
-      )
-      .execute();
-  
-    if (inProgressGenerations.length > 0) {
-      await this.log(
-        'warn',
-        `Images are already being processed for ${combinationString}, gender: ${gender}`,
-        {
-          inProgressGenerationsCount: inProgressGenerations.length,
-          generationIds: inProgressGenerations.map((g) => g.id),
-        }
+        gender, // Service processes both genders internally
+        language,
+        override
       );
-      return { message: 'Images are being processed, please try again later.' };
-    }
-    await this.log('info', 'No in-progress image generations found', {
-      combinationString,
-      gender,
-    });
-  
-    // Step 3: Generate missing textual content (description, virtues, content, leonardoPrompt)
-    const archetypesNeedingText = archetypes.filter(
-      (arc) =>
-        !arc.description ||
-        arc.virtues === '[]' ||
-        arc.content === '[]' ||
-        !arc.leonardoPrompt
-    );
-  
-    if (archetypesNeedingText.length > 0) {
-      await this.log('info', 'Generating missing textual content', {
+
+      // Step 3: Generate content for both genders
+      await this.log('debug', 'Generating content', {
         combinationString,
         gender,
         language,
-        archetypesNeedingTextCount: archetypesNeedingText.length,
-        archetypeIds: archetypesNeedingText.map((a) => a.id),
+        override,
+        userId,
       });
-  
-      const descVirtues =
-        await this.archetypeService.generateDescriptionsAndVirtues(
-          combinationString,
-          gender,
-          language
-        );
       await this.archetypeService.generateContent(
         combinationString,
-        gender,
+        gender, // Service processes both genders internally
         language,
-        descVirtues
+        descriptions,
+        override
       );
+
+      // Step 4: Generate Leonardo prompts for both genders
+      await this.log('debug', 'Generating Leonardo prompts', {
+        combinationString,
+        gender,
+        language,
+        override,
+        userId,
+      });
       await this.archetypeService.generateLeonardoPrompts(
+        combinationString,
+        gender, // Service processes both genders internally
+        language,
+        descriptions,
+        override
+      );
+
+      // Step 5: Fetch archetypes for the requested gender only for image generation
+      await this.log('debug', 'Fetching archetypes for image generation', {
         combinationString,
         gender,
         language,
-        descVirtues
+        userId,
+      });
+      const archetypes = await this.archetypeService.fetchArchetypesFromDB(
+        combinationString,
+        gender, // Fetch only the requested gender
+        language
       );
-    } else {
-      await this.log('info', 'No textual content generation needed', {
+
+      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}`
+        );
+      }
+
+      // 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;
+        }
+
+        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,
+          });
+        }
+      }
+
+      // 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,
       });
-    }
-  
-    // Refetch archetypes after generating textual content
-    const updatedArchetypes = await this.archetypeService.fetchArchetypesFromDB(
-      combinationString,
-      gender,
-      language
-    );
-    await this.log('info', 'Refetched archetypes', {
-      updatedArchetypesCount: updatedArchetypes.length,
-      archetypeIds: updatedArchetypes.map((a) => a.id),
-    });
-  
-    // Step 4: Queue image generation if needed
-    const archetypesNeedingImages = updatedArchetypes.filter(
-      (arc) => JSON.parse(arc.images).length < 3
-    );
-  
-    if (archetypesNeedingImages.length > 0) {
-      await this.log(
-        'info',
-        'Queuing image generation for missing archetypes',
-        {
-          archetypesNeedingImagesCount: archetypesNeedingImages.length,
-          archetypeIds: archetypesNeedingImages.map((a) => a.id),
+      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;
         }
-      );
-  
-      const batch = archetypesNeedingImages.map((arc) => ({
-        body: {
-          archetypeDataId: arc.id,
-        },
-      }));
-      await this.log('debug', 'Sending batch to ARCHETYPE_POPULATION_QUEUE', {
-        batchCount: batch.length,
-        batch,
+
+        if (imageCount >= 3) {
+          await db
+            .update(schema.archetypesData)
+            .set({
+              status: 'completed',
+              updatedAt: new Date().getTime(),
+            })
+            .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,
+          });
+        }
+      }
+
+      await this.log('info', 'Completed ArchetypeWorkflow.execute', {
+        combinationString,
+        gender,
+        language,
+        userId,
       });
-      await this.context.env.ARCHETYPE_POPULATION_QUEUE.sendBatch(batch);
-      await this.log('info', 'Successfully queued image generation', {
-        batchCount: batch.length,
+    } catch (error) {
+      await this.log('error', 'Error in ArchetypeWorkflow.execute', {
+        combinationString,
+        gender,
+        language,
+        userId,
+        error: error instanceof Error ? error.message : String(error),
       });
-  
-      return { message: 'Images are being processed, please try again later.' };
+      throw error;
     }
-  
-    await this.log('info', 'Archetypes fully processed and ready', {
-      updatedArchetypes,
-    });
-    return {
-      archetypes: updatedArchetypes.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.372",
+  "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];