@zodic/shared 0.0.294 → 0.0.295

package/app/services/ArchetypeService.ts

@@ -1,3 +1,4 @@
+import { eq } from 'drizzle-orm';
 import { inject, injectable } from 'inversify';
 import { ChatMessages, schema } from '../..';
 import { KVArchetype, ZodiacSignSlug } from '../../types/scopes/legacy';
@@ -286,7 +287,8 @@ export class ArchetypeService {
 
   async generateArchetypeNames(
     combination: string,
-    gender: 'male' | 'female' | 'non-binary'
+    gender: 'male' | 'female' | 'non-binary',
+    overrideExisting: boolean = false
   ) {
     const [sun, ascendant, moon] = combination.split('-') as ZodiacSignSlug[];
 
@@ -338,49 +340,184 @@ export class ArchetypeService {
     await Promise.all(
       englishNames.map(async (entry, i) => {
         const index = (i + 1).toString();
-        await db
-          .insert(schema.archetypesData)
-          .values({
-            id: `${combination}:${gender}:${index}`,
-            combination,
-            gender,
-            archetypeIndex: index,
-            language: 'en-us',
-            name: entry.name,
-            essenceLine: entry.essenceLine,
-            status: 'idle',
-            
-          })
-          .onConflictDoUpdate({
-            target: [schema.archetypesData.id],
-            set: {
+        const existingEntry = await db
+          .select({ id: schema.archetypesData.id })
+          .from(schema.archetypesData)
+          .where(
+            eq(schema.archetypesData.id, `${combination}:${gender}:${index}`)
+          )
+          .execute();
+
+        if (overrideExisting || existingEntry.length === 0) {
+          await db
+            .insert(schema.archetypesData)
+            .values({
+              id: `${combination}:${gender}:${index}`,
+              combination,
+              gender,
+              archetypeIndex: index,
+              language: 'en-us',
               name: entry.name,
               essenceLine: entry.essenceLine,
-              updatedAt: new Date(),
-            },
-          });
-
-        await db
-          .insert(schema.archetypesData)
-          .values({
-            id: `${combination}:${gender}:${index}:pt`,
-            combination,
-            gender,
-            archetypeIndex: index,
-            language: 'pt-br',
-            name: portugueseVariants[i].masc,
-            essenceLine: portugueseVariants[i].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(),
+              },
+            });
+        }
+
+        const existingEntryPt = await db
+          .select({ id: schema.archetypesData.id })
+          .from(schema.archetypesData)
+          .where(
+            eq(schema.archetypesData.id, `${combination}:${gender}:${index}:pt`)
+          )
+          .execute();
+
+        if (overrideExisting || existingEntryPt.length === 0) {
+          await db
+            .insert(schema.archetypesData)
+            .values({
+              id: `${combination}:${gender}:${index}:pt`,
+              combination,
+              gender,
+              archetypeIndex: index,
+              language: 'pt-br',
               name: portugueseVariants[i].masc,
               essenceLine: portugueseVariants[i].essenceLine,
-              updatedAt: new Date(),
-            },
-          });
+              status: 'idle',
+            })
+            .onConflictDoUpdate({
+              target: [schema.archetypesData.id],
+              set: {
+                name: portugueseVariants[i].masc,
+                essenceLine: portugueseVariants[i].essenceLine,
+                updatedAt: new Date().getTime(),
+              },
+            });
+        }
       })
     );
   }
