@zodic/shared 0.0.307 → 0.0.309

package/app/services/ArchetypeService.ts

@@ -1,4 +1,3 @@
-
 import { and, eq, sql } from 'drizzle-orm';
 import { inject, injectable } from 'inversify';
 import { ChatMessages, Composition, schema } from '../..';
@@ -313,7 +312,8 @@ export class ArchetypeService {
       return;
     }
 
-    const { english: englishNames, portuguese: portugueseVariants } = this.parseArchetypeNameBlocks(response);
+    const { english: englishNames, portuguese: portugueseVariants } =
+      this.parseArchetypeNameBlocks(response);
 
     async function isEnglishNameDuplicate(name: string): Promise<boolean> {
       const result = await db
@@ -610,7 +610,12 @@ export class ArchetypeService {
       return;
     }
 
-    const blocks = response
+    // Clean up the response by removing unexpected suffixes
+    const cleanedResponse = response
+      .replace(/###|---\s*###|-\s*###/g, '')
+      .trim();
+
+    const blocks = cleanedResponse
       .split(/Composition \d+/)
       .slice(1)
       .map((b) => b.trim());
@@ -623,13 +628,13 @@ export class ArchetypeService {
 
       console.log(`🔄 [Batch] Processing: ${combination}`);
 
-      let en = '';
-      let pt = '';
-      try {
-        en = block.split('-EN')[1].split('-PT')[0].trim();
-        pt = block.split('-PT')[1].trim();
-      } catch (err) {
-        console.error(`❌ [Batch] Parsing failed for: ${combination}`, err);
+      const { english, portuguese } = this.parseArchetypeNameBlocks(block);
+
+      if (
+        english.length !== indexes.length ||
+        portuguese.length !== indexes.length
+      ) {
+        console.error(`❌ [Batch] Parsing failed for: ${combination}`);
         await this.context
           .drizzle()
           .insert(schema.archetypeNameDumps)
@@ -643,37 +648,27 @@ export class ArchetypeService {
         continue;
       }
 
-      const english = en
-        .split(/\n\d\.\s*\n?/)
-        .filter(Boolean)
-        .map((line) => ({
-          name: line.match(/• Name:\s*(.+)/)?.[1]?.trim() || '',
-          essenceLine: line.match(/• Essence:\s*(.+)/)?.[1]?.trim() || '',
-        }));
-
-      const portuguese = pt
-        .split(/\n\d\.\s*\n?/)
-        .filter(Boolean)
-        .map((line) => ({
-          masc: line.match(/• Masculino:\s*(.+)/)?.[1]?.trim() || '',
-          fem: line.match(/• Feminino:\s*(.+)/)?.[1]?.trim() || '',
-          essenceLine: line.match(/• Essência:\s*(.+)/)?.[1]?.trim() || '',
-        }));
-
       for (const index of indexes) {
-        if (!english[index - 1] || !portuguese[index - 1]) {
-          await this.context.drizzle().insert(schema.archetypeNameDumps).values({
-            id: `${combination}:${index}:${Date.now()}`,
-            combination,
-            rawText: block,
-            parsedSuccessfully: 0,
-            createdAt: Date.now(),
-          });
-          console.warn(`⚠️ [Batch] Skipping index ${index} for ${combination} due to missing parsed block`);
+        const idx = index - 1;
+        const englishEntry = english[idx];
+        const ptEntry = portuguese[idx];
+
+        if (!englishEntry || !ptEntry) {
+          await this.context
+            .drizzle()
+            .insert(schema.archetypeNameDumps)
+            .values({
+              id: `${combination}:${index}:${Date.now()}`,
+              combination,
+              rawText: block,
+              parsedSuccessfully: 0,
+              createdAt: Date.now(),
+            });
+          console.warn(
+            `⚠️ [Batch] Skipping index ${index} for ${combination} due to missing parsed block`
+          );
           continue;
         }
-        const englishEntry = english[index - 1];
-        const ptEntry = portuguese[index - 1];
 
         for (const gender of ['male', 'female']) {
           const enId = `${combination}:${gender}:${index}`;
@@ -737,11 +732,188 @@ export class ArchetypeService {
       `🎉 [Batch] Completed regenerating ${compositions.length} combinations`
     );
   }
-  
+
+  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}`);
+
+      // Fetch all dump entries for this combination
+      const dumpEntries = await db
+        .select({
+          id: schema.archetypeNameDumps.id,
+          rawText: schema.archetypeNameDumps.rawText,
+        })
+        .from(schema.archetypeNameDumps)
+        .where(eq(schema.archetypeNameDumps.combination, combination))
+        .execute();
+
+      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) {
+        // Find a dump entry that contains the specific index
+        let rawText: string | null = null;
+        for (const entry of dumpEntries) {
+          if (entry.rawText.includes(`-EN ${index}.`)) {
+            rawText = entry.rawText;
+            break;
+          }
+        }
+
+        if (!rawText) {
+          console.log(
+            `⚠️ [Recycle] No dump entry contains index ${index} for combination: ${combination}`
+          );
+          continue;
+        }
+
+        // Clean up the raw text
+        const cleanedText = rawText
+          .replace(/###|---\s*###|-\s*###/g, '')
+          .trim();
+
+        // Extract the specific index sections
+        const enSectionMatch = cleanedText.match(
+          new RegExp(`-EN ${index}\\.\\s*[^-]*(?=-EN|-PT|$)`, 's')
+        );
+        const ptSectionMatch = cleanedText.match(
+          new RegExp(`-PT ${index}\\.\\s*[^-]*(?=-EN|-PT|$)`, 's')
+        );
+
+        if (!enSectionMatch || !ptSectionMatch) {
+          console.log(
+            `⚠️ [Recycle] Could not extract index ${index} sections for combination: ${combination}`
+          );
+          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()}`;
+
+        // Step 3: Parse the block
+        const { english, portuguese } = this.parseArchetypeNameBlocks(block);
+
+        if (english.length === 0 || portuguese.length === 0) {
+          console.error(
+            `❌ [Recycle] Parsing failed for index ${index} of combination: ${combination}`
+          );
+          continue;
+        }
+
+        const englishEntry = english[0];
+        const ptEntry = portuguese[0];
+
+        if (!englishEntry || !ptEntry) {
+          console.warn(
+            `⚠️ [Recycle] Skipping index ${index} for ${combination} due to missing parsed data`
+          );
+          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;
+
+          await this.context
+            .drizzle()
+            .insert(schema.archetypesData)
+            .values({
+              id: enId,
+              combination,
+              gender,
+              archetypeIndex: index.toString(),
+              language: 'en-us',
+              name: englishEntry.name,
+              essenceLine: englishEntry.essenceLine,
+              status: 'idle',
+            })
+            .onConflictDoUpdate({
+              target: [schema.archetypesData.id],
+              set: {
+                name: englishEntry.name,
+                essenceLine: englishEntry.essenceLine,
+                updatedAt: new Date().getTime(),
+              },
+            });
+
+          await this.context
+            .drizzle()
+            .insert(schema.archetypesData)
+            .values({
+              id: ptId,
+              combination,
+              gender,
+              archetypeIndex: index.toString(),
+              language: 'pt-br',
+              name: ptName,
+              essenceLine: ptEntry.essenceLine,
+              status: 'idle',
+            })
+            .onConflictDoUpdate({
+              target: [schema.archetypesData.id],
+              set: {
+                name: ptName,
+                essenceLine: ptEntry.essenceLine,
+                updatedAt: new Date().getTime(),
+              },
+            });
+
+          await db
+            .delete(schema.archetypeNameDumps)
+            .where(
+              eq(
+                schema.archetypeNameDumps.id,
+                dumpEntries.find((e) => e.rawText === rawText)?.id || ''
+              )
+            );
+
+          console.log(
+            `✅ [Recycle] Saved archetype ${index} (${gender}) for ${combination}`
+          );
+        }
+      }
+
+      console.log(`🏁 [Recycle] Finished combination: ${combination}`);
+    }
+
+    console.log(
+      `🎉 [Recycle] Completed recycling for ${compositions.length} combinations`
+    );
+  }
+
   async fetchMissingArchetypeCompositions(): Promise<Composition[]> {
     const db = this.context.drizzle();
     const incomplete = await this.findIncompleteCombinations();
-    console.log(`🔎 [Fetch] Retrieved ${incomplete.length} incomplete combinations`);
+    console.log(
+      `🔎 [Fetch] Retrieved ${incomplete.length} incomplete combinations`
+    );
     const limited = incomplete.slice(0, 400);
 
     const compositions: Composition[] = [];
@@ -776,13 +948,18 @@ export class ArchetypeService {
           moon,
           indexesToGenerate,
         });
-        console.log(`✅ [Fetch] Will regenerate indexes [${indexesToGenerate.join(', ')}] for ${combination}`);
+        console.log(
+          `✅ [Fetch] Will regenerate indexes [${indexesToGenerate.join(
+            ', '
+          )}] for ${combination}`
+        );
       }
     }
 
-    console.log(`📦 [Fetch] Total compositions to regenerate (limited to 400): ${compositions.length}`);
-   
- 
+    console.log(
+      `📦 [Fetch] Total compositions to regenerate (limited to 400): ${compositions.length}`
+    );
+
     return compositions;
   }
 
