@zodic/shared 0.0.371 → 0.0.373

package/app/services/ConceptService.ts

@@ -342,14 +342,14 @@ export class ConceptService {
     console.log(
       `[${new Date().toISOString()}] 🚀 Generating Leonardo prompt for concept: ${conceptSlug}, combination: ${combinationString}, override: ${override}`
     );
-  
+
     const db = drizzle(this.context.env.DB); // ✅ Initialize Drizzle with Cloudflare D1
-  
+
     // ✅ Fetch concept data from D1 for both languages
     console.log(
       `[${new Date().toISOString()}] 📡 Fetching concept data for ${conceptSlug}:${combinationString}`
     );
-  
+
     const conceptEntries = await db
       .select({
         id: conceptsData.id,
@@ -368,28 +368,34 @@ export class ConceptService {
         )
       )
       .execute();
-  
+
     if (conceptEntries.length !== 2) {
       throw new Error(
         `❌ Missing concept data for ${conceptSlug}:${combinationString}. Ensure basic info is populated first.`
       );
     }
-  
+
     const conceptEN = conceptEntries.find((c) => c.language === 'en-us');
     const conceptPT = conceptEntries.find((c) => c.language === 'pt-br');
-  
+
     if (!conceptEN || !conceptPT) {
       throw new Error(`❌ Could not find both EN and PT versions.`);
     }
-  
+
+    const leonardoPromptExistsEN =
+      conceptEN.leonardoPrompt && conceptEN.leonardoPrompt.length > 4;
+
+    const leonardoPromptExistsPT =
+      conceptPT.leonardoPrompt && conceptPT.leonardoPrompt.length > 4;
+
     // ✅ Check if prompt already exists and skip if override is false
-    if (!override && conceptEN.leonardoPrompt && conceptPT.leonardoPrompt) {
+    if (!override && leonardoPromptExistsEN && leonardoPromptExistsPT) {
       console.log(
         `[${new Date().toISOString()}] ⚡ Leonardo prompt already exists for ${conceptSlug}, skipping.`
       );
-      return { generatedPrompt: conceptEN.leonardoPrompt };
+      return { generatedPrompt: conceptEN.leonardoPrompt! };
     }
-  
+
     // ✅ Ensure basic info is present
     if (
       !conceptEN.name ||
@@ -403,7 +409,7 @@ export class ConceptService {
         `❌ Basic info must be populated before generating Leonardo prompt for concept: ${conceptSlug}`
       );
     }
-  
+
     // ✅ Generate prompt request
     const messages = this.context
       .buildLLMMessages()
@@ -411,7 +417,7 @@ export class ConceptService {
         conceptSlug,
         combination: combinationString,
       });
-  
+
     // ✅ Call ChatGPT API
     const response = await this.context.api().callTogether.single(messages, {});
     if (!response) {
@@ -419,25 +425,28 @@ export class ConceptService {
         `❌ Failed to generate Leonardo prompt for concept: ${conceptSlug}`
       );
     }
-  
+
     // Clean the response to remove unwanted elements
     let generatedPrompt = response.trim();
-  
+
     // Step 1: Remove **Prompt:** or Prompt: from the start
-    generatedPrompt = generatedPrompt.replace(/^(?:\*\*Prompt:\*\*|Prompt:)\s*/, '');
-  
+    generatedPrompt = generatedPrompt.replace(
+      /^(?:\*\*Prompt:\*\*|Prompt:)\s*/,
+      ''
+    );
+
     // Step 2: Remove character count suffix (e.g., *(Character count: 749)* or *(1498 characters)*)
     generatedPrompt = generatedPrompt.replace(/\s*\*\([^()]*\)*\s*$/, '');
-  
+
     // Step 3: Remove surrounding quotes if they wrap the entire prompt
     if (generatedPrompt.startsWith('"') && generatedPrompt.endsWith('"')) {
       generatedPrompt = generatedPrompt.slice(1, -1).trim();
     }
-  
+
     console.log(
       `[${new Date().toISOString()}] ✨ Cleaned generated prompt: "${generatedPrompt}"`
     );
-  
+
     // ✅ Store the generated prompt in D1 for both languages
     console.log(
       `[${new Date().toISOString()}] 💾 Storing Leonardo prompt for ${conceptSlug}:${combinationString} in D1...`
@@ -462,11 +471,11 @@ export class ConceptService {
           )
         ),
     ]);
