@zodic/shared 0.0.314 → 0.0.316

package/app/workflow/ArchetypeWorkflow.ts

@@ -1,8 +1,8 @@
+import { and, eq } from 'drizzle-orm';
 import { inject, injectable } from 'inversify';
+import { schema } from '../..';
 import { Gender } from '../../types';
-import { KVArchetype } from '../../types/scopes/legacy';
-import { buildCosmicMirrorArchetypeKVKey } from '../../utils/KVKeysBuilders';
-import { AppContext } from '../base/AppContext';
+import { AppContext } from '../base';
 import { ArchetypeService } from '../services/ArchetypeService';
 import { LeonardoService } from '../services/LeonardoService';
 
@@ -14,176 +14,210 @@ export class ArchetypeWorkflow {
     @inject(LeonardoService) private leonardoService: LeonardoService
   ) {}
 
-  async execute(combinationString: string, gender: Gender) {
-    console.log('Starting ArchetypeWorkflow for:', {
+  private async log(
+    level: 'info' | 'debug' | 'warn' | 'error',
+    message: string,
+    context: Record<string, any> = {}
+  ) {
+    const logId = `archetype-workflow:${Date.now()}`;
+    const logMessage = `[${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'
+  ) {
+    await this.log('info', 'Starting ArchetypeWorkflow', {
       combinationString,
       gender,
+      language,
     });
 
-    const archetypes = await this.fetchArchetypesFromKV(
+    // Step 1: Check if archetypes exist, if not, generate names
+    let archetypes = await this.archetypeService.fetchArchetypesFromDB(
       combinationString,
-      gender
+      gender,
+      language
     );
+    if (archetypes.length === 0) {
+      await this.log('info', 'No archetypes found, generating names', {
+        combinationString,
+        gender,
+        language,
+      });
+      await this.archetypeService.generateArchetypeNames(combinationString);
+      archetypes = await this.archetypeService.fetchArchetypesFromDB(
+        combinationString,
+        gender,
+        language
+      );
+    }
+    await this.log('info', 'Fetched archetypes', {
+      archetypesCount: archetypes.length,
+      archetypeIds: archetypes.map((a) => a.id),
+    });
 
-    if (archetypes.some((arc) => arc.status === 'generating')) {
-      console.log(
-        `Archetypes are already being processed for ${combinationString}, gender: ${gender}`
+    // 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),
+          eq(schema.generations.archetypeDataId, combinationString)
+        )
+      )
+      .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),
+        }
       );
       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 (archetypes.some((arc) => !arc.name || arc.images.length < 3)) {
-      console.log(
-        `Generating missing basic info for: ${combinationString}, gender: ${gender}`
+    if (archetypesNeedingText.length > 0) {
+      await this.log('info', 'Generating missing textual content', {
+        combinationString,
+        gender,
+        language,
+        archetypesNeedingTextCount: archetypesNeedingText.length,
+        archetypeIds: archetypesNeedingText.map((a) => a.id),
+      });
+
+      const descVirtues =
+        await this.archetypeService.generateDescriptionsAndVirtues(
+          combinationString,
+          gender,
+          language
+        );
+      await this.archetypeService.generateContent(
+        combinationString,
+        gender,
+        language,
+        descVirtues
       );
-      await this.archetypeService.generateBasicInfo(combinationString);
+      await this.archetypeService.generateLeonardoPrompts(
+        combinationString,
+        gender,
+        language,
+        descVirtues
+      );
+    } else {
+      await this.log('info', 'No textual content generation needed', {
+        combinationString,
+        gender,
+        language,
+      });
     }
 
-    const updatedArchetypes = await this.fetchArchetypesFromKV(
+    // Refetch archetypes after generating textual content
+    const updatedArchetypes = await this.archetypeService.fetchArchetypesFromDB(
       combinationString,
-      gender
+      gender,
+      language
     );
+    await this.log('info', 'Refetched archetypes', {
+      updatedArchetypesCount: updatedArchetypes.length,
+      archetypeIds: updatedArchetypes.map((a) => a.id),
+    });
 
-    if (updatedArchetypes.some((arc) => !arc.leonardoPrompt)) {
-      console.log('Generating missing Leonardo prompts...');
-      await this.leonardoService.processArchetypesPrompts(combinationString);
-    }
-
+    // Step 4: Queue image generation if needed
     const archetypesNeedingImages = updatedArchetypes.filter(
-      (arc) => arc.images.length < 3
+      (arc) => JSON.parse(arc.images).length < 3
     );
 
     if (archetypesNeedingImages.length > 0) {
-      console.log('Queuing image generation for missing archetypes...');
-      await this.updateArchetypeStatus(updatedArchetypes, 'generating', gender);
+      await this.log(
+        'info',
+        'Queuing image generation for missing archetypes',
+        {
+          archetypesNeedingImagesCount: archetypesNeedingImages.length,
+          archetypeIds: archetypesNeedingImages.map((a) => a.id),
+        }
+      );
 
-      try {
-        await this.leonardoService.queueImagesForArchetypes(
-          combinationString,
-          gender
-        );
-      } catch (error) {
-        console.error('Error queuing image generation:', error);
-        await this.updateArchetypeStatus(updatedArchetypes, 'idle', gender);
-        throw error;
-      }
+      const batch = archetypesNeedingImages.map((arc) => ({
+        body: {
+          archetypeDataId: arc.id,
+          combination: combinationString,
+          gender,
+          language,
+          archetypeIndex: arc.archetypeIndex,
+        },
+      }));
+      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.' };
     }
 
-    await this.updateArchetypeStatus(updatedArchetypes, 'idle', gender);
-
-    console.log('Archetypes fully processed and ready:', updatedArchetypes);
+    await this.log('info', 'Archetypes fully processed and ready', {
+      updatedArchetypes,
+    });
     return {
       archetypes: updatedArchetypes.map(
-        ({ name, content, description, virtues, images }) => ({
+        ({ name, essenceLine, description, virtues, images }) => ({
           name,
-          content,
+          essenceLine,
           description,
-          virtues,
-          images,
+          virtues: JSON.parse(virtues),
+          images: JSON.parse(images),
         })
       ),
     };
   }
-
-  async generateNames({
-    combinations,
-    overrideExisting,
-  }: {
-    combinations: string[];
-    overrideExisting?: boolean;
-  }): Promise<void> {
-    if (combinations.length === 0) return;
-
-    if (combinations.length === 1) {
-      await this.archetypeService.generateArchetypeNames(
-        combinations[0],
-        overrideExisting
-      );
-    } else {
-      const entries = combinations.map((combination) => ({
-        combination,
-      }));
-
-      await this.archetypeService.generateArchetypeNamesBatch(
-        entries,
-        overrideExisting
-      );
-    }
-  }
-
-  /**
-   * Fetch all three archetypes from KV for a given combination and gender.
-   */
-  private async fetchArchetypesFromKV(
-    combinationString: string,
-    gender: Gender
-  ): Promise<KVArchetype[]> {
-    return Promise.all(
-      Array.from({ length: 3 }, (_, i) => i + 1).map(async (index) => {
-        const kvKey = buildCosmicMirrorArchetypeKVKey(
-          'en-us',
-          combinationString,
-          gender,
-          index
-        );
-        console.log(`Fetching archetype from KV: ${kvKey}`);
-
-        try {
-          return (
-            (await this.context
-              .kvCosmicMirrorArchetypesStore()
-              .get<KVArchetype>(kvKey, 'json')) || this.createEmptyArchetype()
-          );
-        } catch (error) {
-          console.error(
-            `Error fetching archetype KV for index ${index}:`,
-            error
-          );
-          return this.createEmptyArchetype();
-        }
-      })
-    );
-  }
-
-  /**
-   * Update the status of archetypes in KV.
-   */
-  private async updateArchetypeStatus(
-    archetypes: KVArchetype[],
-    status: 'idle' | 'generating',
-    gender: Gender
-  ): Promise<void> {
-    await Promise.all(
-      archetypes.map(async (archetype, index) => {
-        const kvKey = buildCosmicMirrorArchetypeKVKey(
-          'en-us',
-          archetype.name,
-          gender,
-          index + 1
-        );
-        archetype.status = status;
-        await this.context
-          .kvCosmicMirrorArchetypesStore()
-          .put(kvKey, JSON.stringify(archetype));
-      })
-    );
-  }
-
-  /**
-   * Create an empty KVArchetype object when KV data is missing.
-   */
-  private createEmptyArchetype(): KVArchetype {
-    return {
-      name: '',
-      description: '',
-      content: '',
-      leonardoPrompt: '',
-      visualDescription: '',
-      virtues: [],
-      images: [],
-      status: 'idle',
-    };
-  }
 }

package/db/migrations/0014_green_marvel_apes.sql

@@ -0,0 +1,10 @@
+CREATE TABLE `logs` (
+	`id` text PRIMARY KEY NOT NULL,
+	`level` text NOT NULL,
+	`message` text NOT NULL,
+	`context` text DEFAULT '{}' NOT NULL,
+	`created_at` integer DEFAULT CURRENT_TIMESTAMP
+);
+--> statement-breakpoint
+ALTER TABLE `generations` ADD `archetype_data_id` text REFERENCES archetypes_data(id);--> statement-breakpoint
+CREATE INDEX `generations_archetype_data_id_idx` ON `generations` (`archetype_data_id`);