@zodic/shared 0.0.75 → 0.0.77

package/app/services/ArchetypeService.ts

@@ -0,0 +1,289 @@
+import { inject, injectable } from 'inversify';
+import { KVArchetype } from '../../types/scopes/legacy';
+import { buildCosmicMirrorArchetypeKVKey } from '../../utils/KVKeysBuilders';
+import { AppContext } from '../base';
+
+@injectable()
+export class ArchetypeService {
+  constructor(@inject(AppContext) private context: AppContext) {}
+
+  async generateBasicInfo(combinationString: string): Promise<void> {
+    console.log(
+      `Generating basic info for archetypes of combination: ${combinationString}`
+    );
+
+    const [sun, ascendant, moon] = combinationString.split('-');
+
+    const messages = this.context
+      .buildLLMMessages()
+      .generateCosmicMirrorArchetypeBasicInfo({ sun, ascendant, moon });
+
+    const response = await this.context.api().callDeepSeek.single(messages, {});
+
+    if (!response) {
+      throw new Error(
+        `Failed to generate basic info for archetypes: ${combinationString}`
+      );
+    }
+
+    const archetypes = this.parseArchetypeResponse(response);
+
+    await Promise.all(
+      archetypes.map(async (archetype, index) => {
+        const archetypeIndex = index + 1;
+
+        const maleKey = buildCosmicMirrorArchetypeKVKey(
+          'en-us',
+          combinationString,
+          'male',
+          archetypeIndex
+        );
+        const femaleKey = buildCosmicMirrorArchetypeKVKey(
+          'en-us',
+          combinationString,
+          'female',
+          archetypeIndex
+        );
+        const nonBinaryKey = buildCosmicMirrorArchetypeKVKey(
+          'en-us',
+          combinationString,
+          'non-binary',
+          archetypeIndex
+        );
+
+        const kvDataMale: KVArchetype = {
+          name: archetype.name,
+          description: archetype.descriptionMale,
+          visualDescription: archetype.visualRepresentation,
+          content: '',
+          leonardoPrompt: '',
+          virtues: archetype.virtues,
+          images: [],
+          status: 'idle',
+        };
+
+        const kvDataFemale: KVArchetype = {
+          name: archetype.name,
+          description: archetype.descriptionFemale,
+          visualDescription: archetype.visualRepresentation,
+          content: '',
+          leonardoPrompt: '',
+          virtues: archetype.virtues,
+          images: [],
+          status: 'idle',
+        };
+
+        await Promise.all([
+          this.context
+            .kvCosmicMirrorArchetypesStore()
+            .put(maleKey, JSON.stringify(kvDataMale)),
+          this.context
+            .kvCosmicMirrorArchetypesStore()
+            .put(femaleKey, JSON.stringify(kvDataFemale)),
+          this.context
+            .kvCosmicMirrorArchetypesStore()
+            .put(nonBinaryKey, JSON.stringify(kvDataFemale)),
+        ]);
+      })
+    );
+
+    console.log(
+      `Basic info stored for archetypes of combination: ${combinationString}`
+    );
+  }
+
+  private parseArchetypeResponse(response: string): Array<{
+    name: string;
+    descriptionMale: string;
+    descriptionFemale: string;
+    visualRepresentation: string;
+    virtues: string[];
+  }> {
+    console.log('Parsing archetype response from ChatGPT');
+
+    const archetypes: Array<{
+      name: string;
+      descriptionMale: string;
+      descriptionFemale: string;
+      visualRepresentation: string;
+      virtues: string[];
+    }> = [];
+
+    const entries = response.split(/\n\d+\.\n/).filter(Boolean);
+
+    for (const entry of entries) {
+      const nameMatch = entry.match(/- Name: (.+)/);
+      const descriptionMaleMatch = entry.match(
+        /- Narrative Description \(Male\): (.+)/
+      );
+      const descriptionFemaleMatch = entry.match(
+        /- Narrative Description \(Female\): (.+)/
+      );
+      const visualRepresentationMatch = entry.match(
+        /- Visual Representation: (.+)/
+      );
+      const virtuesMatch = entry.match(/- Virtues: (.+)/);
+
+      if (
+        nameMatch &&
+        descriptionMaleMatch &&
+        descriptionFemaleMatch &&
+        visualRepresentationMatch &&
+        virtuesMatch
+      ) {
+        archetypes.push({
+          name: nameMatch[1].trim(),
+          descriptionMale: descriptionMaleMatch[1].trim(),
+          descriptionFemale: descriptionFemaleMatch[1].trim(),
+          visualRepresentation: visualRepresentationMatch[1].trim(),
+          virtues: virtuesMatch[1].split(',').map((virtue) => virtue.trim()),
+        });
+      }
+    }
+
+    return archetypes;
+  }
+
+  async generatePrompts(combinationString: string): Promise<void> {
+    console.log(
+      `Generating Leonardo.ai prompts for archetypes of: ${combinationString}`
+    );
+
+    const kvStore = this.context.kvCosmicMirrorArchetypesStore();
+
+    const kvKeys = [1, 2, 3].map((index) =>
+      buildCosmicMirrorArchetypeKVKey(
+        'en-us',
+        combinationString,
+        'male',
+        index
+      )
+    );
+
+    const archetypeEntries = await Promise.all(
+      kvKeys.map((key) => kvStore.get<KVArchetype>(key))
+    );
+
+    if (archetypeEntries.some((entry) => !entry)) {
+      throw new Error(
+        `Missing archetype data for combination: ${combinationString}`
+      );
+    }
+
+    const messages = this.context
+      .buildLLMMessages()
+      .generateCosmicMirrorArchetypesLeonardoPrompts(
+        archetypeEntries.map((entry) => ({
+          name: entry!.name,
+          visualDescription: entry!.visualDescription, // Using visual description for prompt
+        }))
+      );
+
+    const response = await this.context.api().callDeepSeek.single(messages, {});
+    if (!response) {
+      throw new Error(
+        `Failed to generate Leonardo prompts for: ${combinationString}`
+      );
+    }
+
+    const parsedPrompts = this.parseLeonardoPromptResponse(response);
+
+    await Promise.all(
+      parsedPrompts.map(async (promptData, index) => {
+        const archetypeIndex = index + 1;
+
+        const maleKey = buildCosmicMirrorArchetypeKVKey(
+          'en-us',
+          combinationString,
+          'male',
+          archetypeIndex
+        );
+        const femaleKey = buildCosmicMirrorArchetypeKVKey(
+          'en-us',
+          combinationString,
+          'female',
+          archetypeIndex
+        );
+        const nonBinaryKey = buildCosmicMirrorArchetypeKVKey(
+          'en-us',
+          combinationString,
+          'non-binary',
+          archetypeIndex
+        );
+
+        const updateKV = async (key: string, updatedPrompt: string) => {
+          const existingEntry = await kvStore.get<KVArchetype>(key);
+          if (existingEntry) {
+            await kvStore.put(
+              key,
+              JSON.stringify({
+                ...existingEntry,
+                leonardoPrompt: updatedPrompt,
+              })
+            );
+          }
+        };
+
+        await Promise.all([
+          updateKV(maleKey, promptData.malePrompt),
+          updateKV(femaleKey, promptData.femalePrompt),
+          updateKV(nonBinaryKey, promptData.nonBinaryPrompt),
+        ]);
+      })
+    );
+
+    console.log(
+      `Leonardo prompts stored for archetypes of: ${combinationString}`
+    );
+  }
+
+  private parseLeonardoPromptResponse(response: string): Array<{
+    malePrompt: string;
+    femalePrompt: string;
+    nonBinaryPrompt: string;
+  }> {
+    console.log('Parsing Leonardo prompt response from ChatGPT');
+
+    const parsedPrompts: Array<{
+      malePrompt: string;
+      femalePrompt: string;
+      nonBinaryPrompt: string;
+    }> = [];
+
+    const entries = response.split(/\n\d+\.\w{1,2}\n/).filter(Boolean);
+
+    for (let i = 0; i < entries.length; i += 3) {
+      const malePrompt = entries[i]?.trim();
+      const femalePrompt = entries[i + 1]?.trim();
+      const nonBinaryPrompt = entries[i + 2]?.trim();
+
+      if (malePrompt && femalePrompt && nonBinaryPrompt) {
+        parsedPrompts.push({ malePrompt, femalePrompt, nonBinaryPrompt });
+      }
+    }
+
+    return parsedPrompts;
+  }
+
+  async generateImages(combinationString: string): Promise<void> {
+    const kvBaseKey = `archetypes:${combinationString}`;
+    console.log(
+      `Generating images for archetypes of combination: ${combinationString}`
+    );
+
+    await Promise.all(
+      [1, 2, 3].map(async (index) => {
+        const kvKey = `${kvBaseKey}:${index}`;
+        const archetype = await this.context
+          .kvCosmicMirrorArchetypesStore()
+          .get<KVArchetype>(kvKey, 'json');
+        if (!archetype || !archetype.leonardoPrompt) {
+          throw new Error(
+            `Missing Leonardo prompt for archetype ${index} of combination: ${combinationString}`
+          );
+        }
+        // Add image generation logic
+      })
+    );
+  }
+}

