@zodic/shared 0.0.313 → 0.0.314

package/app/services/ArchetypeService.ts

@@ -3,6 +3,7 @@ import { inject, injectable } from 'inversify';
 import { ChatMessages, Composition, schema } from '../..';
 import { KVArchetype, ZodiacSignSlug } from '../../types/scopes/legacy';
 import { generateArchetypePrompt } from '../../utils/archetypeNamesMessages';
+import { duplicatedArchetypeNamePrompt } from '../../utils/duplicatedArchetypeNamePrompt';
 import { buildCosmicMirrorArchetypeKVKey } from '../../utils/KVKeysBuilders';
 import { AppContext } from '../base';
 
@@ -751,6 +752,195 @@ export class ArchetypeService {
     );
   }
 
+  async regenerateDuplicateArchetypeNamesBatch(
+    entriesByCombination: Record<string, any[]>
+  ) {
+    const db = this.context.drizzle();
+    console.log(
+      `[RegenerateDuplicatesBatch] Processing batch with ${
+        Object.keys(entriesByCombination).length
+      } combinations`
+    );
+
+    // Process each combination in the batch
+    for (const [combination, entries] of Object.entries(entriesByCombination)) {
+      console.log(
+        `[RegenerateDuplicatesBatch] Processing combination: ${combination}`
+      );
+
+      // Fetch all existing English names for this combination (across all archetypeIndex, gender, language)
+      const existingNamesResult = await db
+        .selectDistinct({ name: schema.archetypesData.name })
+        .from(schema.archetypesData)
+        .where(
+          and(
+            eq(schema.archetypesData.combination, combination),
+            eq(schema.archetypesData.language, 'en-us')
+          )
+        )
+        .execute();
+
+      let existingNames = existingNamesResult.map((r) => r.name);
+      console.log(
+        `[RegenerateDuplicatesBatch] Existing names for ${combination}: ${existingNames.join(
+          ', '
+        )}`
+      );
+
+      // Process each entry with the duplicate name in this combination
+      for (const entry of entries) {
+        const { archetypeIndex, essenceLine } = entry;
+        console.log(
+          `[RegenerateDuplicatesBatch] Regenerating name for ${combination} (archetypeIndex: ${archetypeIndex})`
+        );
+
+        let newName: {
+          name_en: string;
+          name_pt_male: string;
+          name_pt_female: string;
+        } | null = null;
+        let attempts = 0;
+        const maxAttempts = 5;
+
+        // Generate a new name until a unique one is found
+        while (attempts < maxAttempts) {
+          attempts++;
+          console.log(
+            `[RegenerateDuplicatesBatch] Attempt ${attempts} to generate a new name for ${combination} (archetypeIndex: ${archetypeIndex})`
+          );
+
+          // Build the prompt
+          const prompt = duplicatedArchetypeNamePrompt({
+            combination,
+            essenceLine: essenceLine || 'A unique and meaningful archetype', // Fallback for null essenceLine
+            existingNames,
+          });
+
+          // Send the request to the AI
+          const messages: ChatMessages = [{ role: 'user', content: prompt }];
+          const response = await this.context
+            .api()
+            .callTogether.single(messages, {});
+
+          if (!response) {
+            console.error(
+              `[RegenerateDuplicatesBatch] No response from model for ${combination} (archetypeIndex: ${archetypeIndex})`
+            );
+            continue;
+          }
+
+          // Parse the response
+          try {
+            newName = JSON.parse(response);
+            console.log(
+              `[RegenerateDuplicatesBatch] Generated new name: ${JSON.stringify(
+                newName,
+                null,
+                2
+              )}`
+            );
+
+            // Validate the response format
+            if (
+              !newName ||
+              !newName.name_en ||
+              !newName.name_pt_male ||
+              !newName.name_pt_female
+            ) {
+              console.error(
+                `[RegenerateDuplicatesBatch] Invalid response format for ${combination} (archetypeIndex: ${archetypeIndex}): ${response}`
+              );
+              newName = null;
+              continue;
+            }
+          } catch (error) {
+            console.error(
+              `[RegenerateDuplicatesBatch] Failed to parse AI response for ${combination} (archetypeIndex: ${archetypeIndex}): ${response}`,
+              error
+            );
+            continue;
+          }
+
+          // Check if the new name is unique (globally across all combinations)
+          const isDuplicate = await db
+            .select({ name: schema.archetypesData.name })
+            .from(schema.archetypesData)
+            .where(
+              and(
+                eq(schema.archetypesData.language, 'en-us'),
+                eq(schema.archetypesData.name, newName.name_en)
+              )
+            )
+            .limit(1)
+            .execute();
+
+          if (isDuplicate.length > 0) {
+            console.warn(
+              `[RegenerateDuplicatesBatch] Generated name "${newName.name_en}" is already used. Adding to existing names and retrying.`
+            );
+            existingNames.push(newName.name_en);
+            newName = null;
+            continue;
+          }
+
+          // If we reach here, the name is unique
+          break;
+        }
+
+        if (!newName) {
+          console.error(
+            `[RegenerateDuplicatesBatch] Failed to generate a unique name for ${combination} (archetypeIndex: ${archetypeIndex}) after ${maxAttempts} attempts`
+          );
+          continue;
+        }
+
+        // Update the database with the new names
+        for (const gender of ['male', 'female']) {
+          const enId = `${combination}:${gender}:${archetypeIndex}`;
+          const ptId = `${combination}:${gender}:${archetypeIndex}:pt`;
+
+          // Update English entry
+          await db
+            .update(schema.archetypesData)
+            .set({
+              name: newName.name_en,
+              updatedAt: new Date().getTime(),
+            })
+            .where(
+              and(
+                eq(schema.archetypesData.id, enId),
+                eq(schema.archetypesData.language, 'en-us')
+              )
+            )
+            .execute();
+
+          // Update Portuguese entry
+          const ptName =
+            gender === 'female' ? newName.name_pt_female : newName.name_pt_male;
+          await db
+            .update(schema.archetypesData)
+            .set({
+              name: ptName,
+              updatedAt: new Date().getTime(),
+            })
+            .where(
+              and(
+                eq(schema.archetypesData.id, ptId),
+                eq(schema.archetypesData.language, 'pt-br')
+              )
+            )
+            .execute();
+
+          console.log(
+            `[RegenerateDuplicatesBatch] Updated ${combination} (archetypeIndex: ${archetypeIndex}, gender: ${gender}) with new name - English: ${newName.name_en}, Portuguese: ${ptName}`
+          );
+        }
+      }
+    }
+
+    console.log(`✅ [RegenerateDuplicatesBatch] Finished processing batch`);
+  }
+
   async recycleArchetypeNameDumpsBatch(
     compositions: Composition[]
   ): Promise<void> {

package/package.json

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

package/utils/duplicatedArchetypeNamePrompt.ts

@@ -0,0 +1,47 @@
+type ArchetypePromptInputs = {
+  combination: string;
+  essenceLine: string;
+  existingNames: string[];
+};
+
+export function duplicatedArchetypeNamePrompt({
+  combination,
+  essenceLine,
+  existingNames,
+}: ArchetypePromptInputs): string {
+  return `
+You are a creative naming assistant for a symbolic astrology project. Each archetype is defined by a unique combination of three zodiac signs (Sun, Moon, Ascendant), and has an associated *essence line* that captures its spiritual and psychological meaning. Your task is to generate a new, poetic and meaningful name for the archetype, ensuring it is unique among previously used names.
+
+---
+
+Input:
+
+- Combination: \`${combination}\`
+- Essence Line: \`${essenceLine}\`
+- Existing Names: \`${JSON.stringify(existingNames)}\`
+
+---
+
+Important Instructions:
+
+1. Create a new archetype name that poetically reflects the given essence line.
+2. The name should follow the same style as existing archetypes (e.g., \`The Wandering Alchemist\`, \`The Radiant Mask\`, \`The Harmonious Builder\`).
+3. The name must not appear in the list of existing names.
+4. Also generate Portuguese translations of the name:
+   - One in masculine form.
+   - One in feminine form.
+5. Ensure all outputs are semantically coherent and well-written.
+6. Use the following output format precisely.
+
+---
+
+Output Format (exactly like this, do not change it):
+
+{
+  "name_en": <Name in English>,
+  "name_pt_male": <Name in Portuguese Male>,
+  "name_pt_female": <Name in Portuguese Female>,
+}
+
+`;
+}