@zodic/shared 0.0.294 → 0.0.296

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,7 @@ export class ArchetypeService {
 
   async generateArchetypeNames(
     combination: string,
-    gender: 'male' | 'female' | 'non-binary'
+    overrideExisting: boolean = false
   ) {
     const [sun, ascendant, moon] = combination.split('-') as ZodiacSignSlug[];
 
@@ -338,49 +339,192 @@ 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: {
-              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: {
-              name: portugueseVariants[i].masc,
-              essenceLine: portugueseVariants[i].essenceLine,
-              updatedAt: new Date(),
-            },
-          });
+        const ptVariant = portugueseVariants[i];
+
+        for (const gender of ['male', 'female']) {
+          const enId = `${combination}:${gender}:${index}`;
+          const ptId = `${combination}:${gender}:${index}:pt`;
+
+          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',
+                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 ptName = gender === 'female' ? ptVariant.fem : ptVariant.masc;
+
+          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',
+                name: ptName,
+                essenceLine: ptVariant.essenceLine,
+                status: 'idle',
+              })
+              .onConflictDoUpdate({
+                target: [schema.archetypesData.id],
+                set: {
+                  name: ptName,
+                  essenceLine: ptVariant.essenceLine,
+                  updatedAt: new Date().getTime(),
+                },
+              });
+          }
+        }
       })
     );
   }
+
+  async generateArchetypeNamesBatch(
+    entries: Array<{ combination: string }>,
+    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 } = 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() || '',
+          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];
+
+        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;
+
+          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',
+                name: englishEntry.name,
+                essenceLine: englishEntry.essenceLine,
+                status: 'idle',
+              })
+              .onConflictDoUpdate({
+                target: [schema.archetypesData.id],
+                set: {
+                  name: englishEntry.name,
+                  essenceLine: englishEntry.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',
+                name: ptName,
+                essenceLine: ptEntry.essenceLine,
+                status: 'idle',
+              })
+              .onConflictDoUpdate({
+                target: [schema.archetypesData.id],
+                set: {
+                  name: ptName,
+                  essenceLine: ptEntry.essenceLine,
+                  updatedAt: new Date().getTime(),
+                },
+              });
+          }
+        }
+      }
+    }
+  }
 }

package/app/workflow/ArchetypeWorkflow.ts

@@ -87,6 +87,32 @@ export class ArchetypeWorkflow {
     };
   }
 
+  async generateNames({
+    combinations,
+    overrideExisting,
+  }: {
+    combinations: string[];
+    overrideExisting?: boolean;
+  }): Promise<void> {
+    if (combinations.length === 0) return;
+
+    if (combinations.length === 1) {
+      await this.archetypeService.generateArchetypeNames(
+        combinations[0],
+        overrideExisting
+      );
+    } else {
+      const entries = combinations.map((combination) => ({
+        combination,
+      }));
+
+      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.296",
   "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;
-};
+};