package/app/services/ConceptService.ts

@@ -1,6 +1,8 @@
 import { inject, injectable } from 'inversify';
 import 'reflect-metadata';
+import { Languages } from '../../types';
 import { KVConcept, sizes } from '../../types/scopes/legacy';
+import { buildConceptKVKey } from '../../utils/KVKeysBuilders';
 import { AppContext } from '../base/AppContext';
 
 @injectable()
@@ -11,12 +13,13 @@ export class ConceptService {
    * Generate basic info for a concept: name, description, and poem.
    */
   async generateBasicInfo(
+    language: Languages,
     conceptSlug: string,
     combinationString: string
   ): Promise<void> {
-    const kvKey = `concepts:${conceptSlug}:${combinationString}`;
+    const kvKey = buildConceptKVKey(language, conceptSlug, combinationString);
     console.log(
-      `Generating basic info for concept: ${conceptSlug}, combination: ${combinationString}`
+      `Generating basic info for concept: ${conceptSlug}, combination: ${combinationString}, language: ${language}`
     );
 
     const messages = this.context.buildLLMMessages().generateConceptBasicInfo({
@@ -33,13 +36,12 @@ export class ConceptService {
 
     const { name, description, poem } = this.parseBasicInfoResponse(response);
 
-    // Save basic info to KV
     const concept = await this.getKVConcept(kvKey);
     Object.assign(concept, { name, description, poem, status: 'idle' });
 
     await this.context.kvConceptsStore().put(kvKey, JSON.stringify(concept));
     console.log(
-      `Basic info stored for concept: ${conceptSlug}, combination: ${combinationString}`
+      `Basic info stored for concept: ${conceptSlug}, combination: ${combinationString}, language: ${language}`
     );
   }
 
@@ -68,12 +70,13 @@ export class ConceptService {
    * Generate the Leonardo prompt for a concept.
    */
   async generatePrompt(
+    language: Languages,
     conceptSlug: string,
     combinationString: string
   ): Promise<void> {
-    const kvKey = `concepts:${conceptSlug}:${combinationString}`;
+    const kvKey = buildConceptKVKey(language, conceptSlug, combinationString);
     console.log(
-      `Generating Leonardo prompt for concept: ${conceptSlug}, combination: ${combinationString}`
+      `Generating Leonardo prompt for concept: ${conceptSlug}, combination: ${combinationString}, language: ${language}`
     );
 
     const concept = await this.getKVConcept(kvKey);
@@ -100,7 +103,7 @@ export class ConceptService {
     concept.leonardoPrompt = response.trim();
     await this.context.kvConceptsStore().put(kvKey, JSON.stringify(concept));
     console.log(
-      `Leonardo prompt stored for concept: ${conceptSlug}, combination: ${combinationString}`
+      `Leonardo prompt stored for concept: ${conceptSlug}, combination: ${combinationString}, language: ${language}`
     );
   }
 
@@ -108,12 +111,13 @@ export class ConceptService {
    * Generate additional content for a concept.
    */
   async generateContent(
+    language: Languages,
     conceptSlug: string,
     combinationString: string
   ): Promise<void> {
-    const kvKey = `concepts:${conceptSlug}:${combinationString}`;
+    const kvKey = buildConceptKVKey(language, conceptSlug, combinationString);
     console.log(
-      `Generating additional content for concept: ${conceptSlug}, combination: ${combinationString}`
+      `Generating additional content for concept: ${conceptSlug}, combination: ${combinationString}, language: ${language}`
     );
 
     const concept = await this.getKVConcept(kvKey);
@@ -139,7 +143,7 @@ export class ConceptService {
     concept.content = response.trim();
     await this.context.kvConceptsStore().put(kvKey, JSON.stringify(concept));
     console.log(
-      `Content stored for concept: ${conceptSlug}, combination: ${combinationString}`
+      `Content stored for concept: ${conceptSlug}, combination: ${combinationString}, language: ${language}`
     );
   }
 
@@ -147,12 +151,13 @@ export class ConceptService {
    * Queue image generation for a concept.
    */
   async generateImages(
+    language: Languages,
     conceptSlug: string,
     combinationString: string
   ): Promise<void> {
-    const kvKey = `concepts:${conceptSlug}:${combinationString}`;
+    const kvKey = buildConceptKVKey(language, conceptSlug, combinationString);
     console.log(
-      `Queuing image generation for concept: ${conceptSlug}, combination: ${combinationString}`
+      `Queuing image generation for concept: ${conceptSlug}, combination: ${combinationString}, language: ${language}`
     );
 
     const concept = await this.getKVConcept(kvKey);
@@ -171,7 +176,7 @@ export class ConceptService {
     });
 
     console.log(
-      `Post images queued for concept: ${conceptSlug}, combination: ${combinationString}`
+      `Post images queued for concept: ${conceptSlug}, combination: ${combinationString}, language: ${language}`
     );
   }
 
@@ -182,6 +187,7 @@ export class ConceptService {
     const existingData = await this.context
       .kvConceptsStore()
       .get<KVConcept>(kvKey, 'json');
+
     if (existingData) {
       return existingData;
     }

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.75",
+  "version": "0.0.77",
   "module": "index.ts",
   "type": "module",
   "publishConfig": {

package/utils/KVKeysBuilders.ts

@@ -0,0 +1,18 @@
+import { Gender, Languages } from '../types';
+
+export const buildCosmicMirrorArchetypeKVKey = (
+  lang: Languages,
+  crown: string,
+  gender: Gender,
+  index: number
+): string => {
+  return `cosmic_mirror:${lang}:${crown}:${gender}:${index}`;
+};
+
+export const buildConceptKVKey = (
+  lang: Languages,
+  conceptSlug: string,
+  combinationString: string
+): string => {
+  return `concepts:${lang}:${conceptSlug}:${combinationString}`;
+};

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;
+}