@@ -794,43 +971,69 @@ export class ArchetypeService {
       english: [] as { name: string; essenceLine: string }[],
       portuguese: [] as { masc: string; fem: string; essenceLine: string }[],
     };
-  
+
     try {
-      const enMatch = block.match(/-EN[\s\S]*?-PT/);
-      const ptMatch = block.match(/-PT[\s\S]*/);
-  
-      const enBlock = enMatch?.[0].replace(/-EN/, '').replace(/-PT/, '').trim() ?? '';
-      const ptBlock = ptMatch?.[0].replace(/-PT/, '').trim() ?? '';
-  
-      result.english = enBlock
-        .split(/\n\d\.\s*\n?/)
+      // 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 name = entry.match(/• Name:\s*(.+)/)?.[1]?.trim() ?? '';
-          const essenceLine = entry.match(/• Essence:\s*(.+)/)?.[1]?.trim() ?? '';
+          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);
+            console.warn(
+              `⚠️ [Parse] Incomplete English entry ${i + 1}:`,
+              entry
+            );
           }
           return { name, essenceLine };
         });
-  
-      result.portuguese = ptBlock
-        .split(/\n\d\.\s*\n?/)
+
+      // Parse Portuguese entries
+      result.portuguese = ptSection
+        .split(/\n?\d+\.\s*\n?/)
         .filter(Boolean)
         .map((entry, i) => {
-          const masc = entry.match(/• Masculino:\s*(.+)/)?.[1]?.trim() ?? '';
-          const fem = entry.match(/• Feminino:\s*(.+)/)?.[1]?.trim() ?? '';
-          const essenceLine = entry.match(/• Essência:\s*(.+)/)?.[1]?.trim() ?? '';
+          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);
+            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);
     }
