@zodic/shared 0.0.298 → 0.0.300

package/app/services/ArchetypeService.ts

@@ -1,8 +1,11 @@
-import { and, eq } from 'drizzle-orm';
+import { and, eq, sql } from 'drizzle-orm';
 import { inject, injectable } from 'inversify';
 import { ChatMessages, schema } from '../..';
 import { KVArchetype, ZodiacSignSlug } from '../../types/scopes/legacy';
-import { generateArchetypePrompt } from '../../utils/archetypeNamesMessages';
+import {
+  Composition,
+  generateArchetypePrompt,
+} from '../../utils/archetypeNamesMessages';
 import { buildCosmicMirrorArchetypeKVKey } from '../../utils/KVKeysBuilders';
 import { AppContext } from '../base';
 
@@ -287,19 +290,29 @@ export class ArchetypeService {
 
   async generateArchetypeNames(
     combination: string,
-    overrideExisting: boolean = false
+    overrideExisting: boolean = false,
+    indexesToGenerate?: number[]
   ) {
     const db = this.context.drizzle();
-    const [sun, ascendant, moon] = combination.split('-') as ZodiacSignSlug[];
+    console.log(
+      `🚀 [Single] Starting generation for combination: ${combination} | Override: ${overrideExisting}`
+    );
 
-    const prompt = generateArchetypePrompt([{ sun, ascendant, moon }]);
+    const [sun, ascendant, moon] = combination.split('-') as ZodiacSignSlug[];
+    const prompt = generateArchetypePrompt([
+      {
+        sun,
+        ascendant,
+        moon,
+        indexesToGenerate: indexesToGenerate ?? [1, 2, 3],
+      },
+    ]);
     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[] = [];
@@ -319,7 +332,7 @@ export class ArchetypeService {
         .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,
@@ -330,23 +343,17 @@ 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 englishNames = blocks.map((block) => ({
+      name: block.match(/• Name:\s*(.+)/)?.[1]?.trim() || '',
+      essenceLine: block.match(/• Essence:\s*(.+)/)?.[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 };
-    });
+    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() || '',
+    }));
 
-    // Duplicate helper
     async function isEnglishNameDuplicate(name: string): Promise<boolean> {
       const result = await db
         .select({ name: schema.archetypesData.name })
@@ -369,7 +376,7 @@ export class ArchetypeService {
         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;
         }
 
@@ -378,66 +385,56 @@ export class ArchetypeService {
           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',
+          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,
-                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',
+                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,
-                status: 'idle',
-              })
-              .onConflictDoUpdate({
-                target: [schema.archetypesData.id],
-                set: {
-                  name: ptName,
-                  essenceLine: ptVariant.essenceLine,
-                  updatedAt: new Date().getTime(),
-                },
-              });
-          }
+                updatedAt: new Date().getTime(),
+              },
+            });
+
+          console.log(
+            `✅ [Single] Saved archetype ${index} (${gender}) for ${combination}`
+          );
         }
       })
     );
