@zodic/shared 0.0.165 → 0.0.167

package/app/backend.ts

@@ -1,4 +1,5 @@
 export * from '../utils';
 export * from './base';
+export * from './durable';
 export * from './services';
 export * from './workflow';

package/app/durable/index.ts

@@ -0,0 +1 @@
+export * from './ConceptNameDO';

package/app/services/ConceptService.ts

@@ -31,20 +31,15 @@ export class ConceptService {
 
     const kvStore = this.context.kvConceptsStore();
     const kvFailuresStore = this.context.kvConceptFailuresStore();
-    const kvNamesStore = this.context.kvConceptNamesStore(); // ✅ New KV for storing names
+    const kvNamesStore = this.context.kvConceptNamesStore(); // ✅ New Durable Object
     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`;
-    const namesKeyPT = `${conceptSlug}:pt-br`;
-    const reportKey = `report:${conceptSlug}`; // ✅ New tracking key
-
     // ✅ Check if data already exists
     if (!override) {
       const existingEN = await this.getKVConcept(kvKeyEN);
       const existingPT = await this.getKVConcept(kvKeyPT);
-
       if (
         existingEN.name &&
         existingEN.description &&
@@ -56,7 +51,7 @@ export class ConceptService {
         existingPT.poem.length > 0
       ) {
         console.log(
-          `⚡ Basic info already exists for ${conceptSlug}, combination: ${combinationString}. Skipping.`
+          `⚡ Basic info already exists for ${conceptSlug}, skipping.`
         );
         return;
       }
@@ -71,75 +66,82 @@ export class ConceptService {
         attempts++;
         console.log(`🔄 Attempt ${attempts} to generate basic info...`);
 
-        // ✅ 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[];
+        // ✅ Fetch the latest name list **directly from Durable Object**
+        const response = await fetch(
+          `${this.context.env.API_BASE_URL}/concept-names/${conceptSlug}`
+        );
+        let allNamesEN: string[] = [];
+        let allNamesPT: string[] = [];
+        if (response.ok) {
+          const data = (await response.json()) as {
+            'en-us': string[];
+            'pt-br': string[];
+          };
+          allNamesEN = data['en-us'] || [];
+          allNamesPT = data['pt-br'] || [];
+        }
 
-        // ✅ Get only the last 50 names for AI context
-        const recentNamesEN = allNamesEN.slice(-144);
+        const recentNamesEN = allNamesEN.slice(-144); // 🔥 Only pass the last 144 names
         const recentNamesPT = allNamesPT.slice(-144);
 
-        // ✅ Build the messages to request content, ensuring uniqueness
+        // ✅ Generate content ensuring uniqueness
         const messages = this.context
           .buildLLMMessages()
           .generateConceptBasicInfo({
             combination: combinationString,
             conceptSlug,
-            existingNames: recentNamesEN, // 🔥 Pass only recent names
+            existingNames: recentNamesEN,
           });
 
-        // ✅ Call ChatGPT API
-        let response = await this.context.api().callTogether.single(messages, {});
-        if (!response) {
+        let aiResponse = await this.context
+          .api()
+          .callTogether.single(messages, {});
+        if (!aiResponse) {
           throw new Error(`❌ AI returned an empty response`);
         }
 
         phase = 'cleaning';
-        response = this.cleanAIResponse(response);
+        aiResponse = this.cleanAIResponse(aiResponse);
 
         phase = 'parsing';
 
-        // ✅ Parse response for both languages
         let { nameEN, descriptionEN, poemEN, namePT, descriptionPT, poemPT } =
-          this.parseBasicInfoResponse(response, conceptSlug);
+          this.parseBasicInfoResponse(aiResponse, conceptSlug);
 
-        // 🔥 Check if generated English name is unique
-        if (allNamesEN.includes(nameEN)) {
-          console.warn(`⚠️ Duplicate Crown Name Detected: "${nameEN}"`);
+        // ✅ Check if generated names are unique **right after parsing**
+        if (allNamesEN.includes(nameEN) || allNamesPT.includes(namePT)) {
+          console.warn(
+            `⚠️ Duplicate Name Detected: "${nameEN}" or "${namePT}"`
+          );
           if (attempts >= maxAttempts) {
             throw new Error(
-              `🚨 Could not generate a unique English name after ${maxAttempts} attempts.`
+              `🚨 Could not generate a unique name after ${maxAttempts} attempts.`
             );
           }
-          console.log('🔁 Retrying due to duplicate English name...');
+          console.log('🔁 Retrying due to duplicate 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.`
-            );
+        // ✅ **Immediately update Durable Object with the new name**
+        await fetch(
+          `${this.context.env.API_BASE_URL}/concept-names/${conceptSlug}/add`,
+          {
+            method: 'POST',
+            body: JSON.stringify({ language: 'en-us', name: nameEN }),
+            headers: { 'Content-Type': 'application/json' },
           }
-          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));
+        await fetch(
+          `${this.context.env.API_BASE_URL}/concept-names/${conceptSlug}/add`,
+          {
+            method: 'POST',
+            body: JSON.stringify({ language: 'pt-br', name: namePT }),
+            headers: { 'Content-Type': 'application/json' },
+          }
+        );
 
