@zodic/shared 0.0.145 → 0.0.147

package/app/services/ConceptService.ts

@@ -4,7 +4,11 @@ import 'reflect-metadata';
 import { v4 as uuidv4 } from 'uuid';
 import { schema } from '../..';
 import { Concept, ControlNetConfig, Languages } from '../../types';
-import { KVConcept, sizes, StructuredConceptContent } from '../../types/scopes/legacy';
+import {
+  KVConcept,
+  sizes,
+  StructuredConceptContent,
+} from '../../types/scopes/legacy';
 import { leonardoInitImages } from '../../utils/initImages';
 import { buildConceptKVKey } from '../../utils/KVKeysBuilders';
 import { AppContext } from '../base/AppContext';
@@ -24,98 +28,119 @@ export class ConceptService {
     console.log(
       `🚀 Generating basic info for concept: ${conceptSlug}, combination: ${combinationString}, override: ${override}`
     );
-  
+
     const kvStore = this.context.kvConceptsStore();
     const kvFailuresStore = this.context.kvConceptFailuresStore(); // 🔴 Replace with actual KV store
-    const kvKeyEN = buildConceptKVKey("en-us", conceptSlug, combinationString);
-    const kvKeyPT = buildConceptKVKey("pt-br", conceptSlug, combinationString);
+    const kvKeyEN = buildConceptKVKey('en-us', conceptSlug, combinationString);
+    const kvKeyPT = buildConceptKVKey('pt-br', conceptSlug, combinationString);
     const failureKey = `failures:basic-info:${conceptSlug}:${combinationString}`;
-  
+
     // ✅ Check if data already exists
     if (!override) {
       const existingEN = await this.getKVConcept(kvKeyEN);
       const existingPT = await this.getKVConcept(kvKeyPT);
-  
+
       if (
-        existingEN.name && existingEN.description && existingEN.poem &&
-        existingPT.name && existingPT.description && existingPT.poem
+        existingEN.name &&
+        existingEN.description &&
+        Array.isArray(existingEN.poem) &&
+        existingEN.poem.length > 0 &&
+        existingPT.name &&
+        existingPT.description &&
+        Array.isArray(existingPT.poem) &&
+        existingPT.poem.length > 0
       ) {
-        console.log(`⚡ Basic info already exists for ${conceptSlug}, combination: ${combinationString}. Skipping.`);
+        console.log(
+          `⚡ Basic info already exists for ${conceptSlug}, combination: ${combinationString}. Skipping.`
+        );
         return; // ✅ Skip regeneration
       }
     }
-  
+
     let attempts = 0;
     const maxAttempts = 3;
-  
+
     while (attempts < maxAttempts) {
-      let phase = "generation"; // 📌 Track the phase
+      let phase = 'generation'; // 📌 Track the phase
       try {
         attempts++;
         console.log(`🔄 Attempt ${attempts} to generate basic info...`);
-  
+
         // ✅ Build the messages to request content
-        const messages = this.context.buildLLMMessages().generateConceptBasicInfo({
-          combination: combinationString,
-          conceptSlug,
-        });
-  
+        const messages = this.context
+          .buildLLMMessages()
+          .generateConceptBasicInfo({
+            combination: combinationString,
+            conceptSlug,
+          });
+
         // ✅ Call ChatGPT API
-        const response = await this.context.api().callChatGPT.single(messages, {});
+        const response = await this.context
+          .api()
+          .callChatGPT.single(messages, {});
         if (!response) {
           throw new Error(`❌ AI returned an empty response`);
         }
-  
-        phase = "parsing"; // ✅ Switch to parsing phase
-  
+
+        phase = 'parsing'; // ✅ Switch to parsing phase
+
         // ✅ Parse response for both languages
         const { nameEN, descriptionEN, poemEN, namePT, descriptionPT, poemPT } =
           this.parseBasicInfoResponse(response);
-  
+
         // 🌍 English version
         const conceptEN = await this.getKVConcept(kvKeyEN);
         Object.assign(conceptEN, {
           name: nameEN,
           description: descriptionEN,
           poem: poemEN,
-          status: "idle",
+          status: 'idle',
         });
         await kvStore.put(kvKeyEN, JSON.stringify(conceptEN));
-  
+
         // 🇧🇷 Portuguese version
         const conceptPT = await this.getKVConcept(kvKeyPT);
         Object.assign(conceptPT, {
           name: namePT,
           description: descriptionPT,
           poem: poemPT,
-          status: "idle",
+          status: 'idle',
         });
         await kvStore.put(kvKeyPT, JSON.stringify(conceptPT));
-  
+
         console.log(
           `✅ Basic info stored for ${conceptSlug}, combination: ${combinationString}, in both languages.`
         );
         return; // ✅ Exit loop if successful
-  
       } catch (error) {
-        console.error(`❌ Attempt ${attempts} failed at phase: ${phase}`, (error as Error).message);
-  
+        console.error(
+          `❌ Attempt ${attempts} failed at phase: ${phase}`,
+          (error as Error).message
+        );
+
         // ✅ Store failure details in KV for manual review
-        await kvFailuresStore.put(failureKey, JSON.stringify({
-          error: (error as Error).message,
-          attempt: attempts,
-          phase, // ✅ Identify if failure occurred in "generation" or "parsing"
-          conceptSlug,
-          combinationString,
-          timestamp: new Date().toISOString(),
-        }));
-  
+        await kvFailuresStore.put(
+          failureKey,
+          JSON.stringify({
+            error: (error as Error).message,
+            attempt: attempts,
+            phase, // ✅ Identify if failure occurred in "generation" or "parsing"
+            conceptSlug,
+            combinationString,
+            timestamp: new Date().toISOString(),
+          })
+        );
+
         if (attempts >= maxAttempts) {
-          console.error(`🚨 All ${maxAttempts} attempts failed during ${phase}. Logged failure.`);
-          throw new Error(`Failed to generate basic info after ${maxAttempts} attempts`);
+          console.error(
+            `🚨 All ${maxAttempts} attempts failed during ${phase}. Logged failure.`
+          );
+          throw new Error(
+            `Failed to generate basic info after ${maxAttempts} attempts`
+          );
         }
-  
-        console.log("🔁 Retrying...");
+
+        console.log('🔁 Retrying...');
         await new Promise((resolve) => setTimeout(resolve, 2000)); // ⏳ Small delay before retrying
       }
     }
@@ -130,27 +155,33 @@ export class ConceptService {
     poemPT: string[];
   } {
     console.log('📌 Parsing basic info response from ChatGPT:', response);
-  
+
     const enMatch = response.match(
       /EN:\s*•\s*Name:\s*(.+?)\s*•\s*Description:\s*([\s\S]+?)\s*•\s*Poetic Passage:\s*([\s\S]+?)\s*(?=PT:|$)/
     );
     const ptMatch = response.match(
       /PT:\s*•\s*Nome:\s*(.+?)\s*•\s*Descrição:\s*([\s\S]+?)\s*•\s*Passagem Poética:\s*([\s\S]+)/
     );
-  
+
     if (!enMatch || !ptMatch) {
       console.error('❌ Invalid basic info response format:', response);
       throw new Error('Invalid basic info response format');
     }
-  
+
     const nameEN = enMatch[1].trim();
     const descriptionEN = enMatch[2].trim();
-    const poemEN = enMatch[3].trim().split(/\n+/).map(line => line.trim()); // ✅ Split into array
-  
+    const poemEN = enMatch[3]
+      .trim()
+      .split(/\n+/)
+      .map((line) => line.trim()); // ✅ Split into array
+
     const namePT = ptMatch[1].trim();
     const descriptionPT = ptMatch[2].trim();
-    const poemPT = ptMatch[3].trim().split(/\n+/).map(line => line.trim()); // ✅ Split into array
-  
+    const poemPT = ptMatch[3]
+      .trim()
+      .split(/\n+/)
+      .map((line) => line.trim()); // ✅ Split into array
+
     console.log('✅ Successfully parsed basic info:', {
       nameEN,
       descriptionEN,
@@ -159,7 +190,7 @@ export class ConceptService {
       descriptionPT,
       poemPT,
     });
-  
+
     return { nameEN, descriptionEN, poemEN, namePT, descriptionPT, poemPT };
   }
 
@@ -167,40 +198,65 @@ export class ConceptService {
    * Generate the Leonardo prompt for a concept.
    */
   async generatePrompt(
-    language: Languages,
     conceptSlug: Concept,
-    combinationString: string
+    combinationString: string,
+    override: boolean = false
   ): Promise<void> {
-    const kvKey = buildConceptKVKey(language, conceptSlug, combinationString);
     console.log(
-      `Generating Leonardo prompt for concept: ${conceptSlug}, combination: ${combinationString}, language: ${language}`
+      `🚀 Generating Leonardo prompt for concept: ${conceptSlug}, combination: ${combinationString}`
     );
-
-    const concept = await this.getKVConcept(kvKey);
-    if (!concept.name || !concept.description || !concept.poem) {
+  
+    // ✅ Build KV keys for both languages
+    const kvKeyEN = buildConceptKVKey('en-us', conceptSlug, combinationString);
+    const kvKeyPT = buildConceptKVKey('pt-br', conceptSlug, combinationString);
+  
+    // ✅ Retrieve existing KV data
+    const conceptEN = await this.getKVConcept(kvKeyEN);
+    const conceptPT = await this.getKVConcept(kvKeyPT);
+  
+    // ✅ Check if prompt already exists
+    if (!override && conceptEN.leonardoPrompt && conceptPT.leonardoPrompt) {
+      console.log(`⚡ Leonardo prompt already exists for ${conceptSlug}, skipping.`);
+      return; // ✅ Skip regeneration
+    }
+  
+    // ✅ Ensure basic info is present
+    if (
+      !conceptEN.name || !conceptEN.description || !conceptEN.poem ||
+      !conceptPT.name || !conceptPT.description || !conceptPT.poem
+    ) {
       throw new Error(
-        `Basic info must be populated before generating prompt for concept: ${conceptSlug}`
+        `❌ Basic info must be populated before generating Leonardo prompt for concept: ${conceptSlug}`
       );
     }
-
+  
+    // ✅ Generate prompt request
     const messages = this.context
       .buildLLMMessages()
       .generateConceptLeonardoPrompt({
         conceptSlug,
         combination: combinationString,
       });
-
+  
+    // ✅ Call ChatGPT API
     const response = await this.context.api().callChatGPT.single(messages, {});
     if (!response) {
       throw new Error(
-        `Failed to generate Leonardo prompt for concept: ${conceptSlug}`
+        `❌ Failed to generate Leonardo prompt for concept: ${conceptSlug}`
       );
     }
-
-    concept.leonardoPrompt = response.trim();
-    await this.context.kvConceptsStore().put(kvKey, JSON.stringify(concept));
+  
+    // ✅ Store the generated prompt in both languages
+    conceptEN.leonardoPrompt = response.trim();
+    conceptPT.leonardoPrompt = response.trim();
+  
+    await Promise.all([
+      this.context.kvConceptsStore().put(kvKeyEN, JSON.stringify(conceptEN)),
+      this.context.kvConceptsStore().put(kvKeyPT, JSON.stringify(conceptPT)),
+    ]);
+  
     console.log(
-      `Leonardo prompt stored for concept: ${conceptSlug}, combination: ${combinationString}, language: ${language}`
+      `✅ Leonardo prompt stored for concept: ${conceptSlug}, combination: ${combinationString}, in both languages.`
     );
   }
 
@@ -215,93 +271,114 @@ export class ConceptService {
     console.log(
       `🚀 Generating content for concept: ${conceptSlug}, combination: ${combinationString}, override: ${override}`
     );
-  
+
     const kvStore = this.context.kvConceptsStore();
     const kvFailuresStore = this.context.kvConceptFailuresStore(); // 🔴 Replace with actual KV store
-    const kvKeyEN = buildConceptKVKey("en-us", conceptSlug, combinationString);
-    const kvKeyPT = buildConceptKVKey("pt-br", conceptSlug, combinationString);
+    const kvKeyEN = buildConceptKVKey('en-us', conceptSlug, combinationString);
+    const kvKeyPT = buildConceptKVKey('pt-br', conceptSlug, combinationString);
     const failureKey = `failures:content:${conceptSlug}:${combinationString}`;
-  
+
     // ✅ Ensure basic info is available before generating content
     const conceptEN = await this.getKVConcept(kvKeyEN);
     const conceptPT = await this.getKVConcept(kvKeyPT);
-  
+
     if (
-      !conceptEN.name || !conceptEN.description || !conceptEN.poem ||
-      !conceptPT.name || !conceptPT.description || !conceptPT.poem
+      !conceptEN.name ||
+      !conceptEN.description ||
+      !conceptEN.poem ||
+      !conceptPT.name ||
+      !conceptPT.description ||
+      !conceptPT.poem
     ) {
       throw new Error(
         `❌ Basic info must be populated before generating content for ${conceptSlug}`
       );
     }
-  
-    if (!override && conceptEN.content?.length > 0 && conceptPT.content?.length > 0) {
+
+    if (
+      !override &&
+      conceptEN.content?.length > 0 &&
+      conceptPT.content?.length > 0
+    ) {
       console.log(`⚡ Content already exists for ${conceptSlug}, skipping.`);
       return; // ✅ Skip regeneration
     }
-  
+
     let attempts = 0;
     const maxAttempts = 3;
-  
+
     while (attempts < maxAttempts) {
-      let phase = "generation"; // 📌 Track phase
+      let phase = 'generation'; // 📌 Track phase
       try {
         attempts++;
         console.log(`🔄 Attempt ${attempts} to generate content...`);
-  
+
         // ✅ Build messages for LLM
-        const messages = this.context.buildLLMMessages().generateConceptContent({
-          conceptSlug,
-          combination: combinationString,
-          name: conceptEN.name, // Use English name since both languages match in meaning
-          description: conceptEN.description,
-          poem: conceptEN.poem,
-        });
-  
+        const messages = this.context
+          .buildLLMMessages()
+          .generateConceptContent({
+            conceptSlug,
+            combination: combinationString,
+            name: conceptEN.name, // Use English name since both languages match in meaning
+            description: conceptEN.description,
+            poem: conceptEN.poem,
+          });
+
         // ✅ Call ChatGPT API
-        const response = await this.context.api().callChatGPT.single(messages, {});
+        const response = await this.context
+          .api()
+          .callChatGPT.single(messages, {});
         if (!response) {
           throw new Error(`❌ AI returned an empty response`);
         }
-  
-        phase = "parsing"; // ✅ Switch to parsing phase
-  
+
+        phase = 'parsing'; // ✅ Switch to parsing phase
+
         // ✅ Parse structured content for both languages
         const { structuredContentEN, structuredContentPT } =
           this.parseStructuredContent(response);
-  
+
         // 🌍 Store English content
         Object.assign(conceptEN, { content: structuredContentEN });
         await kvStore.put(kvKeyEN, JSON.stringify(conceptEN));
-  
+
         // 🇧🇷 Store Portuguese content
         Object.assign(conceptPT, { content: structuredContentPT });
         await kvStore.put(kvKeyPT, JSON.stringify(conceptPT));
-  
+
         console.log(
           `✅ Structured content stored for ${conceptSlug}, combination: ${combinationString}, in both languages.`
         );
         return; // ✅ Exit loop if successful
-  
       } catch (error) {
-        console.error(`❌ Attempt ${attempts} failed at phase: ${phase}`, (error as Error).message);
-  
+        console.error(
+          `❌ Attempt ${attempts} failed at phase: ${phase}`,
+          (error as Error).message
+        );
+
         // ✅ Store failure details in KV for manual review
-        await kvFailuresStore.put(failureKey, JSON.stringify({
-          error: (error as Error).message,
-          attempt: attempts,
-          phase, // ✅ Identify failure phase
-          conceptSlug,
-          combinationString,
-          timestamp: new Date().toISOString(),
-        }));
-  
+        await kvFailuresStore.put(
+          failureKey,
+          JSON.stringify({
+            error: (error as Error).message,
+            attempt: attempts,
+            phase, // ✅ Identify failure phase
+            conceptSlug,
+            combinationString,
+            timestamp: new Date().toISOString(),
+          })
+        );
+
         if (attempts >= maxAttempts) {
-          console.error(`🚨 All ${maxAttempts} attempts failed at phase ${phase}. Logged failure.`);
-          throw new Error(`Failed to generate content after ${maxAttempts} attempts`);
+          console.error(
+            `🚨 All ${maxAttempts} attempts failed at phase ${phase}. Logged failure.`
+          );
+          throw new Error(
+            `Failed to generate content after ${maxAttempts} attempts`
+          );
         }
-  
-        console.log("🔁 Retrying...");
+
+        console.log('🔁 Retrying...');
         await new Promise((resolve) => setTimeout(resolve, 2000)); // ⏳ Small delay before retrying
       }
     }
@@ -311,51 +388,57 @@ export class ConceptService {
     structuredContentEN: StructuredConceptContent;
     structuredContentPT: StructuredConceptContent;
   } {
-    console.log('📌 Parsing structured content from ChatGPT response:', response);
-  
+    console.log(
+      '📌 Parsing structured content from ChatGPT response:',
+      response
+    );
+
     const sections = [
-      "Core Identity",
-      "Strengths and Challenges",
-      "Path to Fulfillment",
-      "Emotional Depth",
-      "Vision and Aspirations"
+      'Core Identity',
+      'Strengths and Challenges',
+      'Path to Fulfillment',
+      'Emotional Depth',
+      'Vision and Aspirations',
     ];
-  
+
     const sectionsPT = [
-      "Identidade Essencial",
-      "Forças e Desafios",
-      "Caminho para a Plenitude",
-      "Profundidade Emocional",
-      "Visão e Aspirações"
+      'Identidade Essencial',
+      'Forças e Desafios',
+      'Caminho para a Plenitude',
+      'Profundidade Emocional',
+      'Visão e Aspirações',
     ];
-  
+
     // ✅ Match English and Portuguese content separately
     const enMatches = response.match(/EN:\s*([\s\S]+?)\s*PT:/);
     const ptMatches = response.match(/PT:\s*([\s\S]+)/);
-  
+
     if (!enMatches || !ptMatches) {
-      throw new Error("❌ Missing English or Portuguese content in response.");
+      throw new Error('❌ Missing English or Portuguese content in response.');
     }
-  
+
     const enContent = enMatches[1].trim();
     const ptContent = ptMatches[1].trim();
-  
+
     function extractSections(text: string, sectionTitles: string[]) {
       return sectionTitles.map((title) => {
         const regex = new RegExp(`${title}:\\s*([\\s\\S]+?)(?=\\n\\d|$)`);
         const match = text.match(regex);
-  
+
         if (!match) {
-          return { type: "section", title, content: ["❌ Section Missing"] };
+          return { type: 'section', title, content: ['❌ Section Missing'] };
         }
-  
+
         // ✅ Split content into paragraphs
-        const paragraphs = match[1].trim().split(/\n\n+/).map((p) => p.trim());
-  
-        return { type: "section", title, content: paragraphs };
+        const paragraphs = match[1]
+          .trim()
+          .split(/\n\n+/)
+          .map((p) => p.trim());
+
+        return { type: 'section', title, content: paragraphs };
       });
     }
-  
+
     return {
       structuredContentEN: extractSections(enContent, sections),
       structuredContentPT: extractSections(ptContent, sectionsPT),

package/package.json

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

package/utils/buildMessages.ts

@@ -122,18 +122,22 @@ export const buildLLMMessages = (env: BackendBindings) => ({
   }: {
     combination: string;
     conceptSlug: Concept;
-  }): ChatMessages => [
-    {
-      role: 'system',
-      content: conceptPrompts(env)['leonardoPrompt'][conceptSlug],
-    },
-    {
-      role: 'user',
-      content: `
-          Combination: ${combination}
+  }): ChatMessages => {
+    const zodiacCombination = mapConceptToPlanets(conceptSlug, combination);
+
+    return [
+      {
+        role: 'system',
+        content: conceptPrompts(env)['leonardoPrompt'][conceptSlug],
+      },
+      {
+        role: 'user',
+        content: `
+          Combination: ${zodiacCombination}
         `,
-    },
-  ],
+      },
+    ];
+  },
   generateConceptContent: ({
     name,
     description,