@zodic/shared 0.0.297 → 0.0.299

package/app/services/ArchetypeService.ts

@@ -1,4 +1,4 @@
-import { eq } from 'drizzle-orm';
+import { and, eq } from 'drizzle-orm';
 import { inject, injectable } from 'inversify';
 import { ChatMessages, schema } from '../..';
 import { KVArchetype, ZodiacSignSlug } from '../../types/scopes/legacy';
@@ -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,117 +353,133 @@ 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(
     entries: Array<{ combination: string }>,
     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 db = this.context.drizzle();
-
+  
     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 })
+        .from(schema.archetypesData)
+        .where(
+          and(
+            eq(schema.archetypesData.language, 'en-us'),
+            eq(schema.archetypesData.name, name)
+          )
+        )
+        .limit(1)
+        .execute();
+  
+      return result.length > 0;
+    }
+  
     for (let i = 0; i < entries.length; 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();
-
+      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);
+        await db.insert(schema.archetypeNameDumps).values({
+          id: combination,
+          combination,
+          rawText: block,
+          parsedSuccessfully: 0,
+          createdAt: Date.now(),
+        });
+        continue;
+      }
+  
       const english = en
         .split(/\n\d\.\s*\n?/)
         .filter(Boolean)
@@ -477,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)
@@ -486,76 +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(`⚠️ [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.297",
+  "version": "0.0.299",
   "module": "index.ts",
   "type": "module",
   "publishConfig": {

package/types/scopes/cloudflare.ts

@@ -38,6 +38,7 @@ export type CentralBindings = {
   AMULET_QUEUE: Queue;
   LANTERN_QUEUE: Queue;
   ORB_QUEUE: Queue;
+  ARCHETYPE_POPULATION_QUEUE: Queue;
 
   PROMPT_IMAGE_DESCRIBER: string;
   PROMPT_GENERATE_ARCHETYPE_BASIC_INFO: string;
@@ -136,6 +137,7 @@ export type BackendBindings = Env &
     | 'RING_QUEUE'
     | 'LANTERN_QUEUE'
     | 'ORB_QUEUE'
+    | 'ARCHETYPE_POPULATION_QUEUE'
     | 'KV_API_USAGE'
     | 'KV_CONCEPT_CACHE'
     | 'ENV'