vibefast-cli 0.2.4 → 0.3.1

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

@@ -0,0 +1,257 @@
+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

@@ -0,0 +1,71 @@
+/**
+ * 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

@@ -0,0 +1,43 @@
+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/imageAnalysisAdapter.ts

@@ -0,0 +1,200 @@
+'use node';
+
+import { createGoogleGenerativeAI } from '@ai-sdk/google';
+import { createOpenAI } from '@ai-sdk/openai';
+import { generateObject } from 'ai';
+
+import { getAnalysisConfig } from './analysisConfigs';
+import { type AIProvider, getAIConfig } from './config';
+
+/**
+ * Generic analysis result type
+ */
+export type GenericAnalysisResult = {
+  overallScore: number;
+  overallMessage: string;
+  confidence: number;
+  traitScores: Record<
+    string,
+    {
+      score: number;
+      feedback: string;
+      strengths: string[];
+      improvements: string[];
+    }
+  >;
+  recommendations: string[];
+  analysisType: string;
+  processingTime: number;
+};
+
+/**
+ * Truncate an oversized base64 string while preserving a valid encoding.
+ *
+ * Base64 strings must have a length that is a multiple of 4 and must end with
+ * optional padding characters ("="). A naive substring can break the encoding
+ * and lead to downstream "unsupported image" errors from the OpenAI API. This
+ * helper trims the string **only** when it exceeds the chosen limit and always
+ * rounds the length down to the nearest multiple of 4 to keep the data valid.
+ *
+ * NOTE: The client already compresses/resize images before upload, so the limit
+ * here is intentionally generous (4 MB of base64 text ≈ 3 MB binary). This
+ * should fit within OpenAI's 30 MB image cap while safeguarding Convex memory.
+ */
+function optimizeImageForMemory(base64: string): string {
+  const MAX_CHARS = 4 * 1024 * 1024; // 4 MB worth of base64 characters
+
+  if (base64.length <= MAX_CHARS) {
+    return base64;
+  }
+
+  console.log(
+    `[Memory Optimization] Truncating image from ${base64.length} to ${MAX_CHARS} chars (safe multiple-of-4)`,
+  );
+
+  // Round down to nearest multiple of 4 to preserve base64 integrity
+  const safeLength = MAX_CHARS - (MAX_CHARS % 4);
+  const truncated = base64.substring(0, safeLength);
+
+  // Ensure proper padding – if the truncated string ends with partial padding
+  // remove it and re-append correct padding.
+  const withoutPartialPad = truncated.replace(/=+$/, '');
+  const padNeeded = (4 - (withoutPartialPad.length % 4)) % 4;
+  return withoutPartialPad + '='.repeat(padNeeded);
+}
+
+/**
+ * Generate structured analysis using AI SDK (generic for any analysis type)
+ */
+export async function generateImageAnalysis(
+  imagesAsBase64: string[],
+  preferences: {
+    goal: string;
+    feedbackStyle: string;
+  },
+  analysisConfigId = 'face_analysis',
+): Promise<GenericAnalysisResult> {
+  const config = getAIConfig();
+  const analysisConfig = getAnalysisConfig(analysisConfigId);
+  const startTime = Date.now();
+
+  // Memory optimization: Limit to max 3 images and optimize them
+  const maxImages = 3;
+  const optimizedImages = imagesAsBase64
+    .slice(0, maxImages)
+    .map(optimizeImageForMemory);
+
+  console.log(
+    `[Memory Optimization] Processing ${optimizedImages.length} images (max ${maxImages})`,
+  );
+
+  // Create the appropriate AI provider
+  const provider = createAIProvider(config.provider);
+  const model = provider(config.model);
+
+  // Build a simpler, shorter prompt to reduce memory usage
+  const prompt = buildOptimizedPrompt(
+    analysisConfig,
+    preferences,
+    optimizedImages.length,
+  );
+
+  // Convert base64 images to the format expected by AI SDK
+  const imageMessages = optimizedImages.map((base64) => ({
+    type: 'image' as const,
+    image: `data:image/jpeg;base64,${base64}`,
+  }));
+
+  try {
+    // Generate structured output using AI SDK with reduced complexity
+    const { object } = await generateObject({
+      model,
+      schema: analysisConfig.schema,
+      messages: [
+        {
+          role: 'user',
+          content: [{ type: 'text', text: prompt }, ...imageMessages],
+        },
+      ],
+      temperature: config.temperature,
+      maxTokens: Math.min(config.maxTokens, 2000), // Reduce max tokens to save memory
+    });
+
+    // Add processing metadata
+    const processingTime = Date.now() - startTime;
+    return {
+      ...object,
+      processingTime,
+      analysisType: `${analysisConfigId}_${preferences.goal}_${preferences.feedbackStyle}`,
+    } as GenericAnalysisResult;
+  } catch (error) {
+    console.error('Error generating analysis:', error);
+    throw new Error(
+      `Failed to generate analysis: ${error instanceof Error ? error.message : 'Unknown error'}`,
+    );
+  }
+}
+
+/**
+ * Build optimized, shorter prompt to reduce memory usage
+ */
+function buildOptimizedPrompt(
+  analysisConfig: any,
+  preferences: { goal: string; feedbackStyle: string },
+  imageCount: number,
+): string {
+  const traitNames = Object.keys(analysisConfig.traits).slice(0, 6); // Limit traits to reduce complexity
+
+  return `Analyze the ${imageCount} image(s) for ${analysisConfig.name.toLowerCase()}.
+
+Goal: ${preferences.goal}
+Style: ${preferences.feedbackStyle}
+
+Provide scores (0-100) and feedback for: ${traitNames.join(', ')}.
+
+Include:
+- Overall score and message
+- Individual trait scores with feedback
+- 2-3 recommendations
+- Confidence level (0-1)
+
+Be concise and ${preferences.feedbackStyle}.`;
+}
+
+/**
+ * Legacy function for backward compatibility (face analysis)
+ * @deprecated Use generateImageAnalysis instead
+ */
+export async function generateFacialAnalysis(
+  imagesAsBase64: string[],
+  preferences: {
+    goal: string;
+    feedbackStyle: string;
+  },
+): Promise<GenericAnalysisResult> {
+  return generateImageAnalysis(imagesAsBase64, preferences, 'face_analysis');
+}
+
+/**
+ * Create AI provider based on configuration
+ */
+function createAIProvider(provider: AIProvider) {
+  switch (provider) {
+    case 'openai': {
+      const apiKey = process.env.OPENAI_API_KEY;
+      if (!apiKey) {
+        throw new Error('OPENAI_API_KEY environment variable is required');
+      }
+      return createOpenAI({ apiKey });
+    }
+    case 'gemini': {
+      const apiKey = process.env.GEMINI_API_KEY;
+      if (!apiKey) {
+        throw new Error('GEMINI_API_KEY environment variable is required');
+      }
+      return createGoogleGenerativeAI({ apiKey });
+    }
+    default:
+      throw new Error(`Unsupported AI provider: ${provider}`);
+  }
+}

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

