@zodic/shared 0.0.298 → 0.0.299

package/app/services/ArchetypeService.ts

@@ -290,21 +290,21 @@ export class ArchetypeService {
     overrideExisting: boolean = false
   ) {
     const db = this.context.drizzle();
+    console.log(`🚀 [Single] Starting generation for combination: ${combination} | Override: ${overrideExisting}`);
+  
     const [sun, ascendant, moon] = combination.split('-') as ZodiacSignSlug[];
-
     const prompt = generateArchetypePrompt([{ sun, ascendant, moon }]);
     const messages: ChatMessages = [{ role: 'user', content: prompt }];
     const response = await this.context.api().callTogether.single(messages, {});
-
+  
     if (!response) {
-      throw new Error(
-        `No response when generating archetype names for ${combination}`
-      );
+      console.error(`❌ [Single] No response for: ${combination}`);
+      return;
     }
-
+  
     let blocks: string[] = [];
     let ptBlocks: string[] = [];
-
+  
     try {
       blocks = response
         .split('-EN')[1]
@@ -312,14 +312,14 @@ export class ArchetypeService {
         .trim()
         .split(/\n\d\.\s*\n?/)
         .filter(Boolean);
-
+  
       ptBlocks = response
         .split('-PT')[1]
         .trim()
         .split(/\n\d\.\s*\n?/)
         .filter(Boolean);
     } catch (err) {
-      console.error(`Parsing failed for combination: ${combination}`, err);
+      console.error(`❌ [Single] Parsing failed for ${combination}`, err);
       await db.insert(schema.archetypeNameDumps).values({
         id: combination,
         combination,
@@ -329,24 +329,18 @@ export class ArchetypeService {
       });
       return;
     }
-
-    const englishNames = blocks.map((block) => {
-      const nameMatch = block.match(/• Name:\s*(.+)/);
-      const essenceMatch = block.match(/• Essence:\s*(.+)/);
-      return {
-        name: nameMatch?.[1]?.trim() || '',
-        essenceLine: essenceMatch?.[1]?.trim() || '',
-      };
-    });
-
-    const portugueseVariants = ptBlocks.map((block) => {
-      const masc = block.match(/• Masculino:\s*(.+)/)?.[1]?.trim() || '';
-      const fem = block.match(/• Feminino:\s*(.+)/)?.[1]?.trim() || '';
-      const essence = block.match(/• Essência:\s*(.+)/)?.[1]?.trim() || '';
-      return { masc, fem, essenceLine: essence };
-    });
-
-    // Duplicate helper
+  
+    const englishNames = blocks.map((block) => ({
+      name: block.match(/• Name:\s*(.+)/)?.[1]?.trim() || '',
+      essenceLine: block.match(/• Essence:\s*(.+)/)?.[1]?.trim() || '',
+    }));
+  
+    const portugueseVariants = ptBlocks.map((block) => ({
+      masc: block.match(/• Masculino:\s*(.+)/)?.[1]?.trim() || '',
+      fem: block.match(/• Feminino:\s*(.+)/)?.[1]?.trim() || '',
+      essenceLine: block.match(/• Essência:\s*(.+)/)?.[1]?.trim() || '',
+    }));
+  
     async function isEnglishNameDuplicate(name: string): Promise<boolean> {
       const result = await db
         .select({ name: schema.archetypesData.name })
@@ -359,85 +353,67 @@ export class ArchetypeService {
         )
         .limit(1)
         .execute();
-
+  
       return result.length > 0;
     }
-
+  
     await Promise.all(
       englishNames.map(async (entry, i) => {
         const index = (i + 1).toString();
         const ptVariant = portugueseVariants[i];
-
+  
         if (await isEnglishNameDuplicate(entry.name)) {
-          console.warn(`Duplicate name detected: "${entry.name}" — skipping.`);
+          console.warn(`⚠️ [Single] Duplicate name skipped: ${entry.name}`);
           return;
         }
-
+  
         for (const gender of ['male', 'female']) {
           const enId = `${combination}:${gender}:${index}`;
           const ptId = `${combination}:${gender}:${index}:pt`;
           const ptName = gender === 'female' ? ptVariant.fem : ptVariant.masc;
-
-          const existingEn = await db
-            .select({ id: schema.archetypesData.id })
-            .from(schema.archetypesData)
-            .where(eq(schema.archetypesData.id, enId))
-            .execute();
-
-          if (overrideExisting || existingEn.length === 0) {
-            await db
-              .insert(schema.archetypesData)
-              .values({
-                id: enId,
-                combination,
-                gender,
-                archetypeIndex: index,
-                language: 'en-us',
-                name: entry.name,
-                essenceLine: entry.essenceLine,
-                status: 'idle',
-              })
-              .onConflictDoUpdate({
-                target: [schema.archetypesData.id],
-                set: {
-                  name: entry.name,
-                  essenceLine: entry.essenceLine,
-                  updatedAt: new Date().getTime(),
-                },
-              });
-          }
-
-          const existingPt = await db
-            .select({ id: schema.archetypesData.id })
-            .from(schema.archetypesData)
-            .where(eq(schema.archetypesData.id, ptId))
-            .execute();
-
-          if (overrideExisting || existingPt.length === 0) {
-            await db
-              .insert(schema.archetypesData)
-              .values({
-                id: ptId,
-                combination,
-                gender,
-                archetypeIndex: index,
-                language: 'pt-br',
-                name: ptName,
-                essenceLine: ptVariant.essenceLine,
-                status: 'idle',
-              })
-              .onConflictDoUpdate({
-                target: [schema.archetypesData.id],
-                set: {
-                  name: ptName,
-                  essenceLine: ptVariant.essenceLine,
-                  updatedAt: new Date().getTime(),
-                },
-              });
-          }
+  
+          await db.insert(schema.archetypesData).values({
+            id: enId,
+            combination,
+            gender,
+            archetypeIndex: index,
+            language: 'en-us',
+            name: entry.name,
+            essenceLine: entry.essenceLine,
+            status: 'idle',
+          }).onConflictDoUpdate({
+            target: [schema.archetypesData.id],
+            set: {
+              name: entry.name,
+              essenceLine: entry.essenceLine,
+              updatedAt: new Date().getTime(),
+            },
+          });
+  
+          await db.insert(schema.archetypesData).values({
+            id: ptId,
+            combination,
+            gender,
+            archetypeIndex: index,
+            language: 'pt-br',
+            name: ptName,
+            essenceLine: ptVariant.essenceLine,
+            status: 'idle',
+          }).onConflictDoUpdate({
+            target: [schema.archetypesData.id],
+            set: {
+              name: ptName,
+              essenceLine: ptVariant.essenceLine,
+              updatedAt: new Date().getTime(),
+            },
+          });
+  
+          console.log(`✅ [Single] Saved archetype ${index} (${gender}) for ${combination}`);
         }
       })
     );
+  
+    console.log(`🏁 [Single] Done generating names for ${combination}`);
   }
 
   async generateArchetypeNamesBatch(
@@ -445,25 +421,27 @@ export class ArchetypeService {
     overrideExisting: boolean = false
   ) {
     const db = this.context.drizzle();
-
+    console.log(`🚀 [Batch] Starting generation for ${entries.length} combinations | Override: ${overrideExisting}`);
+  
     const prompts = entries.map(({ combination }) => {
       const [sun, ascendant, moon] = combination.split('-') as ZodiacSignSlug[];
       return { sun, ascendant, moon };
     });
-
+  
     const prompt = generateArchetypePrompt(prompts);
     const messages: ChatMessages = [{ role: 'user', content: prompt }];
     const response = await this.context.api().callTogether.single(messages, {});
-
+  
     if (!response) {
-      throw new Error('No response when generating batch archetype names');
+      console.error(`❌ [Batch] No response from model`);
+      return;
     }
-
+  
     const blocks = response
       .split(/Composition \d+/)
       .slice(1)
       .map((b) => b.trim());
-
+  
     async function isEnglishNameDuplicate(name: string): Promise<boolean> {
       const result = await db
         .select({ name: schema.archetypesData.name })
@@ -476,21 +454,22 @@ export class ArchetypeService {
         )
         .limit(1)
         .execute();
-
+  
       return result.length > 0;
     }
-
+  
     for (let i = 0; i < entries.length; i++) {
       const { combination } = entries[i];
       const block = blocks[i];
-
+      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(`Parsing failed for composition ${combination}`, err);
+        console.error(`❌ [Batch] Parsing failed for: ${combination}`, err);
         await db.insert(schema.archetypeNameDumps).values({
           id: combination,
           combination,
@@ -500,7 +479,7 @@ export class ArchetypeService {
         });
         continue;
       }
-
+  
       const english = en
         .split(/\n\d\.\s*\n?/)
         .filter(Boolean)
@@ -508,7 +487,7 @@ export class ArchetypeService {
           name: line.match(/• Name:\s*(.+)/)?.[1]?.trim() || '',
           essenceLine: line.match(/• Essence:\s*(.+)/)?.[1]?.trim() || '',
         }));
-
+  
       const portuguese = pt
         .split(/\n\d\.\s*\n?/)
         .filter(Boolean)
@@ -517,83 +496,65 @@ export class ArchetypeService {
           fem: line.match(/• Feminino:\s*(.+)/)?.[1]?.trim() || '',
           essenceLine: line.match(/• Essência:\s*(.+)/)?.[1]?.trim() || '',
         }));
-
+  
       for (let j = 0; j < 3; j++) {
         const index = (j + 1).toString();
         const englishEntry = english[j];
         const ptEntry = portuguese[j];
-
+  
         if (await isEnglishNameDuplicate(englishEntry.name)) {
-          console.warn(
-            `Duplicate English name "${englishEntry.name}" — skipping.`
-          );
+          console.warn(`⚠️ [Batch] Duplicate name skipped: ${englishEntry.name}`);
           continue;
         }
-
+  
         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;
-
-          const existingEn = await db
-            .select({ id: schema.archetypesData.id })
-            .from(schema.archetypesData)
-            .where(eq(schema.archetypesData.id, enId))
-            .execute();
-
-          if (overrideExisting || existingEn.length === 0) {
-            await db
-              .insert(schema.archetypesData)
-              .values({
-                id: enId,
-                combination,
-                gender,
-                archetypeIndex: index,
-                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(),
-                },
-              });
-          }
-
-          const existingPt = await db
-            .select({ id: schema.archetypesData.id })
-            .from(schema.archetypesData)
-            .where(eq(schema.archetypesData.id, ptId))
-            .execute();
-
-          if (overrideExisting || existingPt.length === 0) {
-            await db
-              .insert(schema.archetypesData)
-              .values({
-                id: ptId,
-                combination,
-                gender,
-                archetypeIndex: index,
-                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.insert(schema.archetypesData).values({
+            id: enId,
+            combination,
+            gender,
+            archetypeIndex: index,
+            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 db.insert(schema.archetypesData).values({
+            id: ptId,
+            combination,
+            gender,
+            archetypeIndex: index,
+            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(),
+            },
+          });
+  
+          console.log(`✅ [Batch] Saved archetype ${index} (${gender}) for ${combination}`);
         }
       }
+  
+      console.log(`🏁 [Batch] Finished combination: ${combination}`);
     }
+  
+    console.log(`🎉 [Batch] Completed processing for all ${entries.length} combinations`);
   }
 }

package/package.json

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