-  
+
     console.log(
       `[${new Date().toISOString()}] ✅ Leonardo prompt stored for concept: ${conceptSlug}, combination: ${combinationString}, in both languages.`
     );
-  
+
     return { generatedPrompt };
   }
 
@@ -1817,41 +1826,44 @@ export class ConceptService {
       .limit(1)
       .execute();
 
-    return !!conceptData?.leonardoPrompt && conceptData.leonardoPrompt.length > 10;
+    return (
+      !!conceptData?.leonardoPrompt && conceptData.leonardoPrompt.length > 10
+    );
   }
 
-// src/services/ConceptService.ts
-async checkConceptCompletion(
-  conceptSlug: Concept,
-  combinationString: string,
-  lang: string = 'en-us'
-): Promise<boolean> {
-  const db = this.context.drizzle();
-  const [conceptData] = await db
-    .select({
-      leonardoPrompt: schema.conceptsData.leonardoPrompt,
-      postImages: schema.conceptsData.postImages,
-      reelImages: schema.conceptsData.reelImages,
-    })
-    .from(schema.conceptsData)
-    .where(
-      and(
-        eq(schema.conceptsData.conceptSlug, conceptSlug),
-        eq(schema.conceptsData.combination, combinationString),
-        eq(schema.conceptsData.language, lang)
+  // src/services/ConceptService.ts
+  async checkConceptCompletion(
+    conceptSlug: Concept,
+    combinationString: string,
+    lang: string = 'en-us'
+  ): Promise<boolean> {
+    const db = this.context.drizzle();
+    const [conceptData] = await db
+      .select({
+        leonardoPrompt: schema.conceptsData.leonardoPrompt,
+        postImages: schema.conceptsData.postImages,
+        reelImages: schema.conceptsData.reelImages,
+      })
+      .from(schema.conceptsData)
+      .where(
+        and(
+          eq(schema.conceptsData.conceptSlug, conceptSlug),
+          eq(schema.conceptsData.combination, combinationString),
+          eq(schema.conceptsData.language, lang)
+        )
       )
-    )
-    .limit(1)
-    .execute();
-
-  if (!conceptData) return false; // No concept data found
+      .limit(1)
+      .execute();
 
-  // Check if postImages and reelImages are valid non-empty JSON arrays
-  const hasPostImages =
-    conceptData.postImages &&
-    conceptData.postImages.trim().length > 4 && // Ensures length > 4 to exclude "[]"
-    JSON.parse(conceptData.postImages).length > 2;
+    if (!conceptData) return false; // No concept data found
+    const hasPrompt =
+      !!conceptData?.leonardoPrompt && conceptData.leonardoPrompt.length > 10;
+    // Check if postImages and reelImages are valid non-empty JSON arrays
+    const hasPostImages =
+      conceptData.postImages &&
+      conceptData.postImages.trim().length > 4 && // Ensures length > 4 to exclude "[]"
+      JSON.parse(conceptData.postImages).length > 2;
 
-  return !!conceptData.leonardoPrompt && !!hasPostImages;
-}
+    return hasPrompt && !!hasPostImages;
+  }
 }

package/app/workflow/ArchetypeWorkflow.ts

@@ -1,4 +1,4 @@
-import { and, eq, inArray } from 'drizzle-orm';
+import { and, eq } from 'drizzle-orm';
 import { inject, injectable } from 'inversify';
 import { schema } from '../..';
 import { Gender } from '../../types';
@@ -20,7 +20,7 @@ export class ArchetypeWorkflow {
     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();
@@ -48,167 +48,228 @@ export class ArchetypeWorkflow {
   async execute(
     combinationString: string,
     gender: Gender,
-    language: string = 'en-us'
+    language: string = 'en-us',
+    override: boolean = false
   ) {
     await this.log('info', 'Starting ArchetypeWorkflow', {
       combinationString,
       gender,
       language,
+      override,
     });
-  
-    // Step 1: Check if archetypes exist, if not, generate names
+
+    // Step 1: Fetch existing archetypes
     let archetypes = await this.archetypeService.fetchArchetypesFromDB(
       combinationString,
       gender,
       language
     );
-    if (archetypes.length === 0) {
-      await this.log('info', 'No archetypes found, generating names', {
+    await this.log('info', 'Fetched existing archetypes', {
+      archetypesCount: archetypes.length,
+      archetypeIds: archetypes.map((a) => a.id),
+    });
+
+    // 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', {
         combinationString,
         gender,
         language,
+        override,
       });
-      await this.archetypeService.generateArchetypeNames(combinationString);
+      await this.archetypeService.generateArchetypeNames(
+        combinationString,
+        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',
+      });
     }
-    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),
-        }
+
+    // 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', {
+        combinationString,
+        gender,
+        language,
+        override,
+      });
+      descVirtues = await this.archetypeService.generateDescriptionsAndVirtues(
+        combinationString,
+        gender,
+        language,
+        override
       );
