vibefast-cli 0.2.4 → 0.3.1

package/2/packages/backend/convex/imageAnalysisFunctions.ts

@@ -0,0 +1,325 @@
+import { getAuthUserId } from '@convex-dev/auth/server';
+import { v } from 'convex/values';
+
+import { internal } from './_generated/api';
+import type { Id } from './_generated/dataModel';
+import {
+  action,
+  internalAction,
+  internalMutation,
+  internalQuery,
+  query,
+} from './_generated/server';
+import { generateImageAnalysis } from './lib/ai/imageAnalysisAdapter';
+
+/**
+ * Public action to start image analysis
+ */
+export const analyzeImages = action({
+  args: {
+    imagesAsBase64: v.array(v.string()),
+    preferences: v.object({
+      goal: v.string(),
+      feedbackStyle: v.string(),
+    }),
+    analysisConfigId: v.optional(v.string()), // Optional for backward compatibility
+  },
+  handler: async (ctx, args): Promise<Id<'imageAnalyses'>> => {
+    const userId = await getAuthUserId(ctx);
+    if (!userId) {
+      throw new Error('Not authenticated');
+    }
+
+    // Use default config if not provided (for backward compatibility)
+    const configId = args.analysisConfigId || 'face_analysis';
+
+    // Store images in Convex storage
+    const imageStorageIds: Id<'_storage'>[] = [];
+    for (const base64Image of args.imagesAsBase64) {
+      const uint8Array = new Uint8Array(Buffer.from(base64Image, 'base64'));
+      const blob = new Blob([uint8Array], { type: 'image/jpeg' });
+      const storageId = await ctx.storage.store(blob);
+      imageStorageIds.push(storageId);
+    }
+
+    // Create analysis record
+    const analysisId = await ctx.runMutation(
+      internal.imageAnalysisFunctions.createAnalysisRecord,
+      {
+        userId,
+        imageStorageIds,
+        analysisConfigId: configId,
+        preferences: args.preferences,
+      },
+    );
+
+    // Schedule background AI analysis
+    await ctx.scheduler.runAfter(
+      0,
+      internal.imageAnalysisFunctions.performAiAnalysis,
+      {
+        analysisId,
+      },
+    );
+
+    return analysisId;
+  },
+});
+
+/**
+ * Internal mutation to create analysis record
+ */
+export const createAnalysisRecord = internalMutation({
+  args: {
+    userId: v.id('users'),
+    imageStorageIds: v.array(v.id('_storage')),
+    analysisConfigId: v.optional(v.string()),
+    preferences: v.object({
+      goal: v.string(),
+      feedbackStyle: v.string(),
+    }),
+  },
+  handler: async (ctx, args) => {
+    return await ctx.db.insert('imageAnalyses', {
+      userId: args.userId,
+      status: 'processing',
+      imageStorageIds: args.imageStorageIds,
+      analysisConfigId: args.analysisConfigId,
+      preferences: args.preferences,
+    });
+  },
+});
+
+/**
+ * Internal action to perform AI analysis
+ */
+export const performAiAnalysis = internalAction({
+  args: {
+    analysisId: v.id('imageAnalyses'),
+  },
+  handler: async (ctx, args) => {
+    try {
+      // Get analysis record
+      const analysis = await ctx.runQuery(
+        internal.imageAnalysisFunctions.getAnalysisRecord,
+        {
+          analysisId: args.analysisId,
+        },
+      );
+
+      if (!analysis) {
+        throw new Error('Analysis record not found');
+      }
+
+      // Get analysis configuration (use default if not specified for backward compatibility)
+      const configId = analysis.analysisConfigId || 'face_analysis';
+
+      // Get image URLs from storage - parallelize for better performance
+      const imageUrls = await Promise.all(
+        analysis.imageStorageIds.map(async (storageId) => {
+          const url = await ctx.storage.getUrl(storageId);
+          return url;
+        }),
+      );
+
+      // Convert image URLs to base64 for AI analysis - parallelize with timeout
+      const FETCH_TIMEOUT_MS = 30000; // 30 seconds per image
+      const imagesAsBase64 = await Promise.all(
+        imageUrls
+          .filter((url): url is string => url !== null)
+          .map(async (url) => {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(
+              () => controller.abort(),
+              FETCH_TIMEOUT_MS,
+            );
+            try {
+              const response = await fetch(url, { signal: controller.signal });
+              clearTimeout(timeoutId);
+              if (!response.ok) {
+                throw new Error(
+                  `Failed to fetch image: ${response.statusText}`,
+                );
+              }
+              const arrayBuffer = await response.arrayBuffer();
+              return Buffer.from(arrayBuffer).toString('base64');
+            } catch (error) {
+              clearTimeout(timeoutId);
+              if (error instanceof Error && error.name === 'AbortError') {
+                throw new Error(
+                  `Image fetch timed out after ${FETCH_TIMEOUT_MS}ms`,
+                );
+              }
+              throw error;
+            }
+          }),
+      );
+
+      // Validate we have at least one image
+      if (imagesAsBase64.length === 0) {
+        throw new Error('No valid images found for analysis');
+      }
+
+      // Normalize preferences for backward compatibility
+      const normalizedPreferences = {
+        goal:
+          'goal' in analysis.preferences
+            ? analysis.preferences.goal
+            : (analysis.preferences as any).analysisGoal,
+        feedbackStyle: analysis.preferences.feedbackStyle,
+      };
+
+      // Perform AI analysis
+      const results = await generateImageAnalysis(
+        imagesAsBase64,
+        normalizedPreferences,
+        configId,
+      );
+
+      // Update analysis record with results
+      await ctx.runMutation(
+        internal.imageAnalysisFunctions.updateAnalysisResults,
+        {
+          analysisId: args.analysisId,
+          results,
+          status: 'completed',
+        },
+      );
+    } catch (error) {
+      console.error('AI analysis failed:', error);
+
+      // Update analysis record with error
+      await ctx.runMutation(
+        internal.imageAnalysisFunctions.updateAnalysisResults,
+        {
+          analysisId: args.analysisId,
+          status: 'failed',
+          errorMessage:
+            error instanceof Error ? error.message : 'Unknown error',
+        },
+      );
+    }
+  },
+});
+
+/**
+ * Internal query to get analysis record
+ */
+export const getAnalysisRecord = internalQuery({
+  args: {
+    analysisId: v.id('imageAnalyses'),
+  },
+  handler: async (ctx, args) => {
+    return await ctx.db.get(args.analysisId);
+  },
+});
+
+/**
+ * Internal mutation to update analysis results
+ */
+export const updateAnalysisResults = internalMutation({
+  args: {
+    analysisId: v.id('imageAnalyses'),
+    results: v.optional(v.any()),
+    status: v.union(v.literal('completed'), v.literal('failed')),
+    errorMessage: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    await ctx.db.patch(args.analysisId, {
+      status: args.status,
+      results: args.results,
+      errorMessage: args.errorMessage,
+    });
+  },
+});
+
+/**
+ * Public query to get analysis by ID
+ */
+export const getAnalysisById = query({
+  args: {
+    analysisId: v.id('imageAnalyses'),
+  },
+  handler: async (ctx, args) => {
+    const userId = await getAuthUserId(ctx);
+    if (!userId) {
+      throw new Error('Not authenticated');
+    }
+
+    const analysis = await ctx.db.get(args.analysisId);
+    if (!analysis) {
+      return null;
+    }
+
+    // Ensure user owns this analysis
+    if (analysis.userId !== userId) {
+      throw new Error('Unauthorized');
+    }
+
+    return analysis;
+  },
+});
+
+/**
+ * Public query to get full analysis with image URLs
+ */
+export const getImageAnalysis = query({
+  args: {
+    analysisId: v.id('imageAnalyses'),
+  },
+  handler: async (ctx, args) => {
+    const userId = await getAuthUserId(ctx);
+    if (!userId) {
+      throw new Error('Not authenticated');
+    }
+
+    const analysis = await ctx.db.get(args.analysisId);
+    if (!analysis) {
+      return null;
+    }
+
+    // Ensure user owns this analysis
+    if (analysis.userId !== userId) {
+      throw new Error('Unauthorized');
+    }
+
+    // Get image URLs - parallelize for better performance
+    const imageUrls = await Promise.all(
+      analysis.imageStorageIds.map(async (storageId) => {
+        const url = await ctx.storage.getUrl(storageId);
+        return url;
+      }),
+    );
+
+    return {
+      ...analysis,
+      imageUrls: imageUrls.filter((url): url is string => url !== null),
+    };
+  },
+});
+
+/**
+ * Public query to get user's analysis history with pagination
+ */
+export const getUserImageAnalyses = query({
+  args: {
+    paginationOpts: v.optional(
+      v.object({
+        numItems: v.number(),
+        cursor: v.union(v.string(), v.null()),
+      }),
+    ),
+  },
+  handler: async (ctx, args) => {
+    const userId = await getAuthUserId(ctx);
+    if (!userId) {
+      throw new Error('Not authenticated');
+    }
+
+    return await ctx.db
+      .query('imageAnalyses')
+      .withIndex('by_userId', (q) => q.eq('userId', userId))
+      .order('desc')
+      .paginate(args.paginationOpts ?? { numItems: 50, cursor: null });
+  },
+});