+
+    console.log(`🏁 [Single] Done generating names for ${combination}`);
   }
 
   async generateArchetypeNamesBatch(
@@ -445,6 +442,9 @@ 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[];
@@ -456,7 +456,8 @@ export class ArchetypeService {
     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
@@ -483,6 +484,7 @@ export class ArchetypeService {
     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 = '';
@@ -490,7 +492,7 @@ export class ArchetypeService {
         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,
@@ -525,7 +527,7 @@ export class ArchetypeService {
 
         if (await isEnglishNameDuplicate(englishEntry.name)) {
           console.warn(
-            `Duplicate English name "${englishEntry.name}" — skipping.`
+            `⚠️ [Batch] Duplicate name skipped: ${englishEntry.name}`
           );
           continue;
         }
@@ -535,65 +537,263 @@ export class ArchetypeService {
           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',
+          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,
-                status: 'idle',
-              })
-              .onConflictDoUpdate({
-                target: [schema.archetypesData.id],
-                set: {
-                  name: englishEntry.name,
-                  essenceLine: englishEntry.essenceLine,
-                  updatedAt: new Date().getTime(),
-                },
-              });
-          }
+                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`
+    );
+  }
+
+  async findIncompleteCombinations(): Promise<
+    Array<{ combination: string; count: number }>
+  > {
+    const db = this.context.drizzle();
+
+    const result = await db
+      .select({
+        combination: schema.archetypesData.combination,
+        count: sql<number>`count(*)`.as('count'),
+      })
+      .from(schema.archetypesData)
+      .groupBy(schema.archetypesData.combination)
+      .having(sql`count(*) < 12`)
+      .execute();
+
+    const typedResult = result.map((row) => ({
+      combination: row.combination,
+      count: Number(row.count),
+    }));
+
+    console.log(`🔍 Found ${typedResult.length} incomplete combinations`);
+    return typedResult;
+  }
+
+  async regenerateMissingArchetypeNames(overrideExisting: boolean = false) {
+    const incomplete = await this.findIncompleteCombinations();
+    console.log(
+      `🔁 Starting regeneration for ${incomplete.length} combinations`
+    );
+
+    for (const { combination, count } of incomplete) {
+      const indexesToGenerate: number[] = [];
+
+      const db = this.context.drizzle();
+      const existing = await db
+        .select({
+          archetypeIndex: schema.archetypesData.archetypeIndex,
+          language: schema.archetypesData.language,
+          gender: schema.archetypesData.gender,
+        })
+        .from(schema.archetypesData)
+        .where(eq(schema.archetypesData.combination, combination))
+        .execute();
+
+      for (let i = 1; i <= 3; i++) {
+        const hasAll =
+          existing.filter((e) => e.archetypeIndex === i.toString()).length ===
+          4;
+        if (!hasAll) indexesToGenerate.push(i);
+      }
+
+      if (indexesToGenerate.length > 0) {
+        console.log(
+          `🧩 Regenerating indexes ${indexesToGenerate.join(
+            ','
+          )} for ${combination}`
+        );
+        await this.generateArchetypeNames(
+          combination,
+          overrideExisting,
+          indexesToGenerate
+        );
+      }
+    }
+
+    console.log(`✅ Done regenerating missing archetype names`);
+  }
+
+  async regenerateMissingArchetypeNamesBatch(compositions: Composition[]) {
+    if (compositions.length === 0) {
+      console.log('✅ [Batch] No combinations provided for regeneration');
+      return;
+    }
 
-          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',
+    console.log(
+      `🔁 [Batch] Starting regeneration for ${compositions.length} combinations`
+    );
+
+    const prompt = generateArchetypePrompt(compositions);
+    const messages: ChatMessages = [{ role: 'user', content: prompt }];
+    const response = await this.context.api().callTogether.single(messages, {});
+
+    if (!response) {
+      console.error(`❌ [Batch] No response from model during regeneration`);
+      return;
+    }
+
+    const blocks = response
+      .split(/Composition \d+/)
+      .slice(1)
+      .map((b) => b.trim());
+
+    for (let i = 0; i < compositions.length; i++) {
+      const comp = compositions[i];
+      const combination = [comp.sun, comp.ascendant, comp.moon].join('-');
+      const block = blocks[i];
+      const indexes = comp.indexesToGenerate ?? [1, 2, 3];
+
+      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 this.context
+          .drizzle()
+          .insert(schema.archetypeNameDumps)
+          .values({
+            id: `${combination}:${Date.now()}`,
+            combination,
+            rawText: block,
+            parsedSuccessfully: 0,
+            createdAt: Date.now(),
+          });
+        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) {
+        const englishEntry = english[index - 1];
+        const ptEntry = portuguese[index - 1];
+
+        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,
-                status: 'idle',
-              })
-              .onConflictDoUpdate({
-                target: [schema.archetypesData.id],
-                set: {
-                  name: ptName,
-                  essenceLine: ptEntry.essenceLine,
-                  updatedAt: new Date().getTime(),
-                },
-              });
-          }
+                updatedAt: new Date().getTime(),
+              },
+            });
+
+          console.log(
+            `✅ [Batch] Saved archetype ${index} (${gender}) for ${combination}`
+          );
         }
       }
+
+      console.log(`🏁 [Batch] Finished combination: ${combination}`);
     }
+
+    console.log(
+      `🎉 [Batch] Completed regenerating ${compositions.length} combinations`
+    );
   }
 }

package/db/schema.ts

@@ -425,7 +425,7 @@ export const archetypesData = sqliteTable(
     content: text('content').default('[]').notNull(), // JSON stringified structured content
     virtues: text('virtues').default('[]').notNull(), // JSON stringified array
     leonardoPrompt: text('leonardo_prompt'), // Leonardo prompt
-    status: text('status').default('idle'), // Generation status
+    status: text('status').default('idle'), // Status: 'idle', 'generated', 'duplicate', 'error'
     createdAt: integer('created_at').default(sql`CURRENT_TIMESTAMP`),
     // JSON array of objects: { leonardoId: string; url: string; height: number; width: number; }
     images: text('images').default('[]').notNull(),

package/package.json

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

package/utils/archetypeNamesMessages.ts

@@ -1,5 +1,3 @@
-// --- 1. Influence Table ---
-
 import { ZodiacSignSlug } from '../types/scopes/legacy';
 
 export type Planet = 'sun' | 'ascendant' | 'moon';
@@ -198,12 +196,11 @@ export const influenceMap: Record<Planet, Record<ZodiacSignSlug, Trait>> = {
   },
 };
 
-// --- 2. Prompt Generator ---
-
 export interface Composition {
   sun: ZodiacSignSlug;
   ascendant: ZodiacSignSlug;
   moon: ZodiacSignSlug;
+  indexesToGenerate?: number[];
 }
 
 export function generateArchetypePrompt(compositions: Composition[]): string {
@@ -226,40 +223,42 @@ Do not include any commentary or explanations outside the defined output structu
     const sun = influenceMap.sun[comp.sun];
     const asc = influenceMap.ascendant[comp.ascendant];
     const moon = influenceMap.moon[comp.moon];
+    const indexes = comp.indexesToGenerate ?? [1, 2, 3];
 
-    return `\n\n### Composition ${i + 1}
+    const influences = `\n\n### Composition ${i + 1}
 
 • First Influence – ${sun.label}: ${sun.description}  
 • Second Influence – ${asc.label}: ${asc.description}  
 • Third Influence – ${moon.label}: ${moon.description}`;
-  });
 
-  const outputFormat = `\n\n### Output Format for Each Composition:
-\n\n\`\n-EN  
-1.  
-  • Name: [Name that emphasizes the first influence, while blending the second and third]  
-  • Essence: [Short poetic description line in English]  
-2.  
-  • Name: [Name that emphasizes the second influence, while blending the first and third]  
-  • Essence: [Short poetic description line in English]  
-3.  
-  • Name: [Name that emphasizes the third influence, while blending the first and second]  
-  • Essence: [Short poetic description line in English]
+    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]`
+      )
+      .join('\n');
 
--PT  
-1.  
+    const ptLines = indexes
+      .map(
+        (idx) => `${idx}.  
   • Masculino: [Portuguese name (masc)]  
   • Feminino: [Portuguese name (fem)]  
-  • Essência: [Short poetic description line in Portuguese]  
-2.  
-  • Masculino: [Portuguese name (masc)]  
-  • Feminino: [Portuguese name (fem)]  
-  • Essência: [Short poetic description line in Portuguese]  
-3.  
-  • Masculino: [Portuguese name (masc)]  
-  • Feminino: [Portuguese name (fem)]  
-  • Essência: [Short poetic description line in Portuguese]
+  • Essência: [Short poetic description line in Portuguese]`
+      )
+      .join('\n');
+
+    return `${influences}
+
+\`\n-EN  
+${enLines}
+
+-PT  
+${ptLines}
 \``;
+  });
 
-  return `${promptHeader}\n${compositionBlocks.join('\n')}\n${outputFormat}`;
+  return `${promptHeader}\n${compositionBlocks.join('\n')}`;
 }