-        // 🌍 English version
+        // ✅ Store the generated basic info in KV
         const conceptEN = await this.getKVConcept(kvKeyEN);
         Object.assign(conceptEN, {
           name: nameEN,
@@ -149,7 +151,6 @@ export class ConceptService {
         });
         await kvStore.put(kvKeyEN, JSON.stringify(conceptEN));
 
-        // 🇧🇷 Portuguese version
         const conceptPT = await this.getKVConcept(kvKeyPT);
         Object.assign(conceptPT, {
           name: namePT,
@@ -160,19 +161,7 @@ export class ConceptService {
         await kvStore.put(kvKeyPT, JSON.stringify(conceptPT));
 
         console.log(
-          `✅ Basic info stored for ${conceptSlug}, combination: ${combinationString}, in both languages.`
-        );
-
-        // ✅ Increment report tracking successful inserts
-        let currentCount = parseInt(
-          (await kvNamesStore.get(reportKey)) || '0',
-          10
-        );
-        currentCount += 1;
-        await kvNamesStore.put(reportKey, currentCount.toString());
-
-        console.log(
-          `📊 Updated progress for ${conceptSlug}: ${currentCount} successful inserts.`
+          `✅ Stored basic info for ${conceptSlug}, combination: ${combinationString}.`
         );
 
         return; // ✅ Exit loop if successful
@@ -181,29 +170,12 @@ 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,
-            conceptSlug,
-            combinationString,
-            timestamp: new Date().toISOString(),
-          })
-        );
-
         if (attempts >= maxAttempts) {
-          console.error(
-            `🚨 All ${maxAttempts} attempts failed during ${phase}. Logged failure.`
-          );
+          console.error(`🚨 All ${maxAttempts} attempts failed.`);
           throw new Error(
-            `Failed to generate basic info after ${maxAttempts} attempts`
+            `Failed to generate basic info after ${maxAttempts} attempts.`
           );
         }
-
         console.log('🔁 Retrying...');
         await new Promise((resolve) => setTimeout(resolve, 500)); // ⏳ Small delay before retrying
       }
