@zodic/shared 0.0.314 → 0.0.316

package/app/services/LeonardoService.ts

@@ -1,382 +1,281 @@
+import { eq } from 'drizzle-orm';
 import { inject, injectable } from 'inversify';
 import 'reflect-metadata';
 import { schema } from '../..';
-import { Gender, VALID_GENDERS_ARRAY } from '../../types';
-import {
-  KVArchetype,
-  LeonardoGenerateImageResponse,
-  sizes,
-} from '../../types/scopes/legacy';
-import { buildCosmicMirrorArchetypeKVKey } from '../../utils/KVKeysBuilders';
+import { Gender } from '../../types';
 import { AppContext } from '../base/AppContext';
 
+interface QueueMessage {
+  archetypeDataId: string;
+  combination: string;
+  gender: Gender;
+  language: string;
+  archetypeIndex: string;
+}
+
 @injectable()
 export class LeonardoService {
   constructor(@inject(AppContext) private context: AppContext) {}
 
-  /**
-   * Processes and generates missing Leonardo prompts for archetypes.
-   */
-  async processArchetypesPrompts(crown: string): Promise<void> {
-    console.log(`Processing Leonardo prompts for crown: ${crown}`);
-
-    const promptsToGenerate: Array<{
-      kvKey: string;
-      name: string;
-      visualDescription: string;
-    }> = [];
-
-    for (const gender of VALID_GENDERS_ARRAY) {
-      for (let index = 1; index <= 3; index++) {
-        const kvKey = buildCosmicMirrorArchetypeKVKey(
-          'en-us',
-          crown,
-          gender,
-          index
-        );
-        console.log(`Fetching archetype from KV: ${kvKey}`);
-
-        const kvData = await this.context
-          .kvCosmicMirrorArchetypesStore()
-          .get<KVArchetype>(kvKey, 'json');
-        if (kvData && !kvData.leonardoPrompt) {
-          promptsToGenerate.push({
-            kvKey,
-            name: kvData.name,
-            visualDescription: kvData.visualDescription,
-          });
-        }
-      }
-    }
-
-    if (promptsToGenerate.length === 0) {
-      console.log('No archetype prompts need to be generated.');
-      return;
-    }
-
-    console.log('Archetypes requiring prompt generation:', promptsToGenerate);
-
-    const archetypes = promptsToGenerate.map(({ name, visualDescription }) => ({
-      name,
-      visualDescription,
-    }));
-    const leonardoPrompts =
-      await this.generateCosmicMirrorArchetypesLeonardoPrompts(archetypes);
-
-    if (leonardoPrompts.length !== archetypes.length) {
-      throw new Error('Mismatch between archetypes and generated prompts.');
-    }
-
-    for (const [index, promptSet] of leonardoPrompts.entries()) {
-      const { kvKey } = promptsToGenerate[index];
-      console.log(`Updating KV with prompts for archetype: ${kvKey}`);
+  private async log(
+    level: 'info' | 'debug' | 'warn' | 'error',
+    message: string,
+    context: Record<string, any> = {}
+  ) {
+    const logId = `leonardo-service:${Date.now()}`;
+    const logMessage = `[${level.toUpperCase()}] ${message}`;
 
-      const kvData = await this.context
-        .kvCosmicMirrorArchetypesStore()
-        .get<KVArchetype>(kvKey, 'json');
-      if (!kvData) {
-        console.warn(`KV data not found for key: ${kvKey}. Skipping update.`);
-        continue;
-      }
+    console[level](logMessage, context);
 
-      kvData.leonardoPrompt = promptSet;
-      await this.context
-        .kvCosmicMirrorArchetypesStore()
-        .put(kvKey, JSON.stringify(kvData));
+    const db = this.context.drizzle();
+    try {
+      await db
+        .insert(schema.logs)
+        .values({
+          id: logId,
+          level,
+          message,
+          context: JSON.stringify(context),
+          createdAt: new Date().getTime(),
+        })
+        .execute();
+    } catch (error) {
+      console.error('[ERROR] Failed to persist log to database:', {
+        error,
+        logId,
+        message,
+        context,
+      });
     }
-
-    console.log(`Completed prompt processing for crown: ${crown}`);
   }
 
   /**
-   * Queues image generation for archetypes if no images exist.
+   * Processes a message from ARCHETYPE_POPULATION_QUEUE to ensure the archetype has three images.
    */
-  async queueImagesForArchetypes(crown: string, gender: Gender): Promise<void> {
-    console.log(
-      `Queuing image generation for crown: ${crown}, gender: ${gender}`
-    );
-
-    for (let index = 1; index <= 3; index++) {
-      const kvKey = buildCosmicMirrorArchetypeKVKey(
-        'en-us',
-        crown,
-        gender,
-        index
-      );
-      console.info(`Fetching KV for archetype: ${kvKey}`);
-
-      const kvData = await this.context
-        .kvCosmicMirrorArchetypesStore()
-        .get<KVArchetype>(kvKey, 'json');
-      if (!kvData || kvData.images.length >= 3) {
-        console.info(
-          `Skipping image generation for index ${index}, images already exist.`
-        );
-        continue;
-      }
-
-      console.info(`No images found. Queuing generation for index ${index}...`);
-
-      const generationResponse = await this.queueImageGeneration(
-        kvData.leonardoPrompt
-      );
-      const generationId = generationResponse.sdGenerationJob.generationId;
+  async processArchetypePopulation(message: QueueMessage): Promise<void> {
+    const { archetypeDataId, combination, gender, language, archetypeIndex } =
+      message;
+    await this.log('info', 'Processing archetype population', {
+      archetypeDataId,
+      combination,
+      gender,
+      language,
+      archetypeIndex,
+    });
 
-      if (!generationId) {
-        throw new Error('Leonardo generation failed to return a valid ID.');
-      }
+    const db = this.context.drizzle();
+    const archetype = await db
+      .select()
+      .from(schema.archetypesData)
+      .where(eq(schema.archetypesData.id, archetypeDataId))
+      .limit(1)
+      .execute();
+
+    if (!archetype[0]) {
+      await this.log('error', 'Archetype not found', { archetypeDataId });
+      throw new Error(`Archetype not found: ${archetypeDataId}`);
+    }
 
-      await this.context.drizzle().insert(schema.generations).values({
-        id: generationId,
-        archetypeIndex: index,
-        conceptCombinationId: null,
-        type: 'archetype_image',
-        status: 'pending',
-        createdAt: new Date(),
+    const images = JSON.parse(archetype[0].images || '[]');
+    if (images.length >= 3) {
+      await this.log('info', 'Archetype already has sufficient images', {
+        archetypeDataId,
+        imageCount: images.length,
       });
+      return;
+    }
 
-      console.info(
-        `Queued generation ${generationId} for archetype index ${index}`
+    if (!archetype[0].leonardoPrompt) {
+      await this.log('error', 'Missing Leonardo prompt for archetype', {
+        archetypeDataId,
+      });
+      throw new Error(
+        `Missing Leonardo prompt for archetype: ${archetypeDataId}`
       );
     }
-  }
 
-  /**
-   * Generates Leonardo prompts for archetypes.
-   */
-  private async generateCosmicMirrorArchetypesLeonardoPrompts(
-    archetypes: Array<{ name: string; visualDescription: string }>
-  ): Promise<string[]> {
-    console.log(`Generating Leonardo prompts for archetypes`);
+    await this.log('debug', 'Generating images for archetype', {
+      archetypeDataId,
+      prompt: archetype[0].leonardoPrompt,
+    });
 
-    const messages = this.context
-      .buildLLMMessages()
-      .generateCosmicMirrorArchetypesLeonardoPrompts(archetypes);
-    const response = await this.context.api().callChatGPT.single(messages, {});
+    const generationResponse = await this.context
+      .api()
+      .callLeonardo.generateImage({
+        prompt: archetype[0].leonardoPrompt,
+        width: 512,
+        height: 640,
+        quantity: 3 - images.length,
+      });
 
-    if (!response) {
-      throw new Error('Leonardo prompts not generated');
+    const generationId = generationResponse.sdGenerationJob.generationId;
+    if (!generationId) {
+      await this.log(
+        'error',
+        'Leonardo generation failed to return a valid ID',
+        { archetypeDataId }
+      );
+      throw new Error('Leonardo generation failed to return a valid ID');
     }
 
-    console.log('Leonardo Prompts from API -> ', response);
+    await db.insert(schema.generations).values({
+      id: generationId,
+      archetypeIndex: parseInt(archetypeIndex),
+      archetypeDataId,
+      type: 'archetype_image',
+      status: 'pending',
+      gender,
+      createdAt: new Date(),
+    });
 
-    return response
-      .split('\n')
-      .map((prompt) => prompt.trim())
-      .filter(Boolean);
+    await this.log('info', 'Queued image generation', {
+      generationId,
+      archetypeDataId,
+      imagesToGenerate: 3 - images.length,
+    });
   }
 
   /**
-   * Queues an image generation request to Leonardo.
+   * Uploads a user-provided image to Leonardo.ai.
    */
-  private async queueImageGeneration(
-    prompt: string
-  ): Promise<LeonardoGenerateImageResponse> {
-    console.log(`Queuing Leonardo image generation...`);
-
-    const { width, height } = sizes['alchemy']['post4:5'];
-
-    try {
-      const response = await this.context
-        .api()
-        .callLeonardo.generateImage({ width, height, prompt });
-      if (!response) {
-        throw new Error('Leonardo image generation failed');
-      }
-
-      console.log('Leonardo Image Generation Response:', response);
-      return response;
-    } catch (error) {
-      console.error('Error queuing Leonardo image generation:', error);
-      throw error;
-    }
-  }
-
   async uploadImage(
     file: File
   ): Promise<{ uploadedImageId: string; uploadedImageUrl: string }> {
-    const fileName = file.name;
-    const fileExtension = fileName.split('.').pop()?.toLowerCase();
-    const mimeType = `image/${fileExtension}`;
+    await this.log('info', 'Starting image upload', {
+      fileName: file.name,
+      fileSize: file.size,
+    });
 
-    if (!fileExtension) {
-      throw new Error('Invalid file extension');
-    }
+    const fileExtension = file.name.split('.').pop()?.toLowerCase();
+    const mimeType = file.type || `image/${fileExtension}`;
 
-    console.log('Starting uploadImage with details:', {
-      fileName,
-      fileExtension,
-      mimeType,
-    });
+    if (!fileExtension || !mimeType.startsWith('image/')) {
+      await this.log('error', 'Invalid file extension or type', {
+        fileName: file.name,
+      });
+      throw new Error('Invalid file extension or type');
+    }
 
     try {
-      console.log('Requesting presigned URL...');
       const presignedUrlData = await this.context
         .api()
-        .callLeonardo.generatePresignedUrl({
-          extension: fileExtension,
-        });
-
-      if (
-        !presignedUrlData.url ||
-        !presignedUrlData.fields ||
-        !presignedUrlData.id
-      ) {
-        throw new Error('Invalid presigned URL response from API');
-      }
-
-      console.log('Uploading file...');
-      await this.uploadToPresignedUrl(
-        presignedUrlData.url,
-        presignedUrlData.fields,
-        file
-      );
+        .callLeonardo.generatePresignedUrl();
+      await this.context.api().callLeonardo.uploadImageToPresignedUrl(file, {
+        fields: presignedUrlData.fields,
+        url: presignedUrlData.url,
+      });
 
       const uploadedImageId = presignedUrlData.id;
+      // TODO: Replace hardcoded user ID with dynamic value from env or context
       const uploadedImageUrl = `https://cdn.leonardo.ai/users/b117a933-e5c9-45b2-96aa-4b619c2d74ba/initImages/${uploadedImageId}.${fileExtension}`;
 
-      console.log('File uploaded successfully:', {
+      await this.log('info', 'Image uploaded successfully', {
         uploadedImageId,
         uploadedImageUrl,
       });
-
       return { uploadedImageId, uploadedImageUrl };
     } catch (error: any) {
-      console.error('Error during image upload:', error.message);
+      await this.log('error', 'Error during image upload', {
+        message: error.message,
+      });
       throw new Error('Failed to upload image');
     }
   }
 
+  /**
+   * Uploads an image from a URL to Leonardo.ai.
+   */
   async uploadImageByUrl(
     imageUrl: string
   ): Promise<{ uploadedImageId: string; uploadedImageUrl: string }> {
-    console.log('Starting uploadImageByUrl with imageUrl:', imageUrl);
+    await this.log('info', 'Starting image upload by URL', { imageUrl });
 
     try {
-      console.log('Fetching image from URL...');
       const response = await fetch(imageUrl);
-
       if (!response.ok) {
-        throw new Error(
-          `Failed to fetch image from URL: ${response.statusText}`
-        );
+        await this.log('error', 'Failed to fetch image from URL', {
+          status: response.status,
+          statusText: response.statusText,
+        });
+        throw new Error(`Failed to fetch image: ${response.statusText}`);
       }
 
       const blob = await response.blob();
       const fileExtension = imageUrl.split('.').pop()?.toLowerCase() || 'jpg';
       const mimeType = blob.type || `image/${fileExtension}`;
 
-      if (!fileExtension || !mimeType.startsWith('image/')) {
-        throw new Error('Invalid image URL or file type');
+      if (!mimeType.startsWith('image/')) {
+        await this.log('error', 'Invalid image type', { imageUrl, mimeType });
+        throw new Error('Invalid image type');
       }
 
-      console.log('Image fetched successfully:', {
-        fileExtension,
-        mimeType,
+      // Explicitly use global File constructor to ensure Web API File
+      const file = new File([blob], `upload.${fileExtension}`, {
+        type: mimeType,
       });
 
-      console.log('Requesting presigned URL...');
       const presignedUrlData = await this.context
         .api()
-        .callLeonardo.generatePresignedUrl({
-          extension: fileExtension,
+        .callLeonardo.generatePresignedUrl();
+      await this.context
+        .api()
+        .callLeonardo.uploadImageToPresignedUrl(file as File, {
+          fields: presignedUrlData.fields,
+          url: presignedUrlData.url,
         });
 
-      if (
-        !presignedUrlData.url ||
-        !presignedUrlData.fields ||
-        !presignedUrlData.id
-      ) {
-        throw new Error('Invalid presigned URL response from API');
-      }
-
-      console.log('Presigned URL obtained:', presignedUrlData);
-
-      const file = new File([blob], `upload.${fileExtension}`, {
-        type: mimeType,
-      });
-
-      console.log('Uploading file to presigned URL...');
-      await this.uploadToPresignedUrl(
-        presignedUrlData.url,
-        presignedUrlData.fields,
-        file as any
-      );
-
       const uploadedImageId = presignedUrlData.id;
+      // TODO: Replace hardcoded user ID with dynamic value from env or context
       const uploadedImageUrl = `https://cdn.leonardo.ai/users/b117a933-e5c9-45b2-96aa-4b619c2d74ba/initImages/${uploadedImageId}.${fileExtension}`;
 
-      console.log('Image uploaded successfully:', {
+      await this.log('info', 'Image uploaded successfully', {
         uploadedImageId,
         uploadedImageUrl,
       });
-
       return { uploadedImageId, uploadedImageUrl };
     } catch (error: any) {
-      console.error('Error during uploadImageByUrl:', error.message);
+      await this.log('error', 'Error during uploadImageByUrl', {
+        message: error.message,
+      });
       throw new Error('Failed to upload image by URL');
     }
   }
 
-  private async uploadToPresignedUrl(
-    presignedUrl: string,
-    fields: string,
-    file: File
-  ): Promise<void> {
-    const parsedFields = JSON.parse(fields);
-    const formData = new FormData();
-
-    Object.entries(parsedFields).forEach(([key, value]) => {
-      formData.append(key, value as string);
-    });
-    formData.append('file', file);
-
-    console.log('Uploading with FormData:', Array.from(formData.entries()));
-
-    const response = await fetch(presignedUrl, {
-      method: 'POST',
-      body: formData,
+  /**
+   * Personalizes a Leonardo prompt based on user-specific traits.
+   */
+  async personalizeCosmicMirrorLeonardoPrompt(params: {
+    leonardoPrompt: string;
+    traits: string;
+  }): Promise<string> {
+    const { leonardoPrompt, traits } = params;
+    await this.log('info', 'Personalizing Leonardo prompt', {
+      leonardoPrompt,
+      traits,
     });
 
-    if (!response.ok) {
-      const errorDetails = await response.text();
-      console.error('Upload failed:', errorDetails);
-      throw new Error(`Image upload failed: ${response.status}`);
-    }
-
-    console.log('Upload to presigned URL successful');
-  }
+    const messages = this.context
+      .buildLLMMessages()
+      .personalizeCosmicMirrorLeonardoPrompt({ leonardoPrompt, traits });
 
-  /**
- * Personalizes a Leonardo prompt based on user-specific traits.
- * @param params - Details for prompt personalization
- * @returns {Promise<string>} - The personalized prompt
- */
-async personalizeCosmicMirrorLeonardoPrompt(params: {
-  leonardoPrompt: string;
-  traits: string;
-}): Promise<string> {
-  const { leonardoPrompt, traits } = params;
-
-  const messages = this.context
-    .buildLLMMessages()
-    .personalizeCosmicMirrorLeonardoPrompt({ leonardoPrompt, traits });
-
-  try {
-    const personalizedPrompt = await this.context
-      .api()
-      .callChatGPT.single(messages, {});
+    try {
+      const personalizedPrompt = await this.context
+        .api()
+        .callChatGPT.single(messages, {});
+      if (!personalizedPrompt) {
+        await this.log('error', 'Failed to generate personalized prompt');
+        throw new Error('Failed to generate personalized prompt');
+      }
 
-    if (!personalizedPrompt) {
-      throw new Error('Failed to generate personalized prompt');
+      await this.log('info', 'Successfully personalized prompt', {
+        personalizedPrompt,
+      });
+      return personalizedPrompt.trim();
+    } catch (error: any) {
+      await this.log('error', 'Error personalizing Leonardo prompt', {
+        message: error.message,
+      });
+      throw error;
     }
-
-    console.log('Personalized Leonardo Prompt:', personalizedPrompt);
-
-    return personalizedPrompt.trim();
-  } catch (error) {
-    console.error('Error personalizing Leonardo prompt:', error);
-    throw error;
   }
 }
-}