@zodic/shared 0.0.310 → 0.0.312

package/app/services/ArchetypeService.ts

@@ -733,28 +733,26 @@ export class ArchetypeService {
     );
   }
 
-  async recycleArchetypeNameDumpsBatch(
-    compositions: Composition[]
-  ): Promise<void> {
+  async recycleArchetypeNameDumpsBatch(compositions: Composition[]): Promise<void> {
     console.log('🔁 [Recycle] Starting recycling of archetype name dumps');
-
+  
     if (compositions.length === 0) {
       console.log('✅ [Recycle] No compositions provided for recycling');
       return;
     }
-
+  
     console.log(
       `📦 [Recycle] Total compositions to recycle: ${compositions.length}`
     );
-
+  
     // Step 1: Process each composition
     const db = this.context.drizzle();
     for (const comp of compositions) {
       const combination = [comp.sun, comp.ascendant, comp.moon].join('-');
       const indexes = comp.indexesToGenerate ?? [1, 2, 3];
-
-      console.log(`🔄 [Recycle] Processing: ${combination}`);
-
+  
+      console.log(`🔄 [Recycle] Processing combination: ${combination} with indexes: [${indexes.join(', ')}]`);
+  
       // Fetch all dump entries for this combination
       const dumpEntries = await db
         .select({
@@ -764,37 +762,50 @@ export class ArchetypeService {
         .from(schema.archetypeNameDumps)
         .where(eq(schema.archetypeNameDumps.combination, combination))
         .execute();
-
+  
+      console.log(
+        `[Recycle] Retrieved ${dumpEntries.length} dump entries for ${combination}: ${JSON.stringify(dumpEntries, null, 2)}`
+      );
+  
       if (dumpEntries.length === 0) {
         console.log(
           `⚠️ [Recycle] No dump entries found for combination: ${combination}`
         );
         continue;
       }
-
+  
       // Step 2: Process each missing index
       for (const index of indexes) {
+        console.log(`[Recycle] Processing index ${index} for ${combination}`);
+  
         // Find a dump entry that contains the specific index
         let rawText: string | null = null;
+        let selectedEntryId: string | null = null;
         for (const entry of dumpEntries) {
-          if (entry.rawText.includes(`-EN ${index}.`)) {
+          if (entry.rawText && entry.rawText.includes(`-EN ${index}.`)) {
             rawText = entry.rawText;
+            selectedEntryId = entry.id;
+            console.log(
+              `[Recycle] Selected dump entry for index ${index} with id ${selectedEntryId}: ${rawText}`
+            );
             break;
           }
         }
-
+  
         if (!rawText) {
           console.log(
             `⚠️ [Recycle] No dump entry contains index ${index} for combination: ${combination}`
           );
           continue;
         }
-
+  
         // Clean up the raw text
+        console.log(`[Recycle] Cleaning rawText for index ${index}: ${rawText}`);
         const cleanedText = rawText
           .replace(/###|---\s*###|-\s*###/g, '')
           .trim();
-
+        console.log(`[Recycle] Cleaned text for index ${index}: ${cleanedText}`);
+  
         // Extract the specific index sections
         const enSectionMatch = cleanedText.match(
           new RegExp(`-EN ${index}\\.\\s*[^-]*(?=-EN|-PT|$)`, 's')
@@ -802,45 +813,77 @@ export class ArchetypeService {
         const ptSectionMatch = cleanedText.match(
           new RegExp(`-PT ${index}\\.\\s*[^-]*(?=-EN|-PT|$)`, 's')
         );
-
-        if (!enSectionMatch || !ptSectionMatch) {
+  
+        console.log(
+          `[Recycle] Extracted sections for index ${index} - enSectionMatch: ${JSON.stringify(enSectionMatch)}, ptSectionMatch: ${JSON.stringify(ptSectionMatch)}`
+        );
+  
+        if (!enSectionMatch || !ptSectionMatch || !enSectionMatch[0] || !ptSectionMatch[0]) {
           console.log(
-            `⚠️ [Recycle] Could not extract index ${index} sections for combination: ${combination}`
+            `⚠️ [Recycle] Could not extract index ${index} sections for combination: ${combination}. enSectionMatch: ${JSON.stringify(enSectionMatch)}, ptSectionMatch: ${JSON.stringify(ptSectionMatch)}`
           );
           continue;
         }
-
+  
         // Combine the extracted sections into a block for parsing
-        const block = `-EN\n${enSectionMatch[0]
-          .replace(/-EN\s*/, '')
-          .trim()}\n\n-PT\n${ptSectionMatch[0].replace(/-PT\s*/, '').trim()}`;
-
+        const block = `-EN\n${enSectionMatch[0].replace(/-EN\s*/, '').trim()}\n\n-PT\n${ptSectionMatch[0].replace(/-PT\s*/, '').trim()}`;
+        console.log(`[Recycle] Constructed block for index ${index}: ${block}`);
+  
         // Step 3: Parse the block
         const { english, portuguese } = this.parseArchetypeNameBlocks(block);
-
+        console.log(
+          `[Recycle] Parsed results for index ${index} - English: ${JSON.stringify(english, null, 2)}, Portuguese: ${JSON.stringify(portuguese, null, 2)}`
+        );
+  
         if (english.length === 0 || portuguese.length === 0) {
           console.error(
-            `❌ [Recycle] Parsing failed for index ${index} of combination: ${combination}`
+            `❌ [Recycle] Parsing failed for index ${index} of combination: ${combination}. Block: ${block}`
           );
+          if (block) {
+            await this.context
+              .drizzle()
+              .insert(schema.archetypeNameDumps)
+              .values({
+                id: `${combination}:${index}:${Date.now()}`,
+                combination,
+                rawText: block,
+                parsedSuccessfully: 0,
+                createdAt: Date.now(),
+              });
+            console.log(
+              `[Recycle] Logged failed parse to archetype_name_dumps for index ${index} of ${combination}`
+            );
+          } else {
+            console.error(
+              `❌ [Recycle] Cannot log failed parse to archetype_name_dumps: block is undefined`
+            );
+          }
           continue;
         }
-
+  
         const englishEntry = english[0];
         const ptEntry = portuguese[0];
-
+  
+        console.log(
+          `[Recycle] Extracted entries for index ${index} - englishEntry: ${JSON.stringify(englishEntry, null, 2)}, ptEntry: ${JSON.stringify(ptEntry, null, 2)}`
+        );
+  
         if (!englishEntry || !ptEntry) {
           console.warn(
-            `⚠️ [Recycle] Skipping index ${index} for ${combination} due to missing parsed data`
+            `⚠️ [Recycle] Skipping index ${index} for ${combination} due to missing parsed data. englishEntry: ${JSON.stringify(englishEntry)}, ptEntry: ${JSON.stringify(ptEntry)}`
           );
           continue;
         }
-
+  
         // Step 4: Insert the parsed data into archetypes_data
         for (const gender of ['male', 'female']) {
           const enId = `${combination}:${gender}:${index}`;
           const ptId = `${combination}:${gender}:${index}:pt`;
           const ptName = gender === 'female' ? ptEntry.fem : ptEntry.masc;
-
+  
+          console.log(
+            `[Recycle] Inserting English entry for ${combination}, index ${index}, gender ${gender}: id=${enId}, name=${englishEntry.name}, essenceLine=${englishEntry.essenceLine}`
+          );
           await this.context
             .drizzle()
             .insert(schema.archetypesData)
@@ -862,7 +905,10 @@ export class ArchetypeService {
                 updatedAt: new Date().getTime(),
               },
             });
-
+  
+          console.log(
+            `[Recycle] Inserting Portuguese entry for ${combination}, index ${index}, gender ${gender}: id=${ptId}, name=${ptName}, essenceLine=${ptEntry.essenceLine}`
+          );
           await this.context
             .drizzle()
             .insert(schema.archetypesData)
@@ -884,25 +930,33 @@ export class ArchetypeService {
                 updatedAt: new Date().getTime(),
               },
             });
-
-          await db
-            .delete(schema.archetypeNameDumps)
-            .where(
-              eq(
-                schema.archetypeNameDumps.id,
-                dumpEntries.find((e) => e.rawText === rawText)?.id || ''
-              )
+  
+          // Delete the processed dump entry
+          if (selectedEntryId) {
+            console.log(
+              `[Recycle] Deleting dump entry with id ${selectedEntryId} for ${combination}, index ${index}`
             );
-
+            await db
+              .delete(schema.archetypeNameDumps)
+              .where(eq(schema.archetypeNameDumps.id, selectedEntryId));
+            console.log(
+              `[Recycle] Successfully deleted dump entry with id ${selectedEntryId}`
+            );
+          } else {
+            console.warn(
+              `[Recycle] Could not delete dump entry for ${combination}, index ${index}: selectedEntryId is null`
+            );
+          }
+  
           console.log(
             `✅ [Recycle] Saved archetype ${index} (${gender}) for ${combination}`
           );
         }
       }
-
+  
       console.log(`🏁 [Recycle] Finished combination: ${combination}`);
     }
-
+  
     console.log(
       `🎉 [Recycle] Completed recycling for ${compositions.length} combinations`
     );
@@ -963,77 +1017,100 @@ export class ArchetypeService {
     return compositions;
   }
 
-  private parseArchetypeNameBlocks(block: string): {
-    english: { name: string; essenceLine: string }[];
-    portuguese: { masc: string; fem: string; essenceLine: string }[];
+  parseArchetypeNameBlocks(block: string): {
+    english: any[];
+    portuguese: any[];
   } {
-    const result = {
-      english: [] as { name: string; essenceLine: string }[],
-      portuguese: [] as { masc: string; fem: string; essenceLine: string }[],
-    };
-
-    try {
-      // Normalize the block by replacing multiple spaces with a single space and ensuring newlines
-      const normalizedBlock = block
-        .replace(/\s+/g, ' ')
-        .replace(/-EN\s*/, '-EN\n')
-        .replace(/-PT\s*/, '\n-PT\n')
-        .trim();
-
-      // Split into EN and PT sections
-      const sections = normalizedBlock.split(/\n?-PT\n/);
-      const enSection = sections[0]?.replace(/-EN\n/, '').trim() ?? '';
-      const ptSection = sections[1]?.trim() ?? '';
-
-      // Parse English entries
-      result.english = enSection
-        .split(/\n?\d+\.\s*\n?/)
-        .filter(Boolean)
-        .map((entry, i) => {
-          const nameMatch = entry.match(/• Name:\s*([^•]+)/);
-          const essenceMatch = entry.match(/• Essence:\s*([^•]+)/);
-          const name = nameMatch?.[1]?.trim() ?? '';
-          const essenceLine = essenceMatch?.[1]?.trim() ?? '';
-          if (!name || !essenceLine) {
-            console.warn(
-              `⚠️ [Parse] Incomplete English entry ${i + 1}:`,
-              entry
-            );
-          }
-          return { name, essenceLine };
-        });
-
-      // Parse Portuguese entries
-      result.portuguese = ptSection
-        .split(/\n?\d+\.\s*\n?/)
-        .filter(Boolean)
-        .map((entry, i) => {
-          const mascMatch = entry.match(/• Masculino:\s*([^•]+)/);
-          const femMatch = entry.match(/• Feminino:\s*([^•]+)/);
-          const essenceMatch = entry.match(/• Essência:\s*([^•]+)/);
-          const masc = mascMatch?.[1]?.trim() ?? '';
-          const fem = femMatch?.[1]?.trim() ?? '';
-          const essenceLine = essenceMatch?.[1]?.trim() ?? '';
-          if (!masc || !fem || !essenceLine) {
-            console.warn(
-              `⚠️ [Parse] Incomplete Portuguese entry ${i + 1}:`,
-              entry
-            );
-          }
-          // Validate gender consistency
-          if (masc.startsWith('A ') && fem.startsWith('O ')) {
-            console.warn(
-              `⚠️ [Parse] Gender mismatch in Portuguese entry ${i + 1}:`,
-              entry
-            );
-            return { masc: fem, fem: masc, essenceLine }; // Swap to correct the mismatch
-          }
-          return { masc, fem, essenceLine };
-        });
-    } catch (error) {
-      console.error('❌ [Parse] Failed to parse block:', error);
+    console.log(`[Parse] Starting parsing of block: ${block}`);
+  
+    const sections = block.split(/^-EN|^-PT/m).filter((s) => s.trim());
+    console.log(
+      `[Parse] Split block into ${sections.length} sections: ${JSON.stringify(sections, null, 2)}`
+    );
+  
+    const english: any[] = [];
+    const portuguese: any[] = [];
+  
+    for (const section of sections) {
+      console.log(`[Parse] Processing section: ${section}`);
+  
+      if (section.startsWith('EN')) {
+        const lines = section.split('\n').filter((l) => l.trim());
+        console.log(
+          `[Parse] Extracted ${lines.length} lines from English section: ${JSON.stringify(lines, null, 2)}`
+        );
+  
+        const nameMatch = lines
+          .find((l) => l.includes('• Name:'))
+          ?.split('• Name:')[1]
+          ?.trim();
+        console.log(`[Parse] English nameMatch: ${nameMatch}`);
+  
+        const essenceMatch = lines
+          .find((l) => l.includes('• Essence:'))
+          ?.split('• Essence:')[1]
+          ?.trim();
+        console.log(`[Parse] English essenceMatch: ${essenceMatch}`);
+  
+        if (nameMatch && essenceMatch) {
+          const entry = { name: nameMatch, essenceLine: essenceMatch };
+          english.push(entry);
+          console.log(
+            `[Parse] Added English entry: ${JSON.stringify(entry, null, 2)}`
+          );
+        } else {
+          console.warn(
+            `[Parse] Skipping English section due to missing fields. nameMatch: ${nameMatch}, essenceMatch: ${essenceMatch}`
+          );
+        }
+      } else if (section.startsWith('PT')) {
+        const lines = section.split('\n').filter((l) => l.trim());
+        console.log(
+          `[Parse] Extracted ${lines.length} lines from Portuguese section: ${JSON.stringify(lines, null, 2)}`
+        );
+  
+        const mascMatch = lines
+          .find((l) => l.includes('• Masculino:'))
+          ?.split('• Masculino:')[1]
+          ?.trim();
+        console.log(`[Parse] Portuguese mascMatch: ${mascMatch}`);
+  
+        const femMatch = lines
+          .find((l) => l.includes('• Feminino:'))
+          ?.split('• Feminino:')[1]
+          ?.trim();
+        console.log(`[Parse] Portuguese femMatch: ${femMatch}`);
+  
+        const essenceMatch = lines
+          .find((l) => l.includes('• Essência:'))
+          ?.split('• Essência:')[1]
+          ?.trim();
+        console.log(`[Parse] Portuguese essenceMatch: ${essenceMatch}`);
+  
+        if (mascMatch && femMatch && essenceMatch) {
+          const entry = {
+            masc: mascMatch,
+            fem: femMatch,
+            essenceLine: essenceMatch,
+          };
+          portuguese.push(entry);
+          console.log(
+            `[Parse] Added Portuguese entry: ${JSON.stringify(entry, null, 2)}`
+          );
+        } else {
+          console.warn(
+            `[Parse] Skipping Portuguese section due to missing fields. mascMatch: ${mascMatch}, femMatch: ${femMatch}, essenceMatch: ${essenceMatch}`
+          );
+        }
+      } else {
+        console.warn(`[Parse] Unrecognized section: ${section}`);
+      }
     }
-
-    return result;
+  
+    console.log(
+      `[Parse] Final parsed results - English: ${JSON.stringify(english, null, 2)}, Portuguese: ${JSON.stringify(portuguese, null, 2)}`
+    );
+  
+    return { english, portuguese };
   }
 }

package/package.json

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