@zodic/shared 0.0.295 → 0.0.297

package/app/services/ArchetypeService.ts

@@ -287,18 +287,13 @@ export class ArchetypeService {
 
   async generateArchetypeNames(
     combination: string,
-    gender: 'male' | 'female' | 'non-binary',
     overrideExisting: boolean = false
   ) {
+    const db = this.context.drizzle();
     const [sun, ascendant, moon] = combination.split('-') as ZodiacSignSlug[];
 
     const prompt = generateArchetypePrompt([{ sun, ascendant, moon }]);
-    const messages: ChatMessages = [
-      {
-        role: 'user',
-        content: prompt,
-      },
-    ];
+    const messages: ChatMessages = [{ role: 'user', content: prompt }];
     const response = await this.context.api().callTogether.single(messages, {});
 
     if (!response) {
@@ -307,17 +302,33 @@ export class ArchetypeService {
       );
     }
 
-    const blocks = response
-      .split('-EN')[1]
-      .split('-PT')[0]
-      .trim()
-      .split(/\n\d\.\s*\n?/)
-      .filter(Boolean);
-    const ptBlocks = response
-      .split('-PT')[1]
-      .trim()
-      .split(/\n\d\.\s*\n?/)
-      .filter(Boolean);
+    let blocks: string[] = [];
+    let ptBlocks: string[] = [];
+
+    try {
+      blocks = response
+        .split('-EN')[1]
+        .split('-PT')[0]
+        .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);
+      await db.insert(schema.archetypeNameDumps).values({
+        id: combination,
+        combination,
+        rawText: response,
+        parsedSuccessfully: 0,
+        createdAt: Date.now(),
+      });
+      return;
+    }
 
     const englishNames = blocks.map((block) => {
       const nameMatch = block.match(/• Name:\s*(.+)/);
@@ -335,81 +346,102 @@ export class ArchetypeService {
       return { masc, fem, essenceLine: essence };
     });
 
-    const db = this.context.drizzle();
+    // Duplicate helper
+    async function isEnglishNameDuplicate(name: string): Promise<boolean> {
+      const result = await db
+        .select({ name: schema.archetypesData.name })
+        .from(schema.archetypesData)
+        .where(
+          and(
+            eq(schema.archetypesData.language, 'en-us'),
+            eq(schema.archetypesData.name, name)
+          )
+        )
+        .limit(1)
+        .execute();
+
+      return result.length > 0;
+    }
 
     await Promise.all(
       englishNames.map(async (entry, i) => {
         const index = (i + 1).toString();
-        const existingEntry = await db
-          .select({ id: schema.archetypesData.id })
-          .from(schema.archetypesData)
-          .where(
-            eq(schema.archetypesData.id, `${combination}:${gender}:${index}`)
-          )
-          .execute();
-
-        if (overrideExisting || existingEntry.length === 0) {
-          await db
-            .insert(schema.archetypesData)
-            .values({
-              id: `${combination}:${gender}:${index}`,
-              combination,
-              gender,
-              archetypeIndex: index,
-              language: 'en-us',
-              name: entry.name,
-              essenceLine: entry.essenceLine,
-              status: 'idle',
-            })
-            .onConflictDoUpdate({
-              target: [schema.archetypesData.id],
-              set: {
+        const ptVariant = portugueseVariants[i];
+
+        if (await isEnglishNameDuplicate(entry.name)) {
+          console.warn(`Duplicate name detected: "${entry.name}" — skipping.`);
+          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,
-                updatedAt: new Date().getTime(),
-              },
-            });
-        }
+                status: 'idle',
+              })
+              .onConflictDoUpdate({
+                target: [schema.archetypesData.id],
+                set: {
+                  name: entry.name,
+                  essenceLine: entry.essenceLine,
+                  updatedAt: new Date().getTime(),
+                },
+              });
+          }
 
-        const existingEntryPt = await db
-          .select({ id: schema.archetypesData.id })
-          .from(schema.archetypesData)
-          .where(
-            eq(schema.archetypesData.id, `${combination}:${gender}:${index}:pt`)
-          )
-          .execute();
-
-        if (overrideExisting || existingEntryPt.length === 0) {
-          await db
-            .insert(schema.archetypesData)
-            .values({
-              id: `${combination}:${gender}:${index}:pt`,
-              combination,
-              gender,
-              archetypeIndex: index,
-              language: 'pt-br',
-              name: portugueseVariants[i].masc,
-              essenceLine: portugueseVariants[i].essenceLine,
-              status: 'idle',
-            })
-            .onConflictDoUpdate({
-              target: [schema.archetypesData.id],
-              set: {
-                name: portugueseVariants[i].masc,
-                essenceLine: portugueseVariants[i].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(),
+                },
+              });
+          }
         }
       })
     );
   }
 
   async generateArchetypeNamesBatch(
-    entries: Array<{
-      combination: string;
-      gender: 'male' | 'female' | 'non-binary';
-    }>,
+    entries: Array<{ combination: string }>,
     overrideExisting: boolean = false
   ) {
     const prompts = entries.map(({ combination }) => {
@@ -421,8 +453,9 @@ export class ArchetypeService {
     const messages: ChatMessages = [{ role: 'user', content: prompt }];
     const response = await this.context.api().callTogether.single(messages, {});
 
-    if (!response)
+    if (!response) {
       throw new Error('No response when generating batch archetype names');
+    }
 
     const db = this.context.drizzle();
 
@@ -432,7 +465,7 @@ export class ArchetypeService {
       .map((b) => b.trim());
 
     for (let i = 0; i < entries.length; i++) {
-      const { combination, gender } = entries[i];
+      const { combination } = entries[i];
       const block = blocks[i];
       const en = block.split('-EN')[1].split('-PT')[0].trim();
       const pt = block.split('-PT')[1].trim();
@@ -450,72 +483,77 @@ export class ArchetypeService {
         .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 (let j = 0; j < 3; j++) {
         const index = (j + 1).toString();
+        const englishEntry = english[j];
+        const ptEntry = portuguese[j];
+
+        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 existingEntry = await db
-          .select({ id: schema.archetypesData.id })
-          .from(schema.archetypesData)
-          .where(
-            eq(schema.archetypesData.id, `${combination}:${gender}:${index}`)
-          )
-          .execute();
-
-        if (overrideExisting || existingEntry.length === 0) {
-          await db
-            .insert(schema.archetypesData)
-            .values({
-              id: `${combination}:${gender}:${index}`,
-              combination,
-              gender,
-              archetypeIndex: index,
-              language: 'en-us',
-              name: english[j].name,
-              essenceLine: english[j].essenceLine,
-              status: 'idle',
-            })
-            .onConflictDoUpdate({
-              target: [schema.archetypesData.id],
-              set: {
-                name: english[j].name,
-                essenceLine: english[j].essenceLine,
-                updatedAt: new Date().getTime(),
-              },
-            });
-        }
-
-        const existingEntryPt = await db
-          .select({ id: schema.archetypesData.id })
-          .from(schema.archetypesData)
-          .where(
-            eq(schema.archetypesData.id, `${combination}:${gender}:${index}:pt`)
-          )
-          .execute();
-
-        if (overrideExisting || existingEntryPt.length === 0) {
-          await db
-            .insert(schema.archetypesData)
-            .values({
-              id: `${combination}:${gender}:${index}:pt`,
-              combination,
-              gender,
-              archetypeIndex: index,
-              language: 'pt-br',
-              name: portuguese[j].masc,
-              essenceLine: portuguese[j].essenceLine,
-              status: 'idle',
-            })
-            .onConflictDoUpdate({
-              target: [schema.archetypesData.id],
-              set: {
-                name: portuguese[j].masc,
-                essenceLine: portuguese[j].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(),
+                },
+              });
+          }
         }
       }
     }

package/app/workflow/ArchetypeWorkflow.ts

@@ -89,11 +89,9 @@ export class ArchetypeWorkflow {
 
   async generateNames({
     combinations,
-    gender,
     overrideExisting,
   }: {
     combinations: string[];
-    gender: Gender;
     overrideExisting?: boolean;
   }): Promise<void> {
     if (combinations.length === 0) return;
@@ -101,16 +99,17 @@ export class ArchetypeWorkflow {
     if (combinations.length === 1) {
       await this.archetypeService.generateArchetypeNames(
         combinations[0],
-        gender,
         overrideExisting
       );
     } else {
       const entries = combinations.map((combination) => ({
         combination,
-        gender,
       }));
 
-      await this.archetypeService.generateArchetypeNamesBatch(entries, overrideExisting);
+      await this.archetypeService.generateArchetypeNamesBatch(
+        entries,
+        overrideExisting
+      );
     }
   }
 

package/db/migrations/0013_lean_frightful_four.sql

@@ -0,0 +1,7 @@
+CREATE TABLE `archetype_name_dumps` (
+	`id` text PRIMARY KEY NOT NULL,
+	`combination` text NOT NULL,
+	`raw_text` text NOT NULL,
+	`parsed_successfully` integer DEFAULT 0,
+	`created_at` integer DEFAULT CURRENT_TIMESTAMP
+);