-      return { message: 'Images are being processed, please try again later.' };
+      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',
+      });
     }
-    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 4: Generate or update content
+    if (override || archetypes.some((a) => a.content === '[]')) {
+      await this.log('info', 'Generating or updating content', {
         combinationString,
         gender,
         language,
-        archetypesNeedingTextCount: archetypesNeedingText.length,
-        archetypeIds: archetypesNeedingText.map((a) => a.id),
-      });
-  
-      const descVirtues =
-        await this.archetypeService.generateDescriptionsAndVirtues(
-          combinationString,
-          gender,
-          language
-        );
+        override,
+      });
       await this.archetypeService.generateContent(
         combinationString,
         gender,
         language,
-        descVirtues
+        descVirtues,
+        override
       );
-      await this.archetypeService.generateLeonardoPrompts(
+      archetypes = await this.archetypeService.fetchArchetypesFromDB(
         combinationString,
         gender,
-        language,
-        descVirtues
+        language
       );
+      await this.log('info', 'Refetched archetypes after content generation', {
+        archetypesCount: archetypes.length,
+        archetypeIds: archetypes.map((a) => a.id),
+      });
     } else {
-      await this.log('info', 'No textual content generation needed', {
+      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', {
         combinationString,
         gender,
         language,
+        override,
+      });
+      await this.archetypeService.generateLeonardoPrompts(
+        combinationString,
+        gender,
+        language,
+        descVirtues,
+        override
+      );
+      archetypes = await this.archetypeService.fetchArchetypesFromDB(
+        combinationString,
+        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',
       });
     }
-  
-    // 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
+
+    // Step 6: Process image generation if needed
+    const archetypesNeedingImages = archetypes.filter(
+      (arc) => JSON.parse(arc.images).length < 3 || (override && arc.images !== '[]')
     );
-  
+
     if (archetypesNeedingImages.length > 0) {
-      await this.log(
-        'info',
-        'Queuing image generation for missing archetypes',
-        {
-          archetypesNeedingImagesCount: archetypesNeedingImages.length,
-          archetypeIds: archetypesNeedingImages.map((a) => a.id),
+      await this.log('info', 'Processing image generation for archetypes', {
+        archetypesNeedingImagesCount: archetypesNeedingImages.length,
+        archetypeIds: archetypesNeedingImages.map((a) => a.id),
+      });
+
+      for (const archetype of archetypesNeedingImages) {
+        await this.log('debug', 'Processing image generation', {
+          archetypeId: archetype.id,
+          leonardoPrompt: archetype.leonardoPrompt,
+        });
+
+        // Reset images and status if override is true
+        if (override) {
+          await this.context.drizzle()
+            .update(schema.archetypesData)
+            .set({
+              images: '[]',
+              status: 'idle',
+              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,
+          });
         }
-      );
-  
-      const batch = archetypesNeedingImages.map((arc) => ({
-        body: {
-          archetypeDataId: arc.id,
-        },
-      }));
-      await this.log('debug', 'Sending batch to ARCHETYPE_POPULATION_QUEUE', {
-        batchCount: batch.length,
-        batch,
-      });
-      await this.context.env.ARCHETYPE_POPULATION_QUEUE.sendBatch(batch);
-      await this.log('info', 'Successfully queued image generation', {
-        batchCount: batch.length,
-      });
-  
-      return { message: 'Images are being processed, please try again later.' };
+
+        // 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,
+      });
+      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),
+      });
+      return {
+        message: 'Archetype generation is still in progress. Please try again later.',
+      };
     }
-  
-    await this.log('info', 'Archetypes fully processed and ready', {
-      updatedArchetypes,
+
+    await this.log('info', 'All archetypes are complete', {
+      archetypesCount: archetypes.length,
+      archetypeIds: archetypes.map((a) => a.id),
     });
+
     return {
-      archetypes: updatedArchetypes.map(
+      archetypes: archetypes.map(
         ({ id, name, essenceLine, description, virtues, images }) => ({
           id,
           name,
@@ -220,4 +281,4 @@ export class ArchetypeWorkflow {
       ),
     };
   }
-}
+}

package/package.json

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