@zodic/shared 0.0.368 → 0.0.370

package/app/services/ConceptService.ts

@@ -2,7 +2,7 @@ import {
   KVNamespaceListKey,
   KVNamespaceListResult,
 } from '@cloudflare/workers-types';
-import { and, eq, inArray, isNull, sql } from 'drizzle-orm';
+import { and, eq, inArray, isNull } from 'drizzle-orm';
 import { drizzle } from 'drizzle-orm/d1';
 import { inject, injectable } from 'inversify';
 import 'reflect-metadata';
@@ -1118,430 +1118,24 @@ export class ConceptService {
     };
   }
 
-  async findDuplicateNamesForConcept(conceptSlug: Concept) {
-    console.log(
-      `🔍 Fetching duplicate names from KV_CONCEPT_CACHE for ${conceptSlug}...`
-    );
-
-    const kvCacheStore = this.context.env.KV_CONCEPT_CACHE;
-
-    // ✅ Fetch the cached concept name mappings
-    const nameMap: Record<string, string[]> =
-      (await kvCacheStore.get(
-        `cache:concepts:en-us:${conceptSlug}:0`,
-        'json'
-      )) || {};
-
-    let duplicateKeys: string[] = [];
-    let usedNamesEN = new Set<string>();
-    let usedNamesPT = new Set<string>();
-
-    for (const [name, keys] of Object.entries(nameMap)) {
-      if (keys.length > 1) {
-        duplicateKeys.push(...keys.slice(1)); // ✅ Store all but the first occurrence
-      }
-      usedNamesEN.add(name);
-    }
-
-    // ✅ Fetch PT-BR version from cache
-    const nameMapPT: Record<string, string[]> =
-      (await kvCacheStore.get(
-        `cache:concepts:pt-br:${conceptSlug}:0`,
-        'json'
-      )) || {};
-
-    for (const name of Object.keys(nameMapPT)) {
-      usedNamesPT.add(name);
-    }
-
-    console.log(
-      `✅ Found ${duplicateKeys.length} duplicate keys for ${conceptSlug}.`
-    );
-
-    return {
-      duplicateKeys, // ✅ List of keys that need new names
-      usedNamesEN, // ✅ Set of all used EN names
-      usedNamesPT, // ✅ Set of all used PT names
-    };
-  }
-
-  async regenerateDuplicateNamesForConcept(
-    conceptSlug: Concept,
-    maxEntries?: number
-  ) {
-    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`
-          name IN (
-            SELECT name 
-            FROM concepts_data 
-            WHERE language = 'en-us' AND concept_slug = ${conceptSlug}
-            GROUP BY name 
-            HAVING COUNT(*) > 1
-          )
-        `
-        )
-      )
-      .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}.`,
-        remainingDuplicates: 0,
-      };
-    }
-
-    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) {
-      if (!duplicateGroups.has(entry.name)) {
-        duplicateGroups.set(entry.name, []);
-      }
-      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`
-      );
-
-      // ✅ 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...`
-          );
-
-          // ✅ 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, {});
-
-          if (!aiResponse) {
-            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' },
-            crown: { en: 'Crown', pt: 'Coroa', articlePT: 'A' },
-            scepter: { en: 'Scepter', pt: 'Cetro', articlePT: 'O' },
-            lantern: { en: 'Lantern', pt: 'Candeia', articlePT: 'A' },
-            ring: { en: 'Ring', pt: 'Anel', articlePT: 'O' },
-            orb: { en: 'Orb', pt: 'Orbe', articlePT: 'O' },
-          };
-
-          const {
-            en: conceptEN,
-            pt: conceptPT,
-            articlePT,
-          } = conceptMapping[conceptSlug] || {
-            en: conceptSlug,
-            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 (.+)`)
-          );
-
-          if (!enMatch || !ptMatch) {
-            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}"`
-          );
-
-          // ✅ 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.`
-          );
-          failedEntries++;
-          continue;
-        }
-
-        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'))
-          )
-          .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'))
-          )
-          .execute();
-
-        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,
-    };
-  }
-
-  async cacheConceptNamesInBatches(conceptSlug: Concept, batchSize = 500) {
-    console.log(
-      `🔄 Fetching all EN names for '${conceptSlug}' from KV in batches...`
-    );
-
-    const kvStore = this.context.env.KV_CONCEPTS;
-    const kvCacheStore = this.context.env.KV_CONCEPT_CACHE;
-    let cursor: string | undefined = undefined;
-    let nameKeyMap: Record<string, string> = {}; // { name: kvKey }
-    let totalKeysScanned = 0;
-    let batchIndex = 0;
-    const prefix = `concepts:en-us:${conceptSlug}:`; // ✅ Fetch only for this concept
-
-    do {
-      const response: KVNamespaceListResult<KVConcept> = await kvStore.list({
-        prefix,
-        cursor,
-        limit: batchSize, // ✅ Fetch in batches
-      });
-
-      const {
-        keys,
-        cursor: newCursor,
-      }: { keys: KVNamespaceListKey<KVConcept>[]; cursor?: string } = response;
-      totalKeysScanned += keys.length;
-
-      for (const key of keys) {
-        const kvData = await kvStore.get<KVConcept>(key.name, 'json');
-        if (kvData?.name) {
-          nameKeyMap[kvData.name] = key.name; // Map name to its KV key
-        }
-      }
-
-      // ✅ Store this batch separately for the concept to avoid exceeding KV limits
-      await kvCacheStore.put(
-        `cache:concepts:en-us:${conceptSlug}:${batchIndex}`,
-        JSON.stringify(nameKeyMap)
-      );
-      console.log(
-        `📦 Stored batch ${batchIndex} for ${conceptSlug}, ${
-          Object.keys(nameKeyMap).length
-        } names`
-      );
-
-      batchIndex++;
-      nameKeyMap = {}; // ✅ Clear for the next batch
-      cursor = newCursor;
-    } while (cursor);
-
-    console.log(
-      `✅ Cached ${totalKeysScanned} EN names for ${conceptSlug} in ${batchIndex} batches.`
-    );
-    return {
-      message: `Cached ${totalKeysScanned} EN names for ${conceptSlug} in ${batchIndex} batches.`,
-    };
-  }
-
-  async cacheDuplicateConcepts(conceptSlug: Concept) {
-    console.log(`🔍 Identifying duplicate entries for concept: ${conceptSlug}`);
-
-    const kvCacheStore = this.context.env.KV_CONCEPT_CACHE;
-    let cursor: string | undefined = undefined;
-    let batchIndex = 0;
-    let duplicateKeys: string[] = [];
-
-    do {
-      const batchKey = `cache:concepts:en-us:${conceptSlug}:${batchIndex}`;
-      const batchData = await kvCacheStore.get<{ [name: string]: string[] }>(
-        batchKey,
-        'json'
-      );
-
-      if (!batchData) {
-        console.log(`⚠️ No data found for batch: ${batchKey}, stopping.`);
-        break;
-      }
-
-      console.log(
-        `📦 Processing batch ${batchIndex} with ${
-          Object.keys(batchData).length
-        } names`
-      );
-
-      for (const [name, keys] of Object.entries(batchData)) {
-        if (keys.length > 1) {
-          // Collect duplicate entries (all but the first one)
-          duplicateKeys.push(...keys.slice(1));
-        }
-      }
-
-      batchIndex++;
-    } while (true);
-
-    if (duplicateKeys.length === 0) {
-      console.log(`✅ No duplicates found for ${conceptSlug}.`);
-      return;
-    }
-
-    console.log(
-      `🚨 Found ${duplicateKeys.length} duplicate entries for ${conceptSlug}`
-    );
-
-    // Store the duplicate keys list in KV
-    await kvCacheStore.put(
-      `cache:duplicates:${conceptSlug}`,
-      JSON.stringify(duplicateKeys)
-    );
-
-    console.log(`✅ Stored duplicate keys for ${conceptSlug} in cache.`);
-  }
-
   async generateAstroReportContent(
-    params: AstroReportParams | { entityType: string; name: string; override?: boolean },
+    params:
+      | AstroReportParams
+      | { entityType: string; name: string; override?: boolean },
     override: boolean = false
   ): Promise<void> {
     console.log(
-      `🚀 Generating content for ${JSON.stringify(params)}, override: ${override}`
+      `🚀 Generating content for ${JSON.stringify(
+        params
+      )}, override: ${override}`
     );
-  
+
     const db = drizzle(this.context.env.DB);
     let table, whereClause;
-  
+
     let report: AstroReportRow | DescriptionTemplateRow;
     const isReport = 'reportType' in params;
-  
+
     if (isReport) {
       switch (params.reportType) {
         case 'sign':
@@ -1587,18 +1181,25 @@ export class ConceptService {
                 break;
               case 'pure':
                 if (!('dominantElement' in params))
-                  throw new Error('Missing dominantElement for pure element report');
+                  throw new Error(
+                    'Missing dominantElement for pure element report'
+                  );
                 nameValue = params.dominantElement;
                 break;
               case 'preponderant_lacking':
-                if (!('dominantElement' in params) || !('lackingElement' in params))
+                if (
+                  !('dominantElement' in params) ||
+                  !('lackingElement' in params)
+                )
                   throw new Error(
                     'Missing dominantElement or lackingElement for preponderant_lacking element report'
                   );
                 nameValue = `${params.dominantElement}-${params.lackingElement}`;
                 break;
               default:
-                throw new Error(`Unknown element subtype: ${(params as any).subtype}`);
+                throw new Error(
+                  `Unknown element subtype: ${(params as any).subtype}`
+                );
             }
           } else {
             if (!('name' in params))
@@ -1630,21 +1231,24 @@ export class ConceptService {
         .where(whereClause)
         .get()) as DescriptionTemplateRow;
     }
-  
+
     const id = report.id;
     const hasContent = isReport
-      ? (report as AstroReportRow).enReport && (report as AstroReportRow).ptReport
-      : (report as DescriptionTemplateRow).enDescription !== 'Pending generation' &&
-        (report as DescriptionTemplateRow).ptDescription !== 'Pendente de geração';
-  
+      ? (report as AstroReportRow).enReport &&
+        (report as AstroReportRow).ptReport
+      : (report as DescriptionTemplateRow).enDescription !==
+          'Pending generation' &&
+        (report as DescriptionTemplateRow).ptDescription !==
+          'Pendente de geração';
+
     if (!override && hasContent) {
       console.log(`⚡ Content already exists for ${id}, skipping`);
       return;
     }
-  
+
     let attempts = 0;
     const maxAttempts = 2;
-  
+
     while (attempts < maxAttempts) {
       let phase = 'generation';
       try {
@@ -1654,7 +1258,7 @@ export class ConceptService {
             isReport ? 'report' : 'description'
           } content for ${id}...`
         );
-  
+
         let messages: ChatMessages;
         if (isReport) {
           messages = this.context
@@ -1665,7 +1269,7 @@ export class ConceptService {
         } else {
           messages = this.generateDescriptionMessages(params);
         }
-  
+
         console.log(`📨 Sending messages to AI: ${JSON.stringify(messages)}`);
         const response = await this.context
           .api()
@@ -1673,19 +1277,20 @@ export class ConceptService {
         if (!response) {
           throw new Error(`❌ AI returned an empty response for ${id}`);
         }
-  
+
         phase = 'parsing';
         console.log(
           `📝 Received AI response for ${id}: ${response.slice(0, 200)}${
             response.length > 200 ? '...' : ''
           }`
         );
-  
+
         if (isReport) {
-          const { enReport, ptReport } = await this.parseAstrologicalReportContent(
-            (params as AstroReportParams).reportType,
-            response
-          );
+          const { enReport, ptReport } =
+            await this.parseAstrologicalReportContent(
+              (params as AstroReportParams).reportType,
+              response
+            );
           console.log(`💾 Storing report content for ${id}`);
           await db
             .update(table as any)
@@ -1696,7 +1301,8 @@ export class ConceptService {
             .where(eq((table as any).id, id))
             .run();
         } else {
-          const { enDescription, ptDescription } = await this.parseDescriptionContent(response);
+          const { enDescription, ptDescription } =
+            await this.parseDescriptionContent(response);
           console.log(`💾 Storing description content for ${id}`);
           await db
             .update(table as any)
@@ -1707,16 +1313,18 @@ export class ConceptService {
             .where(eq(astroDescriptionTemplates.id, id))
             .run();
         }
-  
+
         console.log(
           `✅ ${isReport ? 'Report' : 'Description'} content stored for ${id}`
         );
         return;
       } catch (error) {
         console.error(
-          `❌ Attempt ${attempts} failed at phase: ${phase} for ${id}: ${(error as Error).message}`
+          `❌ Attempt ${attempts} failed at phase: ${phase} for ${id}: ${
+            (error as Error).message
+          }`
         );
-  
+
         const failureKey = `failures:astro:${
           isReport ? (params as AstroReportParams).reportType : 'description'
         }:${id}`;
@@ -1730,7 +1338,7 @@ export class ConceptService {
             timestamp: new Date().toISOString(),
           })
         );
-  
+
         if (attempts >= maxAttempts) {
           console.error(
             `🚨 All ${maxAttempts} attempts failed at phase ${phase} for ${id}`
@@ -1741,7 +1349,7 @@ export class ConceptService {
             } for ${id} after ${maxAttempts} attempts`
           );
         }
-  
+
         console.log('🔁 Retrying...');
         await new Promise((resolve) => setTimeout(resolve, 2000));
       }
@@ -1862,58 +1470,66 @@ export class ConceptService {
 
   private parseAstrologicalReport(response: string): AstrologicalReport[] {
     console.log('📌 Starting parseAstrologicalReport');
-  
+
     // Step 1: Strip any unexpected introductory text
     const prefixRegex = /^[\s\S]*?(?=--\s*(EN|PT)\s*\n)/;
     response = response.replace(prefixRegex, '').trim();
-    console.log(`📝 Cleaned response:\n${response.slice(0, 200)}${response.length > 200 ? '...' : ''}`);
-  
+    console.log(
+      `📝 Cleaned response:\n${response.slice(0, 200)}${
+        response.length > 200 ? '...' : ''
+      }`
+    );
+
     // Step 2: Split into language sections
     const languageSections = response
       .split(/--\s*(EN|PT)\s*\n/)
       .filter(Boolean);
     console.log(`🔍 Split response into ${languageSections.length} sections`);
-  
+
     // Validate: Expect exactly 4 parts (EN, content, PT, content)
     if (languageSections.length !== 4) {
       throw new Error(
-        `Invalid response format: Expected exactly 2 sections (EN and PT), got ${languageSections.length / 2}`
+        `Invalid response format: Expected exactly 2 sections (EN and PT), got ${
+          languageSections.length / 2
+        }`
       );
     }
-  
+
     const reports: AstrologicalReport[] = [];
-  
+
     for (let i = 0; i < languageSections.length; i += 2) {
       const language = languageSections[i].trim();
       const content = languageSections[i + 1]?.trim();
       console.log(`🚀 Processing section ${i / 2 + 1}: Language = ${language}`);
-  
+
       if (!content || !language.match(/^(EN|PT)$/)) {
         throw new Error(
-          `Invalid section ${i / 2 + 1}: Language must be "EN" or "PT", got "${language}"`
+          `Invalid section ${
+            i / 2 + 1
+          }: Language must be "EN" or "PT", got "${language}"`
         );
       }
-  
+
       console.log(
         `📜 Raw content for ${language}:\n${content.slice(0, 500)}${
           content.length > 500 ? '...' : ''
         }`
       );
-  
+
       const report: AstrologicalReport = {
         language,
         title: [],
         sections: {},
       };
-  
+
       const lines = content.split('\n').map((line) => line.trim());
       console.log(`🔢 Split into ${lines.length} lines`);
-  
+
       let currentSection = '';
       for (let j = 0; j < lines.length; j++) {
         const line = lines[j];
         console.log(`📏 Processing line ${j + 1}: "${line}"`);
-  
+
         if (line.startsWith('### ') && report.title.length === 0) {
           const titleContent = cleanText(line.replace('### ', ''));
           console.log(`🏷️ Found title: "${titleContent}"`);
@@ -1923,21 +1539,22 @@ export class ConceptService {
           });
           continue;
         }
-  
+
         if (line.startsWith('#### ')) {
           currentSection = cleanText(line.replace('#### ', '').trim());
           console.log(`🗂️ New section: "${currentSection}"`);
-          report.sections[currentSection] = report.sections[currentSection] || [];
+          report.sections[currentSection] =
+            report.sections[currentSection] || [];
           continue;
         }
-  
+
         if (!line || !currentSection) {
           console.log(
             `⏩ Skipping line: ${!line ? 'Empty' : 'No current section'}`
           );
           continue;
         }
-  
+
         // Validate language consistency
         const hasPortuguese = /[ãáâéêíóôõúç]/i.test(line);
         const hasEnglish = /[a-zA-Z]/.test(line); // Fixed regex to check for English letters
@@ -1950,16 +1567,16 @@ export class ConceptService {
             `⚠️ Possible invalid content in PT section: No recognizable characters in "${line}"`
           );
         }
-  
+
         if (line.match(/^\d+\.\s/) || line.startsWith('- ')) {
           const listItem = line.replace(/^\d+\.\s|- /, '').trim();
           console.log(`🔹 Bullet point detected: "${listItem}"`);
           const boldMatch = listItem.match(/^\*\*(.+?)\*\*[:\s]*(.+)?$/);
-  
+
           if (boldMatch) {
             const title = cleanText(boldMatch[1]);
             let content = boldMatch[2] ? cleanText(boldMatch[2]) : '';
-  
+
             if (!content && j + 1 < lines.length) {
               const nextLine = lines[j + 1];
               console.log(`🔍 Checking next line for content: "${nextLine}"`);
@@ -1974,7 +1591,7 @@ export class ConceptService {
                 j++;
               }
             }
-  
+
             console.log(
               `✅ Bold match found - Title: "${title}", Content: "${
                 content || 'None'
@@ -1994,14 +1611,14 @@ export class ConceptService {
           }
           continue;
         }
-  
+
         console.log(`📝 Paragraph: "${line}"`);
         report.sections[currentSection].push({
           type: 'p',
           content: cleanText(line),
         });
       }
-  
+
       console.log(
         `🏁 Finished parsing ${language} section. Result:\n${JSON.stringify(
           report,
@@ -2011,7 +1628,7 @@ export class ConceptService {
       );
       reports.push(report);
     }
-  
+
     console.log(`🎉 Parsing complete. Total reports: ${reports.length}`);
     return reports;
   }
@@ -2092,4 +1709,133 @@ export class ConceptService {
     );
     return true; // Everything is ready
   }
+
+  async getConceptBySlug(conceptSlug: Concept) {
+    const db = this.context.drizzle();
+    const [concept] = await db
+      .select({
+        id: schema.concepts.id,
+        planet1: schema.concepts.planet1,
+        planet2: schema.concepts.planet2,
+        planet3: schema.concepts.planet3,
+      })
+      .from(schema.concepts)
+      .where(eq(schema.concepts.slug, conceptSlug))
+      .limit(1)
+      .execute();
+    return concept || null;
+  }
+
+  async getUserSigns(userId: string, planets: string[]) {
+    const db = this.context.drizzle();
+    const userSigns = await db
+      .select({
+        name: schema.astroPlanets.name,
+        sign: schema.astroPlanets.sign,
+      })
+      .from(schema.astroPlanets)
+      .where(
+        and(
+          eq(schema.astroPlanets.userId, userId),
+          inArray(schema.astroPlanets.name, planets)
+        )
+      )
+      .execute();
+    return userSigns;
+  }
+
+  async getOrCreateConceptCombination(
+    conceptId: string,
+    combinationString: string,
+    planets: string[],
+    signs: { name: string; sign: string }[]
+  ) {
+    const db = this.context.drizzle();
+    const [existing] = await db
+      .select({ id: schema.conceptCombinations.id })
+      .from(schema.conceptCombinations)
+      .where(
+        and(
+          eq(schema.conceptCombinations.conceptId, conceptId),
+          eq(schema.conceptCombinations.combinationString, combinationString)
+        )
+      )
+      .limit(1)
+      .execute();
+
+    if (existing) return existing.id;
+
+    const newId = uuidv4();
+    await db
+      .insert(schema.conceptCombinations)
+      .values({
+        id: newId,
+        conceptId,
+        planet1Sign: signs.find((p) => p.name === planets[0])!.sign,
+        planet2Sign: signs.find((p) => p.name === planets[1])!.sign,
+        planet3Sign: signs.find((p) => p.name === planets[2])!.sign,
+        combinationString,
+      })
+      .execute();
+    return newId;
+  }
+
+  async checkHasPrompt(
+    conceptSlug: Concept,
+    combinationString: string,
+    lang: string = 'en-us'
+  ): Promise<boolean> {
+    const db = this.context.drizzle();
+    const [conceptData] = await db
+      .select({
+        leonardoPrompt: schema.conceptsData.leonardoPrompt,
+      })
+      .from(schema.conceptsData)
+      .where(
+        and(
+          eq(schema.conceptsData.conceptSlug, conceptSlug),
+          eq(schema.conceptsData.combination, combinationString),
+          eq(schema.conceptsData.language, lang)
+        )
+      )
+      .limit(1)
+      .execute();
+
+    return !!conceptData?.leonardoPrompt && conceptData.leonardoPrompt.length > 10;
+  }
+
+// src/services/ConceptService.ts
+async checkConceptCompletion(
+  conceptSlug: Concept,
+  combinationString: string,
+  lang: string = 'en-us'
+): Promise<boolean> {
+  const db = this.context.drizzle();
+  const [conceptData] = await db
+    .select({
+      leonardoPrompt: schema.conceptsData.leonardoPrompt,
+      postImages: schema.conceptsData.postImages,
+      reelImages: schema.conceptsData.reelImages,
+    })
+    .from(schema.conceptsData)
+    .where(
+      and(
+        eq(schema.conceptsData.conceptSlug, conceptSlug),
+        eq(schema.conceptsData.combination, combinationString),
+        eq(schema.conceptsData.language, lang)
+      )
+    )
+    .limit(1)
+    .execute();
+
+  if (!conceptData) return false; // No concept data found
+
+  // Check if postImages and reelImages are valid non-empty JSON arrays
+  const hasPostImages =
+    conceptData.postImages &&
+    conceptData.postImages.trim().length > 4 && // Ensures length > 4 to exclude "[]"
+    JSON.parse(conceptData.postImages).length > 2;
+
+  return !!conceptData.leonardoPrompt && !!hasPostImages;
+}
 }

package/app/workflow/ConceptWorkflow.ts

@@ -1,9 +1,7 @@
 import { inject, injectable } from 'inversify';
-import pMap from 'p-map';
-import { zodiacSignCombinations } from '../../data/zodiacSignCombinations';
-import { Concept, ConceptPhase, ConceptProgress } from '../../types';
+import { Concept } from '../../types';
 import { AppContext } from '../base';
-import { ConceptService } from '../services/ConceptService';
+import { ConceptService } from '../services';
 
 @injectable()
 export class ConceptWorkflow {
@@ -12,173 +10,61 @@ export class ConceptWorkflow {
     @inject(ConceptService) private conceptService: ConceptService
   ) {}
 
-  async processSingle(
+  async execute(
+    userId: string,
     conceptSlug: Concept,
     combinationString: string,
-    phase: ConceptPhase,
-    override?: boolean
+    lang: string = 'en-us'
   ) {
     console.log(
-      `🚀 Processing single concept: ${conceptSlug} | ${combinationString} | Phase: ${phase}`
+      `[${new Date().toISOString()}] Starting ConceptWorkflow for ${conceptSlug}:${combinationString}`,
+      { userId, lang }
     );
 
     try {
-      switch (phase) {
-        case 'basic-info':
-          await this.conceptService.generateBasicInfo(
-            conceptSlug,
-            combinationString,
-            override
-          );
-          break;
-        case 'content':
-          await this.conceptService.generateContent(
-            conceptSlug,
-            combinationString,
-            override
-          );
-          break;
-        case 'leonardo-prompt':
-          await this.conceptService.generatePrompt(
-            conceptSlug,
-            combinationString
-          );
-          break;
-        case 'images':
-          await this.conceptService.generateImages(
-            'en-us',
-            conceptSlug,
-            combinationString
-          );
-          break;
-        default:
-          throw new Error(`Unsupported phase: ${phase}`);
+      // Step 1: Generate Leonardo prompt if missing
+      const hasPrompt = await this.conceptService.checkHasPrompt(
+        conceptSlug,
+        combinationString,
+        lang
+      );
+      if (!hasPrompt) {
+        console.log(
+          `[${new Date().toISOString()}] Generating prompt for ${conceptSlug}:${combinationString}`
+        );
+        await this.conceptService.generatePrompt(
+          conceptSlug,
+          combinationString,
+          false
+        );
+      }
+
+      // Step 2: Generate images if missing
+      if (
+        !(await this.conceptService.checkConceptCompletion(
+          conceptSlug,
+          combinationString,
+          lang
+        ))
+      ) {
+        console.log(
+          `[${new Date().toISOString()}] Generating images for ${conceptSlug}:${combinationString}`
+        );
+        await this.conceptService.generateImages(
+          conceptSlug,
+          combinationString
+        );
       }
 
       console.log(
-        `✅ Concept ${conceptSlug}:${combinationString} successfully processed for phase: ${phase}`
+        `[${new Date().toISOString()}] Concept generation completed for ${conceptSlug}:${combinationString}`
       );
     } catch (error) {
       console.error(
-        `❌ Error processing concept ${conceptSlug}:${combinationString} | Phase: ${phase}:`,
+        `[${new Date().toISOString()}] Error in ConceptWorkflow for ${conceptSlug}:${combinationString}:`,
         error
       );
+      throw error; // Let the queue handle retries
     }
   }
-
-  async processDuplicateNames(conceptSlug: Concept) {
-    console.log(`🔍 Initiating duplicate name resolution for ${conceptSlug}`);
-
-    try {
-      await this.conceptService.regenerateDuplicateNamesForConcept(conceptSlug);
-      console.log(`✅ Duplicate names resolved for ${conceptSlug}`);
-    } catch (error) {
-      console.error(`❌ Error resolving duplicates for ${conceptSlug}:`, error);
-    }
-  }
-
-  async processBatch(
-    conceptSlug: Concept,
-    combinations: string[],
-    phase: ConceptPhase,
-    override: boolean = false
-  ) {
-    console.log(
-      `🚀 Processing batch for concept: ${conceptSlug}, Phase: ${phase}, Total Combinations: ${combinations.length}`
-    );
-
-    const concurrency = 5;
-    const failedCombinations: string[] = [];
-
-    // ✅ Get Durable Object stub for progress tracking
-    const id = this.context.env.CONCEPT_NAMES_DO.idFromName(conceptSlug);
-    const stub = this.context.env.CONCEPT_NAMES_DO.get(id);
-
-    // ✅ Try to load last checkpoint from DO
-    let lastIndex = 0;
-    try {
-      const progressRes = await stub.fetch(`https://internal/progress`);
-      if (progressRes.ok) {
-        const progressData = (await progressRes.json()) as ConceptProgress;
-        lastIndex = progressData.lastIndex || 0;
-        console.log(`🔄 Resuming from index ${lastIndex}`);
-      } else {
-        console.log(`📌 No previous checkpoint found, starting from scratch.`);
-      }
-    } catch (error) {
-      console.error(`❌ Error fetching progress from DO:`, error);
-    }
-
-    // ✅ Filter unprocessed combinations
-    const remainingCombinations = combinations.slice(lastIndex);
-    console.log(
-      `⏳ Processing ${remainingCombinations.length} remaining combinations...`
-    );
-
-    await pMap(
-      remainingCombinations,
-      async (combination, index) => {
-        const currentIndex = lastIndex + index;
-        try {
-          console.log(
-            `🛠️ Processing combination ${currentIndex}/${combinations.length}: ${combination}`
-          );
-          await this.processSingle(conceptSlug, combination, phase, override);
-
-          // ✅ Save progress every 10 iterations in DO
-          if (currentIndex % 10 === 0) {
-            await stub.fetch(`https://internal/set-progress`, {
-              method: 'POST',
-              body: JSON.stringify({ lastIndex: currentIndex }),
-              headers: { 'Content-Type': 'application/json' },
-            });
-            console.log(`✅ Checkpoint saved at index ${currentIndex}`);
-          }
-        } catch (error) {
-          console.error(`❌ Error processing ${combination}:`, error);
-          failedCombinations.push(combination);
-        }
-      },
-      { concurrency }
-    );
-
-    console.log(
-      `✅ Batch processing completed for ${conceptSlug}, Phase: ${phase}`
-    );
-
-    // ✅ Retry failed combinations after all batches
-    if (failedCombinations.length > 0) {
-      console.warn(`⚠️ Retrying failed combinations:`, failedCombinations);
-      await this.processBatch(conceptSlug, failedCombinations, phase, override);
-    }
-
-    console.log(
-      `🎉 All combinations successfully processed for ${conceptSlug}!`
-    );
-  }
-
-  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}`
-    );
-  }
 }

package/package.json

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