@zodic/shared 0.0.153 → 0.0.155

package/app/api/index.ts

@@ -38,7 +38,7 @@ export const Api = (env: BackendBindings) => ({
   callTogether: {
     single: async (
       messages: ChatMessages,
-      { model = 'deepseek-ai/DeepSeek-V3', options = { } }: DeepSeekOptions
+      { model = 'deepseek-ai/DeepSeek-V3', options = {} }: DeepSeekOptions
     ): Promise<string> => {
       try {
         const response = await together(env).chat.completions.create({

package/app/base/AppContext.ts

@@ -24,25 +24,30 @@ export class AppContext {
 
   kvConceptsStore() {
     if (!this.env.KV_CONCEPTS) {
-      throw new Error(
-        'KV_CONCEPTS is not defined in the environment.'
-      );
+      throw new Error('KV_CONCEPTS is not defined in the environment.');
     }
     return this.env.KV_CONCEPTS;
   }
 
   kvConceptFailuresStore() {
     if (!this.env.KV_CONCEPT_FAILURES) {
-      throw new Error(
-        'KV_CONCEPT_FAILURES is not defined in the environment.'
-      );
+      throw new Error('KV_CONCEPT_FAILURES is not defined in the environment.');
     }
     return this.env.KV_CONCEPT_FAILURES;
   }
 
+  kvConceptNamesStore() {
+    if (!this.env.KV_CONCEPT_NAMES) {
+      throw new Error('KV_CONCEPT_NAMES is not defined in the environment.');
+    }
+    return this.env.KV_CONCEPT_NAMES;
+  }
+
   kvConceptsManagementStore() {
     if (!this.env.KV_CONCEPTS_MANAGEMENT) {
-      throw new Error('KV_CONCEPTS_MANAGEMENT is not defined in the environment.');
+      throw new Error(
+        'KV_CONCEPTS_MANAGEMENT is not defined in the environment.'
+      );
     }
     return this.env.KV_CONCEPTS_MANAGEMENT;
   }

package/app/services/ConceptService.ts

@@ -23,23 +23,27 @@ export class ConceptService {
   async generateBasicInfo(
     conceptSlug: Concept,
     combinationString: string,
-    override: boolean = false // ✅ New optional override param
+    override: boolean = false
   ): Promise<void> {
     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 kvFailuresStore = this.context.kvConceptFailuresStore();
+    const kvNamesStore = this.context.kvConceptNamesStore(); // ✅ New KV for storing names
     const kvKeyEN = buildConceptKVKey('en-us', conceptSlug, combinationString);
     const kvKeyPT = buildConceptKVKey('pt-br', conceptSlug, combinationString);
     const failureKey = `failures:basic-info:${conceptSlug}:${combinationString}`;
-
+  
+    const namesKeyEN = `${conceptSlug}:en-us`; // ✅ Key for English names
+    const namesKeyPT = `${conceptSlug}:pt-br`; // ✅ Key for Portuguese names
+  
     // ✅ Check if data already exists
     if (!override) {
       const existingEN = await this.getKVConcept(kvKeyEN);
       const existingPT = await this.getKVConcept(kvKeyPT);
-
+  
       if (
         existingEN.name &&
         existingEN.description &&
@@ -53,41 +57,87 @@ export class ConceptService {
         console.log(
           `⚡ Basic info already exists for ${conceptSlug}, combination: ${combinationString}. Skipping.`
         );
-        return; // ✅ Skip regeneration
+        return;
       }
     }
-
+  
     let attempts = 0;
     const maxAttempts = 3;
-
+  
     while (attempts < maxAttempts) {
-      let phase = 'generation'; // 📌 Track the phase
+      let phase = 'generation';
       try {
         attempts++;
         console.log(`🔄 Attempt ${attempts} to generate basic info...`);
-
-        // ✅ Build the messages to request content
+  
+        // ✅ Fetch the full name lists
+        let allNamesEN = JSON.parse(
+          (await kvNamesStore.get(namesKeyEN)) || '[]'
+        ) as string[];
+        let allNamesPT = JSON.parse(
+          (await kvNamesStore.get(namesKeyPT)) || '[]'
+        ) as string[];
+  
+        // ✅ Get only the last 50 names for AI context
+        const recentNamesEN = allNamesEN.slice(-50);
+        const recentNamesPT = allNamesPT.slice(-50);
+  
+        // ✅ Build the messages to request content, ensuring uniqueness
         const messages = this.context
           .buildLLMMessages()
           .generateConceptBasicInfo({
             combination: combinationString,
             conceptSlug,
+            existingNames: recentNamesEN, // 🔥 Pass only recent names
           });
-
+  
         // ✅ Call ChatGPT API
-        const response = await this.context
-          .api()
-          .callTogether.single(messages, {});
+        let response = await this.context.api().callTogether.single(messages, {});
         if (!response) {
           throw new Error(`❌ AI returned an empty response`);
         }
-
-        phase = 'parsing'; // ✅ Switch to parsing phase
-
+  
+        phase = 'cleaning';
+        response = this.cleanAIResponse(response); // ✅ Early Cleaning Step
+  
+        phase = 'parsing';
+  
         // ✅ Parse response for both languages
-        const { nameEN, descriptionEN, poemEN, namePT, descriptionPT, poemPT } =
+        let { nameEN, descriptionEN, poemEN, namePT, descriptionPT, poemPT } =
           this.parseBasicInfoResponse(response);
-
+  
+        // 🔥 Check if generated English name is unique
+        if (allNamesEN.includes(nameEN)) {
+          console.warn(`⚠️ Duplicate Crown Name Detected: "${nameEN}"`);
+          if (attempts >= maxAttempts) {
+            throw new Error(
+              `🚨 Could not generate a unique English name after ${maxAttempts} attempts.`
+            );
+          }
+          console.log('🔁 Retrying due to duplicate English name...');
+          continue;
+        }
+  
+        // 🔥 Check if generated Portuguese name is unique
+        if (allNamesPT.includes(namePT)) {
+          console.warn(`⚠️ Duplicate Portuguese Name Detected: "${namePT}"`);
+          if (attempts >= maxAttempts) {
+            throw new Error(
+              `🚨 Could not generate a unique Portuguese name after ${maxAttempts} attempts.`
+            );
+          }
+          console.log('🔁 Retrying due to duplicate Portuguese name...');
+          continue;
+        }
+  
+        // ✅ Append new names to the full list
+        allNamesEN.push(nameEN);
+        allNamesPT.push(namePT);
+  
+        // ✅ Store updated name lists in KV
+        await kvNamesStore.put(namesKeyEN, JSON.stringify(allNamesEN));
+        await kvNamesStore.put(namesKeyPT, JSON.stringify(allNamesPT));
+  
         // 🌍 English version
         const conceptEN = await this.getKVConcept(kvKeyEN);
         Object.assign(conceptEN, {
@@ -97,7 +147,7 @@ export class ConceptService {
           status: 'idle',
         });
         await kvStore.put(kvKeyEN, JSON.stringify(conceptEN));
-
+  
         // 🇧🇷 Portuguese version
         const conceptPT = await this.getKVConcept(kvKeyPT);
         Object.assign(conceptPT, {
@@ -107,7 +157,7 @@ export class ConceptService {
           status: 'idle',
         });
         await kvStore.put(kvKeyPT, JSON.stringify(conceptPT));
-
+  
         console.log(
           `✅ Basic info stored for ${conceptSlug}, combination: ${combinationString}, in both languages.`
         );
@@ -117,20 +167,20 @@ export class ConceptService {
           `❌ 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"
+            phase, // ✅ Identify if failure occurred in "generation", "cleaning", or "parsing"
             conceptSlug,
             combinationString,
             timestamp: new Date().toISOString(),
           })
         );
-
+  
         if (attempts >= maxAttempts) {
           console.error(
             `🚨 All ${maxAttempts} attempts failed during ${phase}. Logged failure.`
@@ -139,13 +189,23 @@ export class ConceptService {
             `Failed to generate basic info after ${maxAttempts} attempts`
           );
         }
-
+  
         console.log('🔁 Retrying...');
-        await new Promise((resolve) => setTimeout(resolve, 2000)); // ⏳ Small delay before retrying
+        await new Promise((resolve) => setTimeout(resolve, 500)); // ⏳ Small delay before retrying
       }
     }
   }
 
+  private cleanAIResponse(response: string): string {
+    console.log('🧼 Cleaning AI Response...');
+  
+    return response
+      .replace(/\*/g, '') // ✅ Remove asterisks
+      .replace(/#/g, '') // ✅ Remove hashtags
+      .replace(/---+/g, '') // ✅ Remove unnecessary dividers
+      .trim();
+  }
+
   private parseBasicInfoResponse(response: string): {
     nameEN: string;
     descriptionEN: string;

package/app/workflow/ConceptWorkflow.ts

@@ -1,4 +1,6 @@
 import { inject, injectable } from 'inversify';
+import pMap from 'p-map';
+import { zodiacSignCombinations } from '../../data/zodiacSignCombinations';
 import { Concept, ConceptPhase } from '../../types';
 import { ConceptService } from '../services/ConceptService';
 
@@ -13,7 +15,7 @@ export class ConceptWorkflow {
     override?: boolean
   ) {
     console.log(
-      `Processing single concept for slug: ${conceptSlug}, combination: ${combinationString}, phase: ${phase}`
+      `🚀 Processing single concept: ${conceptSlug} | ${combinationString} | Phase: ${phase}`
     );
 
     try {
@@ -50,14 +52,73 @@ export class ConceptWorkflow {
       }
 
       console.log(
-        `Concept ${conceptSlug}:${combinationString} successfully processed for phase: ${phase}`
+        `✅ Concept ${conceptSlug}:${combinationString} successfully processed for phase: ${phase}`
       );
     } catch (error) {
       console.error(
-        `Error processing concept ${conceptSlug}:${combinationString} for phase ${phase}:`,
+        `❌ Error processing concept ${conceptSlug}:${combinationString} | Phase: ${phase}:`,
         error
       );
-      throw error;
     }
   }
+
+  async processBatch(
+    conceptSlug: Concept,
+    combinations: string[],
+    phase: ConceptPhase,
+    override?: boolean
+  ) {
+    console.log(
+      `🚀 Processing batch for concept: ${conceptSlug}, Phase: ${phase}, Total Combinations: ${combinations.length}`
+    );
+
+    const concurrency = 20; // Adjust based on response speed
+    const failedCombinations: string[] = [];
+
+    await pMap(
+      combinations,
+      async (combination) => {
+        try {
+          await this.processSingle(conceptSlug, combination, phase, override);
+        } catch (error) {
+          console.error(`❌ Error processing ${combination}:`, error);
+          failedCombinations.push(combination); // Store failed ones
+        }
+      },
+      { concurrency }
+    );
+
+    if (failedCombinations.length > 0) {
+      console.warn(`⚠️ Retrying failed combinations:`, failedCombinations);
+      await this.processBatch(conceptSlug, failedCombinations, phase, override); // Retry
+    }
+    console.log(
+      `✅ Batch processing completed for concept: ${conceptSlug}, Phase: ${phase}`
+    );
+  }
+
+  async processAllCombinations(
+    conceptSlug: Concept,
+    phase: ConceptPhase,
+    override?: boolean
+  ) {
+    console.log(`🔍 Fetching all possible combinations for: ${conceptSlug}`);
+
+    // 🔥 Replace with the actual function that retrieves all pre-defined combinations from KV or DB
+    const combinations = zodiacSignCombinations;
+    if (!combinations.length) {
+      console.warn(`⚠️ No combinations found for ${conceptSlug}, skipping.`);
+      return;
+    }
+
+    console.log(
+      `🚀 Processing ALL combinations for ${conceptSlug}, Phase: ${phase}, Total: ${combinations.length}`
+    );
+
+    await this.processBatch(conceptSlug, combinations, phase, override);
+
+    console.log(
+      `✅ All combinations processed for concept: ${conceptSlug}, Phase: ${phase}`
+    );
+  }
 }