+
+  async generateArchetypeNamesBatch(
+    entries: Array<{
+      combination: string;
+      gender: 'male' | 'female' | 'non-binary';
+    }>,
+    overrideExisting: boolean = false
+  ) {
+    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');
+
+    const db = this.context.drizzle();
+
+    const blocks = response
+      .split(/Composition \d+/)
+      .slice(1)
+      .map((b) => b.trim());
+
+    for (let i = 0; i < entries.length; i++) {
+      const { combination, gender } = entries[i];
+      const block = blocks[i];
+      const en = block.split('-EN')[1].split('-PT')[0].trim();
+      const pt = block.split('-PT')[1].trim();
+
+      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() || '',
+          essenceLine: line.match(/• Essência:\s*(.+)/)?.[1]?.trim() || '',
+        }));
+
+      for (let j = 0; j < 3; j++) {
+        const index = (j + 1).toString();
+
+        const existingEntry = await db
+          .select({ id: schema.archetypesData.id })
+          .from(schema.archetypesData)
+          .where(
+            eq(schema.archetypesData.id, `${combination}:${gender}:${index}`)
+          )
+          .execute();
+
+        if (overrideExisting || existingEntry.length === 0) {
+          await db
+            .insert(schema.archetypesData)
+            .values({
+              id: `${combination}:${gender}:${index}`,
+              combination,
+              gender,
+              archetypeIndex: index,
+              language: 'en-us',
+              name: english[j].name,
+              essenceLine: english[j].essenceLine,
+              status: 'idle',
+            })
+            .onConflictDoUpdate({
+              target: [schema.archetypesData.id],
+              set: {
+                name: english[j].name,
+                essenceLine: english[j].essenceLine,
+                updatedAt: new Date().getTime(),
+              },
+            });
+        }
+
+        const existingEntryPt = await db
+          .select({ id: schema.archetypesData.id })
+          .from(schema.archetypesData)
+          .where(
+            eq(schema.archetypesData.id, `${combination}:${gender}:${index}:pt`)
+          )
+          .execute();
+
+        if (overrideExisting || existingEntryPt.length === 0) {
+          await db
+            .insert(schema.archetypesData)
+            .values({
+              id: `${combination}:${gender}:${index}:pt`,
+              combination,
+              gender,
+              archetypeIndex: index,
+              language: 'pt-br',
+              name: portuguese[j].masc,
+              essenceLine: portuguese[j].essenceLine,
+              status: 'idle',
+            })
+            .onConflictDoUpdate({
+              target: [schema.archetypesData.id],
+              set: {
+                name: portuguese[j].masc,
+                essenceLine: portuguese[j].essenceLine,
+                updatedAt: new Date().getTime(),
+              },
+            });
+        }
+      }
+    }
+  }
 }

package/app/workflow/ArchetypeWorkflow.ts

@@ -87,6 +87,33 @@ export class ArchetypeWorkflow {
     };
   }
 
+  async generateNames({
+    combinations,
+    gender,
+    overrideExisting,
+  }: {
+    combinations: string[];
+    gender: Gender;
+    overrideExisting?: boolean;
+  }): Promise<void> {
+    if (combinations.length === 0) return;
+
+    if (combinations.length === 1) {
+      await this.archetypeService.generateArchetypeNames(
+        combinations[0],
+        gender,
+        overrideExisting
+      );
+    } else {
+      const entries = combinations.map((combination) => ({
+        combination,
+        gender,
+      }));
+
+      await this.archetypeService.generateArchetypeNamesBatch(entries, overrideExisting);
+    }
+  }
+
   /**
    * Fetch all three archetypes from KV for a given combination and gender.
    */

package/package.json

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

package/types/scopes/generic.ts

@@ -402,7 +402,7 @@ export interface JWKS {
 
 export type ControlNetStrenghtType = 'Low' | 'Mid' | 'High';
 
-export type ControlNetPreprocessorId = 100 | 19;
+export type ControlNetPreprocessorId = 100 | 19 | 133;
 
 export type ControlNetConfig =
   | {
@@ -416,6 +416,12 @@ export type ControlNetConfig =
       initImageType: 'UPLOADED' | 'GENERATED';
       preprocessorId: 19;
       weight: number;
+    }
+  | {
+      initImageId: string;
+      initImageType: 'UPLOADED' | 'GENERATED';
+      preprocessorId: 133;
+      strengthType: ControlNetStrenghtType;
     };
 
 export type PlacementObject = {
@@ -545,13 +551,13 @@ export type ConceptProgress = {
 };
 
 export type UserConceptData = {
-  name: string;              // From conceptsData.name (text, notNull)
-  description: string;       // From conceptsData.description (text, notNull)
-  poem: any[];              // From conceptsData.poem (text, defaults to '[]', but assuming parsed as string)
-  content: any[];            // From conceptsData.content (text, JSON-stringified array, parsed)
+  name: string; // From conceptsData.name (text, notNull)
+  description: string; // From conceptsData.description (text, notNull)
+  poem: any[]; // From conceptsData.poem (text, defaults to '[]', but assuming parsed as string)
+  content: any[]; // From conceptsData.content (text, JSON-stringified array, parsed)
   images: {
-    post: any[];             // From conceptsData.postImages (text, JSON-stringified array, parsed)
-    reel: any[];             // From conceptsData.reelImages (text, JSON-stringified array, parsed)
+    post: any[]; // From conceptsData.postImages (text, JSON-stringified array, parsed)
+    reel: any[]; // From conceptsData.reelImages (text, JSON-stringified array, parsed)
   };
   combinationString: string; // e.g., "sagittarius-aquarius-libra"
   conceptSlug: Concept;
@@ -578,4 +584,4 @@ export type UserProfile = {
   oauthProvider: string | null;
   creditsBalance: number;
   language: string;
-};
+};