@zodic/shared 0.0.76 → 0.0.77

package/app/services/LeonardoService.ts

@@ -0,0 +1,197 @@
+import { inject, injectable } from 'inversify';
+import 'reflect-metadata';
+import { schema } from '../..';
+import { Gender, VALID_GENDERS_ARRAY } from '../../types';
+import {
+  KVArchetype,
+  LeonardoGenerateImageResponse,
+  sizes,
+} from '../../types/scopes/legacy';
+import { buildCosmicMirrorArchetypeKVKey } from '../../utils/KVKeysBuilders';
+import { AppContext } from '../base/AppContext';
+
+@injectable()
+export class LeonardoService {
+  constructor(@inject(AppContext) private context: AppContext) {}
+
+  /**
+   * Processes and generates missing Leonardo prompts for archetypes.
+   */
+  async processArchetypesPrompts(crown: string): Promise<void> {
+    console.log(`Processing Leonardo prompts for crown: ${crown}`);
+
+    const promptsToGenerate: Array<{
+      kvKey: string;
+      name: string;
+      visualDescription: string;
+    }> = [];
+
+    // Fetch archetypes that need prompts
+    for (const gender of VALID_GENDERS_ARRAY) {
+      for (let index = 1; index <= 3; index++) {
+        const kvKey = buildCosmicMirrorArchetypeKVKey(
+          'en-us',
+          crown,
+          gender,
+          index
+        );
+        console.log(`Fetching archetype from KV: ${kvKey}`);
+
+        const kvData = await this.context
+          .kvCosmicMirrorArchetypesStore()
+          .get<KVArchetype>(kvKey, 'json');
+        if (kvData && !kvData.leonardoPrompt) {
+          promptsToGenerate.push({
+            kvKey,
+            name: kvData.name,
+            visualDescription: kvData.visualDescription,
+          });
+        }
+      }
+    }
+
+    if (promptsToGenerate.length === 0) {
+      console.log('No archetype prompts need to be generated.');
+      return;
+    }
+
+    console.log('Archetypes requiring prompt generation:', promptsToGenerate);
+
+    // Generate prompts
+    const archetypes = promptsToGenerate.map(({ name, visualDescription }) => ({
+      name,
+      visualDescription,
+    }));
+    const leonardoPrompts =
+      await this.generateCosmicMirrorArchetypesLeonardoPrompts(archetypes);
+
+    if (leonardoPrompts.length !== archetypes.length) {
+      throw new Error('Mismatch between archetypes and generated prompts.');
+    }
+
+    // Update KV with generated prompts
+    for (const [index, promptSet] of leonardoPrompts.entries()) {
+      const { kvKey } = promptsToGenerate[index];
+      console.log(`Updating KV with prompts for archetype: ${kvKey}`);
+
+      const kvData = await this.context
+        .kvCosmicMirrorArchetypesStore()
+        .get<KVArchetype>(kvKey, 'json');
+      if (!kvData) {
+        console.warn(`KV data not found for key: ${kvKey}. Skipping update.`);
+        continue;
+      }
+
+      kvData.leonardoPrompt = promptSet;
+      await this.context
+        .kvCosmicMirrorArchetypesStore()
+        .put(kvKey, JSON.stringify(kvData));
+    }
+
+    console.log(`Completed prompt processing for crown: ${crown}`);
+  }
+
+  /**
+   * Queues image generation for archetypes if no images exist.
+   */
+  async queueImagesForArchetypes(crown: string, gender: Gender): Promise<void> {
+    console.log(
+      `Queuing image generation for crown: ${crown}, gender: ${gender}`
+    );
+
+    for (let index = 1; index <= 3; index++) {
+      const kvKey = buildCosmicMirrorArchetypeKVKey(
+        'en-us',
+        crown,
+        gender,
+        index
+      );
+      console.info(`Fetching KV for archetype: ${kvKey}`);
+
+      const kvData = await this.context
+        .kvCosmicMirrorArchetypesStore()
+        .get<KVArchetype>(kvKey, 'json');
+      if (!kvData || kvData.images.length >= 3) {
+        console.info(
+          `Skipping image generation for index ${index}, images already exist.`
+        );
+        continue;
+      }
+
+      console.info(`No images found. Queuing generation for index ${index}...`);
+
+      const generationResponse = await this.queueImageGeneration(
+        kvData.leonardoPrompt
+      );
+      const generationId = generationResponse.sdGenerationJob.generationId;
+
+      if (!generationId) {
+        throw new Error('Leonardo generation failed to return a valid ID.');
+      }
+
+      await this.context.drizzle().insert(schema.generations).values({
+        id: generationId,
+        archetypeIndex: index,
+        conceptCombinationId: null,
+        type: 'archetype_image',
+        status: 'pending',
+        createdAt: new Date(),
+      });
+
+      console.info(
+        `Queued generation ${generationId} for archetype index ${index}`
+      );
+    }
+  }
+
+  /**
+   * Generates Leonardo prompts for archetypes.
+   */
+  private async generateCosmicMirrorArchetypesLeonardoPrompts(
+    archetypes: Array<{ name: string; visualDescription: string }>
+  ): Promise<string[]> {
+    console.log(`Generating Leonardo prompts for archetypes`);
+
+    const messages = this.context
+      .buildLLMMessages()
+      .generateCosmicMirrorArchetypesLeonardoPrompts(archetypes);
+    const response = await this.context.api().callDeepSeek.single(messages, {});
+
+    if (!response) {
+      throw new Error('Leonardo prompts not generated');
+    }
+
+    console.log('Leonardo Prompts from API -> ', response);
+
+    return response
+      .split('\n')
+      .map((prompt) => prompt.trim())
+      .filter(Boolean);
+  }
+
+  /**
+   * Queues an image generation request to Leonardo.
+   */
+  private async queueImageGeneration(
+    prompt: string
+  ): Promise<LeonardoGenerateImageResponse> {
+    console.log(`Queuing Leonardo image generation...`);
+
+    const { width, height } = sizes['alchemy']['post4:5'];
+
+    try {
+      const response = await this.context
+        .api()
+        .callLeonardo.generateImage({ width, height, prompt });
+      if (!response) {
+        throw new Error('Leonardo image generation failed');
+      }
+
+      console.log('Leonardo Image Generation Response:', response);
+      return response;
+    } catch (error) {
+      console.error('Error queuing Leonardo image generation:', error);
+      throw error;
+    }
+  }
+}

