@zodic/shared 0.0.225 → 0.0.227

package/app/services/ConceptService.ts

@@ -2,7 +2,7 @@ import {
   KVNamespaceListKey,
   KVNamespaceListResult,
 } from '@cloudflare/workers-types';
-import { and, eq, sql } from 'drizzle-orm';
+import { and, eq, inArray, sql } from 'drizzle-orm';
 import { drizzle } from 'drizzle-orm/d1';
 import { inject, injectable } from 'inversify';
 import 'reflect-metadata';
@@ -377,22 +377,52 @@ export class ConceptService {
   async generateContent(
     conceptSlug: Concept,
     combinationString: string,
-    override: boolean = false // ✅ New optional override parameter
+    override: boolean = false // ✅ Optional override flag
   ): Promise<void> {
     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 failureKey = `failures:content:${conceptSlug}:${combinationString}`;
+    const db = drizzle(this.context.env.DB); // ✅ Initialize Drizzle with Cloudflare D1
 
-    // ✅ Ensure basic info is available before generating content
-    const conceptEN = await this.getKVConcept(kvKeyEN);
-    const conceptPT = await this.getKVConcept(kvKeyPT);
+    // ✅ Fetch concept data from D1
+    console.log(
+      `📡 Fetching concept data for ${conceptSlug}:${combinationString}`
+    );
+
+    const conceptEntries = await db
+      .select({
+        id: conceptsData.id,
+        language: conceptsData.language,
+        name: conceptsData.name,
+        description: conceptsData.description,
+        poem: conceptsData.poem,
+        content: conceptsData.content,
+      })
+      .from(conceptsData)
+      .where(
+        and(
+          eq(conceptsData.conceptSlug, conceptSlug),
+          eq(conceptsData.combination, combinationString),
+          inArray(conceptsData.language, ['en-us', 'pt-br']) // ✅ Fetch both languages
+        )
+      )
+      .execute();
+
+    if (conceptEntries.length !== 2) {
+      throw new Error(
+        `❌ Missing concept data for ${conceptSlug}:${combinationString}. Ensure basic info is populated first.`
+      );
+    }
+
+    const conceptEN = conceptEntries.find((c) => c.language === 'en-us');
+    const conceptPT = conceptEntries.find((c) => c.language === 'pt-br');
+
+    if (!conceptEN || !conceptPT) {
+      throw new Error(`❌ Could not find both EN and PT versions.`);
+    }
 
+    // ✅ Ensure basic info is available before generating content
     if (
       !conceptEN.name ||
       !conceptEN.description ||
@@ -408,8 +438,8 @@ export class ConceptService {
 
     if (
       !override &&
-      conceptEN.content?.length > 0 &&
-      conceptPT.content?.length > 0
+      conceptEN?.content!.length > 0 &&
+      conceptPT?.content!.length > 0
     ) {
       console.log(`⚡ Content already exists for ${conceptSlug}, skipping.`);
       return; // ✅ Skip regeneration
@@ -432,7 +462,6 @@ export class ConceptService {
             combination: combinationString,
             name: conceptEN.name, // Use English name since both languages match in meaning
             description: conceptEN.description,
-            poem: conceptEN.poem,
           });
 
         // ✅ Call ChatGPT API
@@ -447,18 +476,39 @@ export class ConceptService {
 
         // ✅ Parse structured content for both languages
         const { structuredContentEN, structuredContentPT } =
-          this.parseStructuredContent(response);
+          this.parseStructuredContent(conceptSlug, response);
 
-        // 🌍 Store English content
-        Object.assign(conceptEN, { content: structuredContentEN });
-        await kvStore.put(kvKeyEN, JSON.stringify(conceptEN));
+        // ✅ Store content in D1
+        console.log(
+          `💾 Storing structured content for ${conceptSlug}:${combinationString} in D1...`
+        );
 
-        // 🇧🇷 Store Portuguese content
-        Object.assign(conceptPT, { content: structuredContentPT });
-        await kvStore.put(kvKeyPT, JSON.stringify(conceptPT));
+        await db.transaction(async (tx) => {
+          await tx
+            .update(conceptsData)
+            .set({ content: JSON.stringify(structuredContentEN) })
+            .where(
+              and(
+                eq(conceptsData.id, conceptEN.id),
+                eq(conceptsData.language, 'en-us')
+              )
+            )
+            .execute();
+
+          await tx
+            .update(conceptsData)
+            .set({ content: JSON.stringify(structuredContentPT) })
+            .where(
+              and(
+                eq(conceptsData.id, conceptPT.id),
+                eq(conceptsData.language, 'pt-br')
+              )
+            )
+            .execute();
+        });
 
         console.log(
-          `✅ Structured content stored for ${conceptSlug}, combination: ${combinationString}, in both languages.`
+          `✅ Structured content stored successfully for ${conceptSlug}:${combinationString}.`
         );
         return; // ✅ Exit loop if successful
       } catch (error) {
@@ -468,7 +518,9 @@ export class ConceptService {
         );
 
         // ✅ Store failure details in KV for manual review
-        await kvFailuresStore.put(
+        const failureKey = `failures:content:${conceptSlug}:${combinationString}`;
+
+        await this.context.kvConceptFailuresStore().put(
           failureKey,
           JSON.stringify({
             error: (error as Error).message,
@@ -495,11 +547,16 @@ export class ConceptService {
     }
   }
 
-  private parseStructuredContent(response: string): {
+  private parseStructuredContent(
+    conceptSlug: Concept,
+    response: string
+  ): {
     structuredContentEN: StructuredConceptContent;
     structuredContentPT: StructuredConceptContent;
   } {
-    console.log('📌 [START] Parsing structured content from ChatGPT response.');
+    console.log(
+      `📌 [START] Parsing structured content for ${conceptSlug} from ChatGPT response.`
+    );
 
     // ✅ Step 1: Clean artifacts before processing
     let cleanedResponse = response
@@ -513,23 +570,114 @@ export class ConceptService {
       cleanedResponse.slice(0, 500) + '...'
     );
 
-    const sectionsEN = [
-      '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',
-    ];
-
-    // ✅ Step 2: Extract English and Portuguese content separately
+    // ✅ Step 2: Define Section Titles Per Concept
+    const conceptSections: Record<string, { en: string[]; pt: string[] }> = {
+      crown: {
+        en: [
+          'Core Identity',
+          'Strengths and Challenges',
+          'Path to Fulfillment',
+          'Emotional Depth',
+          'Vision and Aspirations',
+        ],
+        pt: [
+          'Identidade Essencial',
+          'Forças e Desafios',
+          'Caminho para a Plenitude',
+          'Profundidade Emocional',
+          'Visão e Aspirações',
+        ],
+      },
+      scepter: {
+        en: [
+          'The Power of Expression',
+          'The Dance of Action and Reaction',
+          'Navigating Challenges',
+          'The Mirror of Relationships',
+          'Impact on the World',
+        ],
+        pt: [
+          'O Poder da Expressão',
+          'A Dança da Ação e Reação',
+          'Navegando Desafios',
+          'O Espelho dos Relacionamentos',
+          'Impacto no Mundo',
+        ],
+      },
+      amulet: {
+        en: [
+          'The Shield of Protection',
+          'The Strength Within',
+          'Nurturing Growth',
+          'The Cycle of Renewal',
+          'The Anchor of Wisdom',
+        ],
+        pt: [
+          'O Escudo da Proteção',
+          'A Força Interior',
+          'Cultivando o Crescimento',
+          'O Ciclo da Renovação',
+          'A Âncora da Sabedoria',
+        ],
+      },
+      ring: {
+        en: [
+          'Magnetic Pull',
+          'Hidden Desires',
+          'The Fated Dance',
+          'Unveiling the Shadows',
+          'Your Love Power',
+        ],
+        pt: [
+          'Força Magnética',
+          'Desejos Ocultos',
+          'A Dança do Destino',
+          'Revelando as Sombras',
+          'Seu Poder no Amor',
+        ],
+      },
+      lantern: {
+        en: [
+          'The Call to Awakening',
+          'Walking Through Shadows',
+          'The Inner Flame',
+          'Revelations and Truths',
+          'Becoming the Light',
+        ],
+        pt: [
+          'O Chamado para o Despertar',
+          'Caminhando Pelas Sombras',
+          'A Chama Interior',
+          'Revelações e Verdades',
+          'Tornando-se a Luz',
+        ],
+      },
+      orb: {
+        en: [
+          'The Path Unfolding',
+          'A Calling Beyond the Self',
+          'Turning Points of Fate',
+          'Mastering the Journey',
+          'Legacy and Impact',
+        ],
+        pt: [
+          'O Caminho que se Revela',
+          'Um Chamado Além de Si Mesmo',
+          'Pontos de Virada do Destino',
+          'Dominando a Jornada',
+          'Legado e Impacto',
+        ],
+      },
+    };
+
+    const sectionsEN = conceptSections[conceptSlug]?.en;
+    const sectionsPT = conceptSections[conceptSlug]?.pt;
+
+    if (!sectionsEN || !sectionsPT) {
+      throw new Error(`❌ Unknown concept: ${conceptSlug}`);
+    }
+
+    // ✅ Step 3: Extract English and Portuguese content separately
     const enMatches = cleanedResponse.match(/EN:\s*([\s\S]+?)\s*PT:/);
     const ptMatches = cleanedResponse.match(/PT:\s*([\s\S]+)/);
 
@@ -552,7 +700,7 @@ export class ConceptService {
       ptContent.slice(0, 500) + '...'
     );
 
-    // ✅ Step 3: Extract structured sections
+    // ✅ Step 4: Extract structured sections
     function extractSections(text: string, sectionTitles: string[]) {
       return sectionTitles.map((title) => {
         console.log(`🔍 [PROCESSING] Extracting section: "${title}"`);
@@ -1034,27 +1182,29 @@ export class ConceptService {
     conceptSlug: Concept,
     maxEntries?: number
   ) {
-    console.log(`🔄 [START] Regenerating duplicate names for concept: ${conceptSlug}...`);
+    console.log(
+      `🔄 [START] Regenerating duplicate names for concept: ${conceptSlug}...`
+    );
     const startTime = Date.now();
-  
+
     const db = drizzle(this.context.env.DB);
-  
+
     // ✅ Step 1: Fetch duplicate entries filtered by conceptSlug
     console.log(`📡 Fetching duplicate entries for concept: ${conceptSlug}...`);
-  
+
     const duplicateEntries = await db
-    .select({
-      id: conceptsData.id,
-      name: conceptsData.name,
-      description: conceptsData.description,
-      combination: conceptsData.combination,
-    })
-    .from(conceptsData)
-    .where(
-      and(
-        eq(conceptsData.language, 'en-us'), // ✅ English only
-        eq(conceptsData.conceptSlug, conceptSlug), // ✅ Filter by concept
-        sql`
+      .select({
+        id: conceptsData.id,
+        name: conceptsData.name,
+        description: conceptsData.description,
+        combination: conceptsData.combination,
+      })
+      .from(conceptsData)
+      .where(
+        and(
+          eq(conceptsData.language, 'en-us'), // ✅ English only
+          eq(conceptsData.conceptSlug, conceptSlug), // ✅ Filter by concept
+          sql`
           name IN (
             SELECT name 
             FROM concepts_data 
@@ -1063,19 +1213,24 @@ export class ConceptService {
             HAVING COUNT(*) > 1
           )
         `
+        )
       )
-    )
-    .orderBy(conceptsData.name) // ✅ Order by name for better grouping
-    .limit(maxEntries || 50) // ✅ Apply optional limit
-    .execute();
-    
+      .orderBy(conceptsData.name) // ✅ Order by name for better grouping
+      .limit(maxEntries || 50) // ✅ Apply optional limit
+      .execute();
+
     if (!duplicateEntries.length) {
       console.log(`🎉 No duplicates found for ${conceptSlug}.`);
-      return { message: `No duplicates detected for ${conceptSlug}.` };
+      return {
+        message: `No duplicates detected for ${conceptSlug}.`,
+        remainingDuplicates: 0,
+      };
     }
-  
-    console.log(`🔍 Found ${duplicateEntries.length} duplicate entries to process.`);
-  
+
+    console.log(
+      `🔍 Found ${duplicateEntries.length} duplicate entries to process.`
+    );
+
     // ✅ Group duplicates by name
     const duplicateGroups = new Map<string, typeof duplicateEntries>();
     for (const entry of duplicateEntries) {
@@ -1084,50 +1239,60 @@ export class ConceptService {
       }
       duplicateGroups.get(entry.name)!.push(entry);
     }
-  
+
     let recentDuplicates = new Set<string>(); // ✅ Track newly generated names
     let updatedEntries = 0;
     let skippedEntries = 0;
     let failedEntries = 0;
-  
+
     for (const [duplicateName, entries] of duplicateGroups.entries()) {
-      console.log(`🔄 Processing duplicate group: "${duplicateName}" with ${entries.length} occurrences`);
-  
+      console.log(
+        `🔄 Processing duplicate group: "${duplicateName}" with ${entries.length} occurrences`
+      );
+
       // ✅ Leave the first entry unchanged and only process the extras
       const [keepEntry, ...entriesToProcess] = entries;
       console.log(`✅ Keeping original name for ID: ${keepEntry.id}`);
-  
+
       for (const entry of entriesToProcess) {
         const { id, description, combination } = entry;
-  
+
         console.log(`🎭 Processing duplicate ID ${id}: "${duplicateName}"`);
-  
+
         let newNameEN: string | null = null;
         let newNamePT: string | null = null;
         let attempts = 0;
         const maxAttempts = 3;
-  
+
         while (attempts < maxAttempts) {
           attempts++;
-          console.log(`📡 Attempt ${attempts}/${maxAttempts} - Requesting AI for a new name...`);
-  
+          console.log(
+            `📡 Attempt ${attempts}/${maxAttempts} - Requesting AI for a new name...`
+          );
+
           // ✅ Generate a new name, passing dynamically tracked duplicates
-          const messages = this.context.buildLLMMessages().regenerateConceptName({
-            conceptSlug,
-            oldNameEN: duplicateName,
-            description,
-            recentNames: Array.from(recentDuplicates),
-          });
-  
-          const aiResponse = await this.context.api().callTogether.single(messages, {});
-  
+          const messages = this.context
+            .buildLLMMessages()
+            .regenerateConceptName({
+              conceptSlug,
+              oldNameEN: duplicateName,
+              description,
+              recentNames: Array.from(recentDuplicates),
+            });
+
+          const aiResponse = await this.context
+            .api()
+            .callTogether.single(messages, {});
+
           if (!aiResponse) {
-            console.warn(`⚠️ AI failed to generate a new name for ID ${id}, skipping.`);
+            console.warn(
+              `⚠️ AI failed to generate a new name for ID ${id}, skipping.`
+            );
             break;
           }
-  
+
           console.log(`📝 Raw AI Response:\n${aiResponse}`);
-  
+
           // ✅ Mapping for concept names with proper PT articles
           const conceptMapping = {
             amulet: { en: 'Amulet', pt: 'Amuleto', articlePT: 'O' },
@@ -1137,7 +1302,7 @@ export class ConceptService {
             ring: { en: 'Ring', pt: 'Anel', articlePT: 'O' },
             orb: { en: 'Orb', pt: 'Orbe', articlePT: 'O' },
           };
-  
+
           const {
             en: conceptEN,
             pt: conceptPT,
@@ -1147,80 +1312,120 @@ export class ConceptService {
             pt: conceptSlug,
             articlePT: 'O', // Default to "O" if concept is missing
           };
-  
+
           // ✅ Strict regex matching for English and Portuguese
-          const enMatch = aiResponse.match(new RegExp(`EN:\\s*The ${conceptEN} of (.+)`));
-          const ptMatch = aiResponse.match(new RegExp(`PT:\\s*${articlePT} ${conceptPT} de (.+)`));
-  
+          const enMatch = aiResponse.match(
+            new RegExp(`EN:\\s*The ${conceptEN} of (.+)`)
+          );
+          const ptMatch = aiResponse.match(
+            new RegExp(`PT:\\s*${articlePT} ${conceptPT} de (.+)`)
+          );
+
           if (!enMatch || !ptMatch) {
-            console.error(`❌ Invalid AI response format for ID ${id}, retrying...`);
+            console.error(
+              `❌ Invalid AI response format for ID ${id}, retrying...`
+            );
             continue;
           }
-  
+
           newNameEN = `The ${conceptEN} of ${enMatch[1].trim()}`;
           newNamePT = `${articlePT} ${conceptPT} de ${ptMatch[1].trim()}`;
-  
-          console.log(`🎨 Extracted Names: EN - "${newNameEN}", PT - "${newNamePT}"`);
-  
+
+          console.log(
+            `🎨 Extracted Names: EN - "${newNameEN}", PT - "${newNamePT}"`
+          );
+
           // ✅ Check if the new name is already in use in D1 before updating
           const existingEntry = await db
             .select({ id: conceptsData.id })
             .from(conceptsData)
             .where(eq(conceptsData.name, newNameEN))
             .execute();
-  
+
           if (existingEntry.length > 0 || recentDuplicates.has(newNameEN)) {
             console.warn(`⚠️ Duplicate detected: "${newNameEN}", retrying...`);
             continue;
           }
-  
+
           recentDuplicates.add(newNameEN);
           break; // ✅ Found a valid new name
         }
-  
+
         if (!newNameEN || !newNamePT) {
-          console.error(`🚨 Failed to generate a unique name for ID ${id} after ${maxAttempts} attempts.`);
+          console.error(
+            `🚨 Failed to generate a unique name for ID ${id} after ${maxAttempts} attempts.`
+          );
           failedEntries++;
           continue;
         }
-  
-        console.log(`✅ Updating names: EN - "${newNameEN}", PT - "${newNamePT}"`);
-  
+
+        console.log(
+          `✅ Updating names: EN - "${newNameEN}", PT - "${newNamePT}"`
+        );
+
         // ✅ Update English name using the ID
         await db
           .update(conceptsData)
           .set({ name: newNameEN })
-          .where(and(eq(conceptsData.id, id), eq(conceptsData.language, 'en-us')))
+          .where(
+            and(eq(conceptsData.id, id), eq(conceptsData.language, 'en-us'))
+          )
           .execute();
-  
+
         // ✅ Convert English ID to Portuguese ID by replacing `:en-us:` with `:pt-br:`
         const ptId = id.replace(':en-us:', ':pt-br:');
-  
+
         // ✅ Update Portuguese name using the derived PT ID
         await db
           .update(conceptsData)
           .set({ name: newNamePT })
-          .where(and(eq(conceptsData.id, ptId), eq(conceptsData.language, 'pt-br')))
+          .where(
+            and(eq(conceptsData.id, ptId), eq(conceptsData.language, 'pt-br'))
+          )
           .execute();
-  
-        console.log(`📝 Updated IDs: EN (${id}) -> "${newNameEN}", PT (${ptId}) -> "${newNamePT}"`);
-  
+
+        console.log(
+          `📝 Updated IDs: EN (${id}) -> "${newNameEN}", PT (${ptId}) -> "${newNamePT}"`
+        );
+
         updatedEntries++;
       }
     }
-  
+
     const elapsedTime = ((Date.now() - startTime) / 1000).toFixed(2);
-  
+
     console.log(`🎉 [COMPLETE] Regeneration finished in ${elapsedTime}s.`);
     console.log(`✅ Successfully updated: ${updatedEntries}`);
     console.log(`⚠️ Skipped (already unique): ${skippedEntries}`);
     console.log(`🚨 Failed attempts: ${failedEntries}`);
-  
+
+    const remainingDuplicates = await db
+      .select({ count: sql<number>`COUNT(*)` }) // ✅ Count only duplicates
+      .from(conceptsData)
+      .where(
+        and(
+          eq(conceptsData.conceptSlug, conceptSlug), // ✅ Filter by concept
+          sql`name IN (
+          SELECT name FROM concepts_data 
+          WHERE concept_slug = ${conceptSlug}
+          GROUP BY name 
+          HAVING COUNT(*) > 1
+        )`
+        )
+      )
+      .execute()
+      .then((res) => res[0]?.count || 0);
+
+    console.log(
+      `🔄 Remaining duplicates for ${conceptSlug}: ${remainingDuplicates}`
+    );
+
     return {
       message: `Duplicate names processed and regenerated for ${conceptSlug}.`,
       updated: updatedEntries,
       skipped: skippedEntries,
       failed: failedEntries,
+      remainingDuplicates,
       elapsedTime,
     };
   }

package/package.json

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

package/utils/buildMessages.ts

@@ -146,18 +146,15 @@ export const buildLLMMessages = (env: BackendBindings) => ({
   generateConceptContent: ({
     name,
     description,
-    poem,
     combination,
     conceptSlug,
   }: {
     name: string;
     description: string;
-    poem: string[];
     conceptSlug: Concept;
     combination: string;
   }): ChatMessages => {
     const zodiacCombination = mapConceptToPlanets(conceptSlug, combination);
-    const formattedPoem = poem.map((line) => `${line}`).join('\n');
 
     return [
       {
@@ -171,8 +168,6 @@ export const buildLLMMessages = (env: BackendBindings) => ({
           - Combination: ${zodiacCombination}
           - Name: ${name}
           - Description: ${description}
-          - Poem:
-          ${formattedPoem}
   
           Generate additional content to elaborate on this concept for frontend display.
         `,
@@ -246,7 +241,11 @@ export const buildLLMMessages = (env: BackendBindings) => ({
     ];
   },
 
-  translateENConceptName: ({ englishName }: { englishName: string }): ChatMessages => [
+  translateENConceptName: ({
+    englishName,
+  }: {
+    englishName: string;
+  }): ChatMessages => [
     {
       role: 'system',
       content: `