@zodic/shared 0.0.313 → 0.0.315

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> {