package/app/workflow/ArchetypeWorkflow.ts

@@ -0,0 +1,156 @@
+import { inject, injectable } from 'inversify';
+import { Gender } from '../../types';
+import { KVArchetype } from '../../types/scopes/legacy';
+import { AppContext } from '../base';
+import { ArchetypeService } from '../services/ArchetypeService';
+import { LeonardoService } from '../services/LeonardoService';
+
+@injectable()
+export class ArchetypeWorkflow {
+  constructor(
+    @inject(AppContext) private context: AppContext,
+    @inject(ArchetypeService) private archetypeService: ArchetypeService,
+    @inject(LeonardoService) private leonardoService: LeonardoService
+  ) {}
+
+  async execute(combinationString: string, gender: Gender) {
+    const kvKeyBase = `cosmic-mirror:archetypes:${combinationString}:${gender}`;
+
+    console.log('Starting ArchetypeWorkflow for:', {
+      combinationString,
+      gender,
+    });
+
+    const archetypes = await Promise.all(
+      Array.from({ length: 3 }, (_, i) => i + 1).map(async (index) => {
+        const kvKey = `${kvKeyBase}:${index}`;
+        try {
+          console.log(`Fetching archetype from KV: ${kvKey}`);
+          return await this.context
+            .kvCosmicMirrorArchetypesStore()
+            .get<KVArchetype>(kvKey, 'json');
+        } catch (error) {
+          console.error(
+            `Error fetching archetype KV for index ${index}:`,
+            error
+          );
+          return null;
+        }
+      })
+    ).then((results) => results.filter((result) => result !== null)); // Filter out nulls
+
+    const isGenerating = archetypes.some(
+      (archetype) => archetype?.status === 'generating'
+    );
+
+    if (isGenerating) {
+      console.log(
+        `Archetype images are already being generated for: ${combinationString}, gender: ${gender}`
+      );
+      return { message: 'Images are being processed, please try again later.' };
+    }
+
+    const missingOrIncomplete =
+      archetypes.length < 3 ||
+      archetypes.some((archetype) => archetype?.images.length < 3);
+
+    if (missingOrIncomplete) {
+      console.log(
+        `Archetypes missing or incomplete for combination: ${combinationString}, gender: ${gender}. Generating...`
+      );
+
+      await this.archetypeService.generateBasicInfo(combinationString);
+
+      const updatedArchetypes = await Promise.all(
+        Array.from({ length: 3 }, (_, i) => i + 1).map(async (index) => {
+          const kvKey = `${kvKeyBase}:${index}`;
+          try {
+            console.log(`Re-fetching archetype from KV: ${kvKey}`);
+            return await this.context
+              .kvCosmicMirrorArchetypesStore()
+              .get<KVArchetype>(kvKey, 'json');
+          } catch (error) {
+            console.error(
+              `Error fetching archetype KV after generation for index ${index}:`,
+              error
+            );
+            return null;
+          }
+        })
+      ).then((results) => results.filter((results) => results != null));
+
+      archetypes.length = 0;
+      archetypes.push(...updatedArchetypes);
+    }
+
+    const missingPrompts = archetypes.some(
+      (archetype) => !archetype?.leonardoPrompt
+    );
+
+    if (missingPrompts) {
+      console.log('Generating missing prompts...');
+      await this.leonardoService.processArchetypesPrompts(combinationString);
+    }
+
+    const archetypesNeedingImages = archetypes.filter(
+      (archetype) => archetype?.images.length < 3
+    );
+
+    if (archetypesNeedingImages.length > 0) {
+      console.log('Queuing image generation for missing archetypes...');
+      try {
+        await Promise.all(
+          archetypesNeedingImages.map(async (archetype, index) => {
+            archetype.status = 'generating';
+            const kvKey = `${kvKeyBase}:${index + 1}`;
+            await this.context
+              .kvCosmicMirrorArchetypesStore()
+              .put(kvKey, JSON.stringify(archetype));
+          })
+        );
+
+        await this.leonardoService.queueImagesForArchetypes(
+          combinationString,
+          gender
+        );
+      } catch (error) {
+        console.error('Error queuing image generation:', error);
+
+        await Promise.all(
+          archetypesNeedingImages.map(async (archetype, index) => {
+            archetype.status = 'idle';
+            const kvKey = `${kvKeyBase}:${index + 1}`;
+            await this.context
+              .kvCosmicMirrorArchetypesStore()
+              .put(kvKey, JSON.stringify(archetype));
+          })
+        );
+
+        throw error;
+      }
+
+      return { message: 'Images are being processed, please try again later.' };
+    }
+
+    await Promise.all(
+      archetypes.map(async (archetype, index) => {
+        archetype.status = 'idle';
+        const kvKey = `${kvKeyBase}:${index + 1}`;
+        await this.context
+          .kvCosmicMirrorArchetypesStore()
+          .put(kvKey, JSON.stringify(archetype));
+      })
+    );
+
+    console.log('Archetypes fully processed and ready:', archetypes);
+    return {
+      archetypes: archetypes.map((arc) => ({
+        name: arc?.name,
+        content: arc?.content,
+        description: arc?.description,
+        virtues: arc?.virtues,
+        images: arc?.images,
+      })),
+    };
+  }
+}