@@ -212,7 +184,7 @@ export class ConceptService {
 
   private cleanAIResponse(response: string): string {
     console.log('🧼 Cleaning AI Response...');
-  
+
     return response
       .replace(/\*/g, '') // ✅ Remove asterisks
       .replace(/#/g, '') // ✅ Remove hashtags
@@ -232,23 +204,23 @@ export class ConceptService {
     poemPT: string[];
   } {
     console.log('📌 Parsing basic info response from ChatGPT:', response);
-  
+
     // ✅ More flexible regex to handle variations in formatting
     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]+)/ 
+      /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');
     }
-  
+
     // ✅ Function to clean text (removes leading/trailing spaces & unwanted symbols)
     const cleanText = (text: string) => text.trim().replace(/\*/g, '');
-  
+
     // ✅ Parse and clean extracted content
     const nameEN = cleanText(enMatch[1]);
     const descriptionEN = cleanText(enMatch[2]);
@@ -256,37 +228,45 @@ export class ConceptService {
       .trim()
       .split(/\n+/)
       .map((line) => cleanText(line));
-  
+
     const namePT = cleanText(ptMatch[1]);
     const descriptionPT = cleanText(ptMatch[2]);
     const poemPT = ptMatch[3]
       .trim()
       .split(/\n+/)
       .map((line) => cleanText(line));
-  
+
     // ✅ Determine appropriate replacement text based on conceptSlug
-    const conceptPlaceholder = `this ${conceptSlug.charAt(0).toUpperCase() + conceptSlug.slice(1)}`;
-    const conceptPlaceholderCapitalized =
-      `This ${conceptSlug.charAt(0).toUpperCase() + conceptSlug.slice(1)}`;
-  
+    const conceptPlaceholder = `this ${
+      conceptSlug.charAt(0).toUpperCase() + conceptSlug.slice(1)
+    }`;
+    const conceptPlaceholderCapitalized = `This ${
+      conceptSlug.charAt(0).toUpperCase() + conceptSlug.slice(1)
+    }`;
+
     // ✅ Function to replace occurrences of the name in a text while handling capitalization
     const replaceConceptName = (text: string, conceptName: string) => {
-      return text.replace(
-        new RegExp(`(?<=\\.\\s*|^)${conceptName}`, 'g'),
-        conceptPlaceholderCapitalized
-      ).replace(new RegExp(conceptName, 'g'), conceptPlaceholder);
+      return text
+        .replace(
+          new RegExp(`(?<=\\.\\s*|^)${conceptName}`, 'g'),
+          conceptPlaceholderCapitalized
+        )
+        .replace(new RegExp(conceptName, 'g'), conceptPlaceholder);
     };
-  
+
     // ✅ Ensure the concept name is not repeated in the description
     const cleanedDescriptionEN = replaceConceptName(descriptionEN, nameEN);
     const cleanedDescriptionPT = replaceConceptName(descriptionPT, namePT);
-  
+
     // ✅ If the name appears in the poem, trigger a retry
-    if (poemEN.some((line) => line.includes(nameEN)) || poemPT.some((line) => line.includes(namePT))) {
+    if (
+      poemEN.some((line) => line.includes(nameEN)) ||
+      poemPT.some((line) => line.includes(namePT))
+    ) {
       console.error('❌ Concept name detected in poem, triggering a retry.');
       throw new Error('Concept name found in poem, regenerating response.');
     }
-  
+
     console.log('✅ Successfully parsed and cleaned basic info:', {
       nameEN,
       descriptionEN: cleanedDescriptionEN,
@@ -295,7 +275,7 @@ export class ConceptService {
       descriptionPT: cleanedDescriptionPT,
       poemPT,
     });
-  
+
     return {
       nameEN,
       descriptionEN: cleanedDescriptionEN,
@@ -317,31 +297,37 @@ export class ConceptService {
     console.log(
       `🚀 Generating Leonardo prompt for concept: ${conceptSlug}, combination: ${combinationString}`
     );
-  
+
     // ✅ 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.`);
+      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
+      !conceptEN.name ||
+      !conceptEN.description ||
+      !conceptEN.poem ||
+      !conceptPT.name ||
+      !conceptPT.description ||
+      !conceptPT.poem
     ) {
       throw new Error(
         `❌ Basic info must be populated before generating Leonardo prompt for concept: ${conceptSlug}`
       );
     }
-  
+
     // ✅ Generate prompt request
     const messages = this.context
       .buildLLMMessages()
@@ -349,7 +335,7 @@ export class ConceptService {
         conceptSlug,
         combination: combinationString,
       });
-  
+
     // ✅ Call ChatGPT API
     const response = await this.context.api().callTogether.single(messages, {});
     if (!response) {
@@ -357,16 +343,16 @@ export class ConceptService {
         `❌ Failed to generate Leonardo prompt for concept: ${conceptSlug}`
       );
     }
-  
+
     // ✅ 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}, in both languages.`
     );
@@ -501,16 +487,19 @@ export class ConceptService {
     structuredContentPT: StructuredConceptContent;
   } {
     console.log('📌 [START] Parsing structured content from ChatGPT response.');
-  
+
     // ✅ Step 1: Clean artifacts before processing
     let cleanedResponse = response
       .replace(/[*#•]/g, '') // Remove bullet points, bold markers, headings
       .replace(/---+/g, '') // Remove dividers (like "---")
       .replace(/\n\s*\n/g, '\n\n') // Normalize multiple line breaks
       .trim();
-  
-    console.log('🔹 [CLEANED RESPONSE]:', cleanedResponse.slice(0, 500) + '...');
-  
+
+    console.log(
+      '🔹 [CLEANED RESPONSE]:',
+      cleanedResponse.slice(0, 500) + '...'
+    );
+
     const sectionsEN = [
       'Core Identity',
       'Strengths and Challenges',
@@ -518,7 +507,7 @@ export class ConceptService {
       'Emotional Depth',
       'Vision and Aspirations',
     ];
-  
+
     const sectionsPT = [
       'Identidade Essencial',
       'Forças e Desafios',
@@ -526,58 +515,76 @@ export class ConceptService {
       'Profundidade Emocional',
       'Visão e Aspirações',
     ];
-  
+
     // ✅ Step 2: Extract English and Portuguese content separately
     const enMatches = cleanedResponse.match(/EN:\s*([\s\S]+?)\s*PT:/);
     const ptMatches = cleanedResponse.match(/PT:\s*([\s\S]+)/);
-  
+
     if (!enMatches || !ptMatches) {
-      console.error('❌ [ERROR] Missing English or Portuguese content in response.');
+      console.error(
+        '❌ [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();
-  
-    console.log('✅ [MATCH SUCCESS] Extracted English Content:', enContent.slice(0, 500) + '...');
-    console.log('✅ [MATCH SUCCESS] Extracted Portuguese Content:', ptContent.slice(0, 500) + '...');
-  
+
+    console.log(
+      '✅ [MATCH SUCCESS] Extracted English Content:',
+      enContent.slice(0, 500) + '...'
+    );
+    console.log(
+      '✅ [MATCH SUCCESS] Extracted Portuguese Content:',
+      ptContent.slice(0, 500) + '...'
+    );
+
     // ✅ Step 3: Extract structured sections
     function extractSections(text: string, sectionTitles: string[]) {
       return sectionTitles.map((title) => {
         console.log(`🔍 [PROCESSING] Extracting section: "${title}"`);
-  
+
         // ✅ Improved regex: Detects sections even if AI formatting changes
-        const regex = new RegExp(`\\d+\\.\\s*${title}:\\s*([\\s\\S]+?)(?=\\n\\d+\\.\\s*[A-Z]|$)`);
+        const regex = new RegExp(
+          `\\d+\\.\\s*${title}:\\s*([\\s\\S]+?)(?=\\n\\d+\\.\\s*[A-Z]|$)`
+        );
         const match = text.match(regex);
-  
+
         if (!match) {
           console.warn(`⚠️ [WARNING] Missing section: "${title}"`);
           return { type: 'section', title, content: ['❌ Section Missing'] };
         }
-  
+
         // ✅ Split content into paragraphs and clean them
         const paragraphs = match[1]
           .trim()
           .split(/\n{2,}/) // Handles cases where paragraphs are separated by multiple new lines
           .map((p) => p.trim())
           .filter((p) => p.length > 0); // Removes empty paragraphs
-  
+
         console.log(`✅ [EXTRACTED] "${title}" - Parsed Content:`, paragraphs);
-  
+
         return { type: 'section', title, content: paragraphs };
       });
     }
-  
+
     // ✅ Return parsed and cleaned structured content
     const structuredContentEN = extractSections(enContent, sectionsEN);
     const structuredContentPT = extractSections(ptContent, sectionsPT);
-  
-    console.log('🎯 [FINAL RESULT] Parsed English Content:', JSON.stringify(structuredContentEN, null, 2));
-    console.log('🎯 [FINAL RESULT] Parsed Portuguese Content:', JSON.stringify(structuredContentPT, null, 2));
-  
-    console.log('✅ [COMPLETE] Structured content parsing finished successfully.');
-  
+
+    console.log(
+      '🎯 [FINAL RESULT] Parsed English Content:',
+      JSON.stringify(structuredContentEN, null, 2)
+    );
+    console.log(
+      '🎯 [FINAL RESULT] Parsed Portuguese Content:',
+      JSON.stringify(structuredContentPT, null, 2)
+    );
+
+    console.log(
+      '✅ [COMPLETE] Structured content parsing finished successfully.'
+    );
+
     return {
       structuredContentEN,
       structuredContentPT,

package/package.json

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

package/types/scopes/cloudflare.ts

@@ -116,6 +116,7 @@ export type BackendBindings = Env &
     | 'PROMPT_GENERATE_ARCHETYPE_BASIC_INFO'
     | 'TOGETHER_API_KEY'
     | 'CONCEPT_NAMES_DO'
+    | 'API_BASE_URL'
   >;
 
 export type BackendCtx = Context<