vibefast-cli 0.7.0 → 0.7.1

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

@@ -1,290 +0,0 @@
-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'
-        }`,
-      );
-    }
-  },
-});

package/2/packages/backend/convex/lib/ai/analysisConfigs.ts

@@ -1,257 +0,0 @@
-import { z } from 'zod';
-
-/**
- * Generic trait analysis schema
- */
-export const TraitAnalysisSchema = z.object({
-  score: z.number().min(0).max(100).describe('Score for this trait (0-100)'),
-  feedback: z.string().describe('Specific feedback about this trait'),
-  strengths: z.array(z.string()).describe('Key strengths for this trait'),
-  improvements: z
-    .array(z.string())
-    .describe('Suggested improvements for this trait'),
-});
-
-/**
- * Base analysis configuration interface
- */
-export interface AnalysisConfig {
-  id: string;
-  name: string;
-  description: string;
-  traits: Record<string, TraitConfig>;
-  prompts: {
-    base: string;
-    instructions: string;
-  };
-  schema: z.ZodObject<any>;
-}
-
-/**
- * Trait configuration interface
- */
-export interface TraitConfig {
-  name: string;
-  description: string;
-  instructions: string;
-}
-
-/**
- * Face Analysis Configuration
- */
-export const FACE_ANALYSIS_CONFIG: AnalysisConfig = {
-  id: 'face_analysis',
-  name: 'Facial Analysis',
-  description: 'Comprehensive facial feature analysis',
-  traits: {
-    jawline: {
-      name: 'Jawline',
-      description: 'Definition, structure, and contouring',
-      instructions: 'Analyze jawline definition, structure, and contouring',
-    },
-    skinHealth: {
-      name: 'Skin Health',
-      description: 'Clarity, texture, tone, and overall health',
-      instructions: 'Assess skin clarity, texture, tone, and overall health',
-    },
-    facialSymmetry: {
-      name: 'Facial Symmetry',
-      description: 'Balance and proportions across facial features',
-      instructions: 'Evaluate facial symmetry and proportional balance',
-    },
-    eyeArea: {
-      name: 'Eye Area',
-      description: 'Shape, clarity, expressiveness, and overall appeal',
-      instructions: 'Analyze eye shape, clarity, and expressiveness',
-    },
-    noseStructure: {
-      name: 'Nose Structure',
-      description: 'Proportions, definition, and harmony with other features',
-      instructions: 'Assess nose proportions and structural harmony',
-    },
-    lipFullness: {
-      name: 'Lip Fullness',
-      description: 'Shape, fullness, and definition',
-      instructions: 'Evaluate lip shape, fullness, and definition',
-    },
-  },
-  prompts: {
-    base: 'You are an expert facial analysis AI. Analyze the provided image(s) and provide a comprehensive facial analysis.',
-    instructions: `Please analyze the following facial traits and provide scores (0-100), specific feedback, strengths, and improvement suggestions for each:
-
-For each trait, provide:
-- A score from 0-100 (where 70+ is good, 80+ is very good, 90+ is excellent)
-- Specific feedback about what you observe
-- Key strengths to highlight
-- Constructive improvement suggestions
-
-Also provide:
-- An overall score (average of all traits)
-- A comprehensive analysis summary
-- Actionable recommendations for enhancement
-- Your confidence level in the analysis (0-1)`,
-  },
-  schema: z.object({
-    overallScore: z.number().min(0).max(100).describe('Overall analysis score'),
-    overallMessage: z.string().describe('Comprehensive analysis summary'),
-    confidence: z
-      .number()
-      .min(0)
-      .max(1)
-      .describe('AI confidence in the analysis'),
-    traitScores: z.object({
-      jawline: TraitAnalysisSchema,
-      skinHealth: TraitAnalysisSchema,
-      facialSymmetry: TraitAnalysisSchema,
-      eyeArea: TraitAnalysisSchema,
-      noseStructure: TraitAnalysisSchema,
-      lipFullness: TraitAnalysisSchema,
-    }),
-    recommendations: z
-      .array(z.string())
-      .describe('Actionable recommendations for improvement'),
-    analysisType: z.string().describe('Type of analysis performed'),
-    processingTime: z
-      .number()
-      .describe('Time taken for analysis in milliseconds'),
-  }),
-};
-
-/**
- * Registry of all available analysis configurations
- */
-export const ANALYSIS_CONFIGS: Record<string, AnalysisConfig> = {
-  face_analysis: FACE_ANALYSIS_CONFIG,
-};
-
-/**
- * Get analysis configuration by ID
- */
-export function getAnalysisConfig(analysisId: string): AnalysisConfig {
-  const config = ANALYSIS_CONFIGS[analysisId];
-  if (!config) {
-    throw new Error(`Unknown analysis type: ${analysisId}`);
-  }
-  return config;
-}
-
-/**
- * Build analysis prompt for any configuration
- */
-export function buildGenericAnalysisPrompt(
-  config: AnalysisConfig,
-  preferences: { goal: string; feedbackStyle: string },
-  imageCount: number,
-): string {
-  const traitInstructions = Object.entries(config.traits)
-    .map(
-      ([, trait], index) =>
-        `${index + 1}. **${trait.name}**: ${trait.description}`,
-    )
-    .join('\n');
-
-  const basePrompt = `${config.prompts.base}
-
-Analysis Goal: ${preferences.goal}
-Feedback Style: ${preferences.feedbackStyle}
-
-Analyze the provided ${imageCount} image(s):
-
-${traitInstructions}
-
-${config.prompts.instructions}
-
-`;
-
-  // Add goal-specific guidance
-  const goalGuidance = getGoalSpecificGuidance(preferences.goal);
-  const styleGuidance = getStyleSpecificGuidance(preferences.feedbackStyle);
-
-  return `${basePrompt}
-
-${goalGuidance}
-
-${styleGuidance}
-
-Be thorough, accurate, and ${preferences.feedbackStyle} in your analysis.`;
-}
-
-/**
- * Get goal-specific analysis guidance
- */
-function getGoalSpecificGuidance(goal: string): string {
-  switch (goal.toLowerCase()) {
-    case 'facial_beauty':
-    case 'beauty':
-      return 'Focus on aesthetic appeal, harmony between features, and overall attractiveness. Consider classical beauty standards while being inclusive of diverse features.';
-
-    case 'skin_health':
-    case 'health':
-      return 'Prioritize health-related aspects: condition, quality, signs of wear or damage, and overall health indicators.';
-
-    case 'facial_structure':
-    case 'structure':
-      return 'Emphasize structural elements, proportions, symmetry, and the geometric relationships between different components.';
-
-    case 'overall_attractiveness':
-    case 'attractiveness':
-      return 'Provide a holistic assessment considering all factors that contribute to overall appeal, including harmony, uniqueness, and visual impact.';
-
-    case 'condition':
-      return 'Focus on the current condition, wear, maintenance, and overall state of the subject being analyzed.';
-
-    default:
-      return 'Provide a balanced analysis considering all aspects with equal weight.';
-  }
-}
-
-/**
- * Get style-specific feedback guidance
- */
-function getStyleSpecificGuidance(style: string): string {
-  switch (style.toLowerCase()) {
-    case 'constructive':
-      return 'Frame all feedback constructively, focusing on actionable improvements while highlighting existing strengths. Be encouraging and supportive.';
-
-    case 'detailed':
-      return 'Provide in-depth, technical analysis with specific observations. Include detailed explanations of your scoring rationale.';
-
-    case 'encouraging':
-      return 'Emphasize positive aspects and frame any suggestions for improvement in an uplifting, motivational manner. Build confidence.';
-
-    case 'professional':
-      return 'Maintain a clinical, objective tone similar to a professional consultation. Be precise and evidence-based.';
-
-    default:
-      return 'Provide balanced, honest feedback that is both informative and respectful.';
-  }
-}
-
-/**
- * Create dynamic schema for any trait configuration
- */
-export function createDynamicSchema(traits: Record<string, TraitConfig>) {
-  const traitSchemas: Record<string, typeof TraitAnalysisSchema> = {};
-
-  Object.keys(traits).forEach((traitKey) => {
-    traitSchemas[traitKey] = TraitAnalysisSchema;
-  });
-
-  return z.object({
-    overallScore: z.number().min(0).max(100).describe('Overall analysis score'),
-    overallMessage: z.string().describe('Comprehensive analysis summary'),
-    confidence: z
-      .number()
-      .min(0)
-      .max(1)
-      .describe('AI confidence in the analysis'),
-    traitScores: z.object(traitSchemas),
-    recommendations: z
-      .array(z.string())
-      .describe('Actionable recommendations for improvement'),
-    analysisType: z.string().describe('Type of analysis performed'),
-    processingTime: z
-      .number()
-      .describe('Time taken for analysis in milliseconds'),
-  });
-}

package/2/packages/backend/convex/lib/ai/config.ts

@@ -1,71 +0,0 @@
-/**
- * AI Configuration for Image Analysis
- * Provides configurable provider and model selection
- */
-
-export type AIProvider = 'openai' | 'gemini';
-
-export interface AIConfig {
-  provider: AIProvider;
-  model: string;
-  temperature: number;
-  maxTokens: number;
-}
-
-/**
- * Default AI configurations for different providers
- */
-export const AI_CONFIGS: Record<AIProvider, AIConfig> = {
-  openai: {
-    provider: 'openai',
-    model: 'gpt-4o', // Latest GPT-4 with vision capabilities
-    temperature: 0.3, // Lower temperature for more consistent analysis
-    maxTokens: 2000,
-  },
-  gemini: {
-    provider: 'gemini',
-    model: 'gemini-1.5-pro', // Gemini Pro with vision capabilities
-    temperature: 0.3,
-    maxTokens: 2000,
-  },
-} as const;
-
-/**
- * Get AI configuration based on environment or default
- */
-export function getAIConfig(): AIConfig {
-  const provider = (process.env.AI_PROVIDER as AIProvider) || 'openai';
-  const config = AI_CONFIGS[provider];
-
-  // Allow model override via environment variable
-  if (process.env.AI_MODEL) {
-    config.model = process.env.AI_MODEL;
-  }
-
-  return config;
-}
-
-/**
- * Available analysis goals for image analysis
- */
-export const ANALYSIS_GOALS = {
-  FACIAL_BEAUTY: 'facial_beauty',
-  SKIN_HEALTH: 'skin_health',
-  FACIAL_STRUCTURE: 'facial_structure',
-  OVERALL_ATTRACTIVENESS: 'overall_attractiveness',
-} as const;
-
-export type AnalysisGoal = (typeof ANALYSIS_GOALS)[keyof typeof ANALYSIS_GOALS];
-
-/**
- * Available feedback styles
- */
-export const FEEDBACK_STYLES = {
-  CONSTRUCTIVE: 'constructive',
-  DETAILED: 'detailed',
-  ENCOURAGING: 'encouraging',
-  PROFESSIONAL: 'professional',
-} as const;
-
-export type FeedbackStyle =
-  (typeof FEEDBACK_STYLES)[keyof typeof FEEDBACK_STYLES];

package/2/packages/backend/convex/lib/ai/geminiAdapter.ts

@@ -1,43 +0,0 @@
-import { createGoogleGenerativeAI } from '@ai-sdk/google';
-import { type CoreMessage, streamText } from 'ai';
-
-export interface GeminiStreamOptions {
-  model?: string;
-  temperature?: number;
-  maxTokens?: number;
-}
-
-/**
- * Stream chat completion from Google Gemini using Vercel AI SDK
- */
-export async function streamGeminiChat(
-  messages: CoreMessage[],
-  options: GeminiStreamOptions = {},
-  onFinish?: (result: any) => Promise<void>,
-) {
-  const {
-    model = 'gemini-2.0-flash',
-    temperature = 0.7,
-    maxTokens = 1000,
-  } = options;
-
-  // Get API key from environment variables
-  const apiKey = process.env.GEMINI_API_KEY;
-  if (!apiKey) {
-    throw new Error('GEMINI_API_KEY environment variable is required');
-  }
-
-  // Create Google provider with API key
-  const googleProvider = createGoogleGenerativeAI({ apiKey });
-
-  // Stream text generation
-  const result = await streamText({
-    model: googleProvider(model),
-    messages,
-    temperature,
-    maxTokens,
-    onFinish,
-  });
-
-  return result;
-}

package/2/packages/backend/convex/lib/ai/openaiAdapter.ts

@@ -1,43 +0,0 @@
-import { createOpenAI } from '@ai-sdk/openai';
-import { type CoreMessage, streamText } from 'ai';
-
-export interface OpenAIStreamOptions {
-  model?: string;
-  temperature?: number;
-  maxTokens?: number;
-}
-
-/**
- * Stream chat completion from OpenAI using Vercel AI SDK
- */
-export async function streamOpenAIChat(
-  messages: CoreMessage[],
-  options: OpenAIStreamOptions = {},
-  onFinish?: (result: any) => Promise<void>,
-) {
-  const {
-    model = 'gpt-4.1-nano',
-    temperature = 0.7,
-    maxTokens = 1000,
-  } = options;
-
-  // Get API key from environment variables
-  const apiKey = process.env.OPENAI_API_KEY;
-  if (!apiKey) {
-    throw new Error('OPENAI_API_KEY environment variable is required');
-  }
-
-  // Create OpenAI provider with API key
-  const openaiProvider = createOpenAI({ apiKey });
-
-  // Stream text generation
-  const result = await streamText({
-    model: openaiProvider(model),
-    messages,
-    temperature,
-    maxTokens,
-    onFinish,
-  });
-
-  return result;
-}