@@ -0,0 +1,43 @@
+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;
+}

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

@@ -0,0 +1,79 @@
+import { z } from 'zod';
+
+/**
+ * Schema for individual trait analysis
+ */
+export const TraitAnalysisSchema = z.object({
+  score: z.number().min(0).max(100).describe('Score from 0-100 for this trait'),
+  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'),
+});
+
+/**
+ * Schema for comprehensive facial analysis results
+ */
+export const FacialAnalysisSchema = z.object({
+  // Overall analysis
+  overallScore: z
+    .number()
+    .min(0)
+    .max(100)
+    .describe('Overall facial analysis score'),
+  overallMessage: z.string().describe('Comprehensive analysis summary'),
+  confidence: z
+    .number()
+    .min(0)
+    .max(1)
+    .describe('AI confidence in the analysis'),
+
+  // Individual trait scores
+  traitScores: z.object({
+    jawline: TraitAnalysisSchema.describe('Jawline definition and structure'),
+    skinHealth: TraitAnalysisSchema.describe(
+      'Skin clarity, texture, and health',
+    ),
+    facialSymmetry: TraitAnalysisSchema.describe(
+      'Facial symmetry and proportions',
+    ),
+    eyeArea: TraitAnalysisSchema.describe(
+      'Eye shape, clarity, and expressiveness',
+    ),
+    noseStructure: TraitAnalysisSchema.describe(
+      'Nose proportions and structure',
+    ),
+    lipFullness: TraitAnalysisSchema.describe('Lip shape and fullness'),
+  }),
+
+  // Recommendations
+  recommendations: z
+    .array(z.string())
+    .describe('Actionable recommendations for improvement'),
+
+  // Analysis metadata
+  analysisType: z.string().describe('Type of analysis performed'),
+  processingTime: z
+    .number()
+    .describe('Time taken for analysis in milliseconds'),
+});
+
+/**
+ * Type definitions derived from schemas
+ */
+export type TraitAnalysis = z.infer<typeof TraitAnalysisSchema>;
+export type FacialAnalysisResult = z.infer<typeof FacialAnalysisSchema>;
+
+/**
+ * Schema for the AI prompt context
+ */
+export const AnalysisPromptSchema = z.object({
+  goal: z.string().describe('Analysis goal (e.g., facial_beauty, skin_health)'),
+  feedbackStyle: z
+    .string()
+    .describe('Feedback style (e.g., constructive, detailed)'),
+  imageCount: z.number().describe('Number of images being analyzed'),
+});
+
+export type AnalysisPrompt = z.infer<typeof AnalysisPromptSchema>;