package/2/packages/backend/convex/imageGeneration/index.ts

@@ -0,0 +1,12 @@
+/**
+ * Image Generation Domain Aggregator
+ *
+ * Single entry point for all image generation Convex functions.
+ * Re-exports functions from imageGeneratorFunctions.ts to decouple
+ * frontend from internal file structure.
+ */
+
+export {
+  generateImageAction,
+  saveImageRecord,
+} from '../imageGeneratorFunctions';

package/2/packages/backend/convex/imageGeneratorFunctions.ts

@@ -0,0 +1,290 @@
+import { getAuthUserId } from '@convex-dev/auth/server';
+import { experimental_generateImage as generateImage } from 'ai';
+import { createOpenAI } from '@ai-sdk/openai';
+import { GoogleGenAI } from '@google/genai';
+import { v } from 'convex/values';
+
+import { internal } from './_generated/api';
+import type { Id } from './_generated/dataModel';
+import { action, internalMutation } from './_generated/server';
+
+const DEFAULT_OPENAI_MODEL = 'dall-e-3';
+const DEFAULT_GEMINI_MODEL = 'gemini-2.5-flash-image';
+
+const SUPPORTED_OPENAI_MODELS = new Set<string>(['dall-e-3', 'gpt-image-1']);
+const SUPPORTED_GEMINI_MODELS = new Set<string>([
+  'gemini-2.5-flash-image',
+  'gemini-2.0-flash-image',
+]);
+
+type SupportedProvider = 'openai' | 'gemini';
+
+const isSupportedProvider = (value: string): value is SupportedProvider =>
+  value === 'openai' || value === 'gemini';
+
+const resolveProvider = (
+  provider: string | null | undefined,
+): SupportedProvider => {
+  if (provider && isSupportedProvider(provider)) {
+    return provider;
+  }
+  return 'gemini';
+};
+
+const resolveModel = (
+  provider: SupportedProvider,
+  model: string | null | undefined,
+): string => {
+  if (provider === 'openai') {
+    return model && SUPPORTED_OPENAI_MODELS.has(model)
+      ? model
+      : DEFAULT_OPENAI_MODEL;
+  }
+  return model && SUPPORTED_GEMINI_MODELS.has(model)
+    ? model
+    : DEFAULT_GEMINI_MODEL;
+};
+
+const generateWithOpenAI = async (prompt: string, model: string) => {
+  const apiKey = process.env.OPENAI_API_KEY;
+  if (!apiKey) {
+    throw new Error('OPENAI_API_KEY environment variable is required');
+  }
+
+  const openai = createOpenAI({ apiKey });
+  const result = await generateImage({
+    model: openai.image(model),
+    prompt,
+    size: '1024x1024',
+  });
+
+  const imageResult = result.image ?? result.images?.[0];
+  if (!imageResult) {
+    throw new Error('OpenAI image generation did not return any image data.');
+  }
+
+  const mimeType = imageResult.mimeType ?? 'image/png';
+  const base64Data =
+    imageResult.base64 ??
+    (imageResult.uint8Array
+      ? Buffer.from(imageResult.uint8Array).toString('base64')
+      : null);
+
+  if (!base64Data) {
+    throw new Error('OpenAI image generation returned no image payload.');
+  }
+
+  return {
+    imageDataUri: `data:${mimeType};base64,${base64Data}`,
+    mimeType,
+  };
+};
+
+const generateWithGemini = async (prompt: string, model: string) => {
+  const apiKey = process.env.GEMINI_API_KEY;
+  if (!apiKey) {
+    throw new Error('GEMINI_API_KEY environment variable is required');
+  }
+
+  const ai = new GoogleGenAI({ apiKey });
+  const response = await ai.models.generateContentStream({
+    model,
+    config: {
+      responseModalities: ['IMAGE', 'TEXT'],
+      //   imageConfig: {
+      //     imageSize: "1K",
+      //   },
+    },
+    contents: [
+      {
+        role: 'user',
+        parts: [
+          {
+            text: prompt,
+          },
+        ],
+      },
+    ],
+  });
+
+  let imageInlineData: {
+    data?: string;
+    mimeType?: string;
+  } | null = null;
+  const textChunks: string[] = [];
+
+  for await (const chunk of response) {
+    const parts = chunk.candidates?.[0]?.content?.parts ?? [];
+    for (const part of parts) {
+      if (part.inlineData) {
+        imageInlineData = part.inlineData;
+        break;
+      }
+      if (part.text) {
+        textChunks.push(part.text);
+      }
+    }
+    if (imageInlineData) {
+      break;
+    }
+  }
+
+  if (!imageInlineData?.data) {
+    const textSummary = textChunks.join(' ').trim();
+    throw new Error(
+      textSummary
+        ? `Gemini image generation did not return any image data. Response: ${textSummary}`
+        : 'Gemini image generation did not return any image data.',
+    );
+  }
+
+  const mimeType = imageInlineData.mimeType ?? 'image/png';
+  const base64Data = imageInlineData.data;
+
+  return {
+    imageDataUri: `data:${mimeType};base64,${base64Data}`,
+    mimeType,
+  };
+};
+
+export const saveImageRecord = internalMutation({
+  args: v.object({
+    userId: v.id('users'),
+    prompt: v.string(),
+    storageId: v.id('_storage'),
+    provider: v.string(),
+    model: v.string(),
+    mimeType: v.optional(v.string()),
+  }),
+  returns: v.id('generatedImages'),
+  handler: async (
+    ctx,
+    { userId, prompt, storageId, provider, model, mimeType },
+  ) => {
+    console.log(`[saveImageRecord] Saving image record for user: ${userId}`);
+
+    const imageRecordId = await ctx.db.insert('generatedImages', {
+      userId,
+      prompt,
+      storageId,
+      provider,
+      model,
+      mimeType,
+    });
+
+    console.log(
+      `[saveImageRecord] Image record created with ID: ${imageRecordId}`,
+    );
+    return imageRecordId;
+  },
+});
+
+/**
+ * Generate an image based on user prompt and provider selection
+ */
+export const generateImageAction = action({
+  args: v.object({
+    prompt: v.string(),
+    provider: v.string(), // supports 'openai' and 'gemini'
+    model: v.string(),
+  }),
+  returns: v.object({
+    imageDataUri: v.string(),
+    mimeType: v.string(),
+    prompt: v.string(),
+    provider: v.string(),
+    model: v.string(),
+    storageId: v.optional(v.id('_storage')),
+    imageId: v.optional(v.id('generatedImages')),
+  }),
+  handler: async (ctx, { prompt, provider, model }) => {
+    // Verify user authentication
+    const identity = await ctx.auth.getUserIdentity();
+    if (!identity) {
+      throw new Error(
+        'Unauthenticated: User must be logged in to generate images',
+      );
+    }
+
+    const userId = await getAuthUserId(ctx);
+    if (!userId) {
+      throw new Error('User record not found for authenticated identity');
+    }
+    console.log(`[generateImageAction] Provider: ${provider}, Model: ${model}`);
+    const resolvedProvider = resolveProvider(provider);
+    const resolvedModel = resolveModel(resolvedProvider, model);
+
+    console.log(
+      `[generateImageAction] Starting image generation | provider=${resolvedProvider}, model=${resolvedModel}`,
+    );
+
+    try {
+      const result =
+        resolvedProvider === 'openai'
+          ? await generateWithOpenAI(prompt, resolvedModel)
+          : await generateWithGemini(prompt, resolvedModel);
+
+      console.log(
+        `[generateImageAction] Image generated successfully. provider=${resolvedProvider}, model=${resolvedModel}, mimeType=${result.mimeType}, dataUri length=${result.imageDataUri.length}`,
+      );
+
+      let storageId: Id<'_storage'> | null = null;
+      try {
+        const base64Match = result.imageDataUri.match(
+          /^data:(?<mime>[^;]+);base64,(?<payload>.+)$/,
+        );
+        if (!base64Match?.groups?.payload) {
+          throw new Error('Invalid image data URI returned by provider');
+        }
+        const buffer = Buffer.from(base64Match.groups.payload, 'base64');
+        const uint8Array = new Uint8Array(buffer);
+        const blob = new Blob([uint8Array], { type: result.mimeType });
+        storageId = await ctx.storage.store(blob);
+      } catch (storageError) {
+        console.error(
+          '[generateImageAction] Failed to persist generated image to storage',
+          storageError,
+        );
+      }
+
+      let imageRecordId: Id<'generatedImages'> | null = null;
+      if (storageId) {
+        try {
+          imageRecordId = await ctx.runMutation(
+            internal.imageGeneration.index.saveImageRecord,
+            {
+              userId,
+              prompt,
+              storageId,
+              provider: resolvedProvider,
+              model: resolvedModel,
+              mimeType: result.mimeType,
+            },
+          );
+        } catch (recordError) {
+          console.error(
+            '[generateImageAction] Failed to save generated image metadata',
+            recordError,
+          );
+        }
+      }
+
+      return {
+        imageDataUri: result.imageDataUri,
+        mimeType: result.mimeType,
+        prompt,
+        provider: resolvedProvider,
+        model: resolvedModel,
+        storageId: storageId ?? undefined,
+        imageId: imageRecordId ?? undefined,
+      };
+    } catch (error) {
+      console.error('[generateImageAction] Error generating image:', error);
+      throw new Error(
+        `Image generation failed: ${
+          error instanceof Error ? error.message : 'Unknown error'
+        }`,
+      );
+    }
+  },
+});