@zodic/shared 0.0.299 → 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,24 +290,34 @@ export class ArchetypeService {
 
   async generateArchetypeNames(
     combination: string,
-    overrideExisting: boolean = false
+    overrideExisting: boolean = false,
+    indexesToGenerate?: number[]
   ) {
     const db = this.context.drizzle();
-    console.log(`🚀 [Single] Starting generation for combination: ${combination} | Override: ${overrideExisting}`);
-  
+    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 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) {
       console.error(`❌ [Single] No response for: ${combination}`);
       return;
     }
-  
+
     let blocks: string[] = [];
     let ptBlocks: string[] = [];
-  
+
     try {
       blocks = response
         .split('-EN')[1]
@@ -312,7 +325,7 @@ export class ArchetypeService {
         .trim()
         .split(/\n\d\.\s*\n?/)
         .filter(Boolean);
-  
+
       ptBlocks = response
         .split('-PT')[1]
         .trim()
@@ -329,18 +342,18 @@ export class ArchetypeService {
       });
       return;
     }
-  
+
     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 })
@@ -353,66 +366,74 @@ 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(`⚠️ [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;
-  
-          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: {
+
+          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(),
-            },
-          });
-  
-          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: {
+              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,
-              updatedAt: new Date().getTime(),
-            },
-          });
-  
-          console.log(`✅ [Single] Saved archetype ${index} (${gender}) for ${combination}`);
+              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}`);
   }
 
@@ -421,27 +442,29 @@ export class ArchetypeService {
     overrideExisting: boolean = false
   ) {
     const db = this.context.drizzle();
-    console.log(`🚀 [Batch] Starting generation for ${entries.length} combinations | Override: ${overrideExisting}`);
-  
+    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) {
       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 })
@@ -454,15 +477,15 @@ 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 {
@@ -479,7 +502,7 @@ export class ArchetypeService {
         });
         continue;
       }
-  
+
       const english = en
         .split(/\n\d\.\s*\n?/)
         .filter(Boolean)
@@ -487,7 +510,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)
@@ -496,65 +519,281 @@ 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}`);
+          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;
-  
-          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: {
+
+          await db
+            .insert(schema.archetypesData)
+            .values({
+              id: enId,
+              combination,
+              gender,
+              archetypeIndex: index,
+              language: 'en-us',
               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: {
+              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,
-              updatedAt: new Date().getTime(),
-            },
+              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;
+    }
+
+    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(),
           });
-  
-          console.log(`✅ [Batch] Saved archetype ${index} (${gender}) for ${combination}`);
+        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,
+                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`);
+
+    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.299",
+  "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')}`;
 }