@zodic/shared 0.0.74 → 0.0.76

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/package.json

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

package/types/scopes/cloudflare.ts

@@ -28,10 +28,11 @@ export type CentralBindings = {
   CONCEPT_GENERATION_QUEUE: Queue;
 
   PROMPT_IMAGE_DESCRIBER: string;
-  PROMPT_GENERATE_ARCHETYPE: string;
-  PROMPT_GENERATE_LEONARDO: string;
+  PROMPT_GENERATE_ARCHETYPE_BASIC_INFO: string;
+  PROMPT_GENERATE_ARCHETYPE_CONTENT: string;
+  PROMPT_GENERATE_ARCHETYPE_LEONARDO_PROMPTS: string;
   NEGATIVE_PROMPT_LEONARDO: string;
-  PROMPT_GENERATE_USER_LUMINOUS_SELF: string;
+  PROMPT_PERSONALIZE_COSMIC_MIRROR_LEONARDO_PROMPT: string;
   AI: Ai;
   DB: D1Database;
   DRIZZLE: DrizzleD1Database;
@@ -90,10 +91,10 @@ export type BackendBindings = Env &
     | 'KV_CONCEPTS'
     | 'KV_LEONARDO_PROMPTS'
     | 'PROMPT_IMAGE_DESCRIBER'
-    | 'PROMPT_GENERATE_ARCHETYPE'
-    | 'PROMPT_GENERATE_LEONARDO'
+    | 'PROMPT_GENERATE_ARCHETYPE_CONTENT'
+    | 'PROMPT_GENERATE_ARCHETYPE_LEONARDO_PROMPTS'
     | 'NEGATIVE_PROMPT_LEONARDO'
-    | 'PROMPT_GENERATE_USER_LUMINOUS_SELF'
+    | 'PROMPT_PERSONALIZE_COSMIC_MIRROR_LEONARDO_PROMPT'
     | 'DB'
     | 'JWT_SECRET'
     | 'GOOGLE_API_KEY'
@@ -115,6 +116,7 @@ export type BackendBindings = Env &
     | 'CONCEPT_GENERATION_QUEUE'
     | 'KV_CONCEPTS_MANAGEMENT'
     | 'DEEPSEEK_API_KEY'
+    | 'PROMPT_GENERATE_ARCHETYPE_BASIC_INFO'
   >;
 
 export type BackendCtx = Context<

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/buildMessages.ts

@@ -9,7 +9,7 @@ export const buildLLMMessages = (env: BackendBindings) => ({
   }: Crown): ChatMessages => [
     {
       role: 'system',
-      content: env.PROMPT_GENERATE_ARCHETYPE,
+      content: env.PROMPT_GENERATE_ARCHETYPE_BASIC_INFO,
     },
     {
       role: 'user',
@@ -21,29 +21,59 @@ export const buildLLMMessages = (env: BackendBindings) => ({
     },
   ],
   generateCosmicMirrorArchetypesLeonardoPrompts: (
-    archetypes: Array<{ name: string; description: string }>
+    archetypes: Array<{ name: string; visualDescription: string }>
   ): ChatMessages => [
     {
       role: 'system',
-      content: env.PROMPT_GENERATE_LEONARDO,
+      content: env.PROMPT_GENERATE_ARCHETYPE_LEONARDO_PROMPTS,
     },
     {
       role: 'user',
       content: `
           1.
           - Name: ${archetypes[0].name}
-          - Description: ${archetypes[0].description}
+          - Visual Description: ${archetypes[0].visualDescription}
 
           2.
           - Name: ${archetypes[1].name}
-          - Description: ${archetypes[1].description}
+          - Visual Description: ${archetypes[1].visualDescription}
           
           3.
           - Name: ${archetypes[2].name}
-          - Description: ${archetypes[2].description}
+          - Visual Description: ${archetypes[2].visualDescription}
           `,
     },
   ],
+  generateCosmicMirrorArchetypeContent: ({
+    name,
+    description,
+    sun,
+    ascendant,
+    moon,
+  }: {
+    name: string;
+    description: string;
+    sun: string;
+    ascendant: string;
+    moon: string;
+  }): ChatMessages => [
+    {
+      role: 'system',
+      content: env.PROMPT_GENERATE_ARCHETYPE_CONTENT,
+    },
+    {
+      role: 'user',
+      content: `
+        Generate a detailed archetype description using the following inputs:
+
+        Archetype Name: ${name}
+        Archetype Description: ${description}
+        Sun Sign: ${sun}
+        Ascendant Sign: ${ascendant}
+        Moon Sign: ${moon}
+      `,
+    },
+  ],
   personalizeCosmicMirrorLeonardoPrompt: ({
     leonardoPrompt,
     traits,
@@ -53,7 +83,7 @@ export const buildLLMMessages = (env: BackendBindings) => ({
   }): ChatMessages => [
     {
       role: 'system',
-      content: env.PROMPT_GENERATE_USER_LUMINOUS_SELF,
+      content: env.PROMPT_PERSONALIZE_COSMIC_MIRROR_LEONARDO_PROMPT,
     },
     {
       role: 'user',