package/app/workflow/ConceptWorkflow.ts

@@ -18,24 +18,28 @@ export class ConceptWorkflow {
       switch (phase) {
         case 'basic-info':
           await this.conceptService.generateBasicInfo(
+            'en-us',
             conceptSlug,
             combinationString
           );
           break;
         case 'content':
           await this.conceptService.generateContent(
+            'en-us',
             conceptSlug,
             combinationString
           );
           break;
         case 'leonardo-prompt':
           await this.conceptService.generatePrompt(
+            'en-us',
             conceptSlug,
             combinationString
           );
           break;
         case 'images':
           await this.conceptService.generateImages(
+            'en-us',
             conceptSlug,
             combinationString
           );

package/package.json

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

package/utils/index.ts

@@ -1,5 +1,5 @@
 import { jwtVerify } from 'jose';
-import { AuthCtx, Provider, ProviderInfo } from '../types';
+import { AuthCtx, Gender, Provider, ProviderInfo, VALID_GENDERS_ARRAY } from '../types';
 
 export const verifyToken = async (
   c: AuthCtx,
@@ -48,3 +48,18 @@ export const providers: (c: AuthCtx) => Record<Provider, ProviderInfo> = (
     resourceUrl: '',
   },
 });
+
+export const GENDER_CODE_MAP: Record<string, Gender> =
+  VALID_GENDERS_ARRAY.reduce((map, gender) => {
+    const key = gender[0];
+    map[key] = gender;
+    return map;
+  }, {} as Record<string, Gender>);
+
+export function createEmptyGenderPrompts(): Record<Gender, string> {
+  const emptyPrompts: Record<Gender, string> = {} as Record<Gender, string>;
+  Object.values(GENDER_CODE_MAP).forEach((gender) => {
+    emptyPrompts[gender] = '';
+  });
+  return emptyPrompts;
+}