-  
+
     return result;
   }
 }

package/package.json

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

package/utils/archetypeNamesMessages.ts

@@ -211,6 +211,14 @@ For every composition, return:
 Avoid names that sound like objects, titles, or abstract forces (e.g., The Lantern, The Eclipse, The Veil).
 Instead, use names that suggest a personified being or living archetype, such as The Masked Oracle, The Starborn Seeker, or The Dancer of the Falling Sky.
 
+**Formatting Rules**:
+- Each composition block must start with "Composition <number>" on its own line.
+- Within each composition block, the English section must start with "-EN" on its own line, followed by the entries.
+- The Portuguese section must start with "-PT" on its own line, followed by the entries.
+- Each entry (e.g., "1.", "2.", "3.") must be on its own line, with its sub-items (e.g., "• Name: ...", "• Masculino: ...") on separate lines.
+- Do not include any extra characters, suffixes, or separators (e.g., "###", "---", or extra newlines) at the end of the response or between composition blocks.
+- Ensure that Portuguese names correctly match the gender: "Masculino" names should use masculine forms (e.g., "O Sábio"), and "Feminino" names should use feminine forms (e.g., "A Sábia").
+
 Do not include any commentary or explanations outside the defined output structure. Only return the output block for each composition, exactly as described:`;
 
   const compositionBlocks = compositions.map((comp, i) => {
@@ -219,7 +227,7 @@ Do not include any commentary or explanations outside the defined output structu
     const moon = influenceMap.moon[comp.moon];
     const indexes = comp.indexesToGenerate ?? [1, 2, 3];
 
-    const influences = `\n\n### Composition ${i + 1}
+    const influences = `\n\nComposition ${i + 1}
 
 • First Influence – ${sun.label}: ${sun.description}  
 • Second Influence – ${asc.label}: ${asc.description}  
@@ -228,28 +236,28 @@ Do not include any commentary or explanations outside the defined output structu
     const enLines = indexes
       .map(
         (idx) => `${idx}.  
-  • Name: [Name that emphasizes the ${
-    ['first', 'second', 'third'][idx - 1]
-  } influence, while blending the other two]  
-  • Essence: [Short poetic description line in English]`
+• Name: [Name that emphasizes the ${
+          ['first', 'second', 'third'][idx - 1]
+        } influence, while blending the other two]  
+• Essence: [Short poetic description line in English]`
       )
       .join('\n');
 
     const ptLines = indexes
       .map(
         (idx) => `${idx}.  
-  • Masculino: [Portuguese name (masc)]  
-  • Feminino: [Portuguese name (fem)]  
-  • Essência: [Short poetic description line in Portuguese]`
+• Masculino: [Portuguese name (masc)]  
+• Feminino: [Portuguese name (fem)]  
+• Essência: [Short poetic description line in Portuguese]`
       )
       .join('\n');
 
     return `${influences}
 
-\`\n-EN  
+\`\n-EN
 ${enLines}
 
--PT  
+-PT
 ${ptLines}
 \``;
   });