vibefast-cli 1.1.5 → 1.3.0

package/recipes/image-analysis-supabase/apps/native/src/features/image-analyzer/hooks/use-image-analysis.ts

@@ -0,0 +1,208 @@
+import * as FileSystem from 'expo-file-system';
+import * as ImageManipulator from 'expo-image-manipulator';
+import { useCallback } from 'react';
+import { create } from 'zustand';
+
+import {
+  useAnalyzeImages as useAnalyzeImageMutation,
+  useImageAnalysis as useImageAnalysisQuery,
+  useUserImageAnalyses,
+} from '@/api-client/supabase/image-analyzer';
+
+// Temporary store for camera capture data to avoid route parameter issues
+type CameraCaptureStore = {
+  capturedImageUri: string | null;
+  stepId: string | null;
+  setCapturedImage: (uri: string, stepId: string) => void;
+  clearCapturedImage: () => void;
+};
+
+export const useCameraCaptureStore = create<CameraCaptureStore>((set) => ({
+  capturedImageUri: null,
+  stepId: null,
+  setCapturedImage: (uri: string, stepId: string) =>
+    set({ capturedImageUri: uri, stepId }),
+  clearCapturedImage: () => set({ capturedImageUri: null, stepId: null }),
+}));
+
+export type AnalyzeImagesParams = {
+  imageUris: string[];
+  preferences: {
+    goal: string;
+    feedbackStyle: string;
+  };
+  onProgress?: (step: string, progress: number) => void;
+};
+
+export type CreateImageAnalysisParams = {
+  imageUris: string[];
+  preferences: {
+    analysisGoal: string;
+    feedbackStyle: string;
+  };
+  onProgress?: (step: string, progress: number) => void;
+};
+
+/**
+ * Hook for analyzing images using the Supabase Edge Function.
+ */
+export function useAnalyzeImages() {
+  const analyzeImageMutation = useAnalyzeImageMutation();
+
+  return useCallback(
+    async (params: AnalyzeImagesParams): Promise<string | null> => {
+      const { imageUris, preferences, onProgress } = params;
+
+      try {
+        onProgress?.('Optimizing images...', 15);
+
+        // Resize & compress images to reduce memory (max width 1024, quality 0.7)
+        const optimizedUris = await Promise.all(
+          imageUris.map(async (uri) => {
+            try {
+              const { uri: optimizedUri } =
+                await ImageManipulator.manipulateAsync(
+                  uri,
+                  [{ resize: { width: 1024 } }],
+                  {
+                    compress: 0.7,
+                    format: ImageManipulator.SaveFormat.JPEG,
+                    base64: false,
+                  },
+                );
+              return optimizedUri;
+            } catch (err) {
+              console.warn('Image optimization failed, using original', err);
+              return uri;
+            }
+          }),
+        );
+
+        onProgress?.('Converting images...', 20);
+
+        // Convert optimized URIs to base64
+        const base64Images = await Promise.all(
+          optimizedUris.map((uri) =>
+            FileSystem.readAsStringAsync(uri, { encoding: 'base64' }),
+          ),
+        );
+
+        onProgress?.('Starting analysis...', 40);
+
+        // Call the analyze image mutation
+        const result = await analyzeImageMutation.mutateAsync({
+          imagesAsBase64: base64Images,
+          preferences,
+        });
+
+        onProgress?.('Analysis in progress...', 50);
+
+        return result.analysisId;
+      } catch (error) {
+        console.error('Error starting image analysis:', error);
+        return null;
+      }
+    },
+    [analyzeImageMutation],
+  );
+}
+
+/**
+ * Hook for creating and managing image analyses (legacy - for backward compatibility).
+ */
+export function useCreateImageAnalysis() {
+  const analyzeImageMutation = useAnalyzeImageMutation();
+
+  return useCallback(
+    async (params: CreateImageAnalysisParams): Promise<string | null> => {
+      const { imageUris, preferences, onProgress } = params;
+
+      try {
+        onProgress?.('Optimizing images...', 15);
+
+        // Resize & compress images to reduce memory (max width 1024, quality 0.7)
+        const optimizedUris = await Promise.all(
+          imageUris.map(async (uri) => {
+            try {
+              const { uri: optimizedUri } =
+                await ImageManipulator.manipulateAsync(
+                  uri,
+                  [{ resize: { width: 1024 } }],
+                  {
+                    compress: 0.7,
+                    format: ImageManipulator.SaveFormat.JPEG,
+                    base64: false,
+                  },
+                );
+              return optimizedUri;
+            } catch (err) {
+              console.warn('Image optimization failed, using original', err);
+              return uri;
+            }
+          }),
+        );
+
+        onProgress?.('Converting images...', 20);
+
+        // Convert optimized URIs to base64
+        const base64Images = await Promise.all(
+          optimizedUris.map((uri) =>
+            FileSystem.readAsStringAsync(uri, { encoding: 'base64' }),
+          ),
+        );
+
+        onProgress?.('Starting analysis...', 40);
+
+        // Create the analysis with uploaded images
+        const result = await analyzeImageMutation.mutateAsync({
+          imagesAsBase64: base64Images,
+          preferences: {
+            goal: preferences.analysisGoal,
+            feedbackStyle: preferences.feedbackStyle,
+          },
+        });
+
+        onProgress?.('Analysis in progress...', 50);
+
+        return result.analysisId;
+      } catch (error) {
+        console.error('Error creating image analysis:', error);
+        return null;
+      }
+    },
+    [analyzeImageMutation],
+  );
+}
+
+/**
+ * Hook for polling analysis status by ID.
+ */
+export function useAnalysisStatus(analysisId?: string) {
+  const { data } = useImageAnalysisQuery(analysisId ?? null);
+  return data;
+}
+
+/**
+ * Hook for fetching an image analysis by ID.
+ */
+export function useImageAnalysis(analysisId?: string) {
+  const { data } = useImageAnalysisQuery(analysisId ?? null);
+  return data;
+}
+
+/**
+ * Hook for fetching user's image analysis history with optional pagination.
+ */
+export function useImageAnalysisHistory(paginationOpts?: {
+  limit: number;
+  offset: number;
+}) {
+  const { data } = useUserImageAnalyses({ limit: paginationOpts?.limit ?? 50 });
+  const pages = data?.pages ?? [];
+  const allAnalyses = pages.flatMap((page) => page?.analyses ?? []);
+  return {
+    page: allAnalyses,
+    isDone: allAnalyses.length < (paginationOpts?.limit ?? 50),
+    continueCursor: null,
+  };
+}

package/recipes/image-analysis-supabase/apps/native/src/features/image-analyzer/services/analysis-service.ts

@@ -0,0 +1,262 @@
+export type AnalysisScores = {
+  overall: number;
+  [key: string]: number;
+};
+
+export type TraitAnalysis = {
+  score: number;
+  feedback: string;
+  strengths?: string[];
+  improvements?: string[];
+  // Legacy support for old format
+  Score?: number;
+  Feedback?: string;
+};
+
+// Generic trait scores - can work with any analysis type
+export type GenericTraitScores = Record<string, TraitAnalysis>;
+
+export type LocalAnalysis = {
+  id: string;
+  localImageUri?: string;
+  aiResults?: {
+    overallScore?: number;
+    overallMessage?: string;
+    confidence?: number;
+    traitScores?: GenericTraitScores; // Now generic instead of hard-coded
+    recommendations?: string[];
+    analysisType?: string;
+    processingTime?: number;
+    // Legacy support for old format
+    analysis?: string; // Legacy field name for overallMessage
+    [key: string]: any;
+  };
+};
+
+/**
+ * Extract scores from any analysis type (completely dynamic)
+ */
+export function extractScoresFromAnalysis(
+  analysis: LocalAnalysis['aiResults'],
+): AnalysisScores | null {
+  if (!analysis) return null;
+
+  const scores: AnalysisScores = {
+    overall: analysis.overallScore || 0,
+  };
+
+  // Handle structured trait scores (new format)
+  if (analysis.traitScores && typeof analysis.traitScores === 'object') {
+    Object.entries(analysis.traitScores).forEach(([key, trait]) => {
+      if (trait && typeof trait === 'object') {
+        // Support both new format (score) and legacy format (Score)
+        const score = (trait as TraitAnalysis).score || (trait as any).Score;
+        if (typeof score === 'number') {
+          scores[key] = score;
+        }
+      }
+    });
+  }
+
+  // Handle legacy flat format (for backward compatibility)
+  Object.entries(analysis).forEach(([key, value]) => {
+    if (
+      key !== 'overallScore' &&
+      key !== 'overallMessage' &&
+      key !== 'confidence' &&
+      key !== 'traitScores' &&
+      key !== 'recommendations' &&
+      key !== 'analysisType' &&
+      key !== 'processingTime'
+    ) {
+      if (value && typeof value === 'object' && 'Score' in value) {
+        scores[key] = (value as any).Score;
+      } else if (typeof value === 'number') {
+        scores[key] = value;
+      }
+    }
+  });
+
+  return scores;
+}
+
+/**
+ * Process image URL from parameters with priority for multiple images
+ */
+export function processImageUrl(
+  localImageUriParam: string | null,
+  localImageUrisParam: string | null,
+  fallbackImageUri: string | null,
+): string | null {
+  // Priority 1: Multiple images from localImageUris parameter
+  if (localImageUrisParam) {
+    try {
+      const parsedUris = JSON.parse(localImageUrisParam);
+      if (Array.isArray(parsedUris) && parsedUris.length > 0) {
+        return parsedUris[0]; // Return first image
+      }
+    } catch (error) {
+      console.warn('Failed to parse localImageUris:', error);
+    }
+  }
+
+  // Priority 2: Single image from localImageUri parameter
+  if (localImageUriParam) {
+    return localImageUriParam;
+  }
+
+  // Priority 3: Fallback image URI
+  return fallbackImageUri;
+}
+
+/**
+ * Format trait name for display (completely generic)
+ */
+export function formatTraitName(traitKey: string): string {
+  // Convert camelCase to Title Case
+  return traitKey
+    .replace(/([A-Z])/g, ' $1')
+    .replace(/^./, (str) => str.toUpperCase())
+    .trim();
+}
+
+/**
+ * Get trait details for any analysis type (dynamic)
+ */
+export function getTraitDetails(
+  traitKey: string,
+  traitScores: GenericTraitScores | undefined,
+): {
+  score: number;
+  feedback: string;
+  strengths: string[];
+  improvements: string[];
+} | null {
+  if (!traitScores || !traitScores[traitKey]) {
+    return null;
+  }
+
+  const trait = traitScores[traitKey];
+
+  return {
+    score: trait.score || trait.Score || 0,
+    feedback: trait.feedback || trait.Feedback || 'No feedback available',
+    strengths: trait.strengths || [],
+    improvements: trait.improvements || [],
+  };
+}
+
+/**
+ * Generic achievement system that works with any analysis type
+ */
+export type Achievement = {
+  id: string;
+  title: string;
+  description: string;
+  icon: string;
+  color: string;
+  points: number;
+  condition: (scores: AnalysisScores) => boolean;
+};
+
+const GENERIC_ACHIEVEMENTS: Achievement[] = [
+  {
+    id: 'excellentScore',
+    title: 'Excellence',
+    description: 'Achieved an excellent overall score',
+    icon: 'trophy-outline',
+    color: '#FFD700',
+    points: 50,
+    condition: (scores) => scores.overall >= 90,
+  },
+  {
+    id: 'goodAnalysis',
+    title: 'Good Analysis',
+    description: 'Scored well in the analysis',
+    icon: 'thumbs-up-outline',
+    color: '#4CAF50',
+    points: 30,
+    condition: (scores) => scores.overall >= 75,
+  },
+  {
+    id: 'balanced',
+    title: 'Well Balanced',
+    description: 'Consistent scores across all traits',
+    icon: 'scale-outline',
+    color: '#2196F3',
+    points: 25,
+    condition: (scores) => {
+      const traitScores = Object.entries(scores)
+        .filter(([key]) => key !== 'overall')
+        .map(([, score]) => score);
+      if (traitScores.length < 2) return false;
+      const avg = traitScores.reduce((a, b) => a + b, 0) / traitScores.length;
+      const variance =
+        traitScores.reduce((acc, score) => acc + (score - avg) ** 2, 0) /
+        traitScores.length;
+      return variance < 100; // Low variance means balanced
+    },
+  },
+  {
+    id: 'highConfidence',
+    title: 'Clear Assessment',
+    description: 'Analysis completed with high confidence',
+    icon: 'eye-outline',
+    color: '#9C27B0',
+    points: 20,
+    condition: () => true, // We don't have confidence in scores, so always true
+  },
+];
+
+/**
+ * Get unlocked achievements based on analysis scores
+ */
+export function getUnlockedAchievements(scores: AnalysisScores): Achievement[] {
+  return GENERIC_ACHIEVEMENTS.filter((achievement) =>
+    achievement.condition(scores),
+  );
+}
+
+/**
+ * Creates a mock analysis for fallback (generic)
+ */
+export function createMockAnalysis(analysisId: string): LocalAnalysis {
+  return {
+    id: analysisId,
+    localImageUri:
+      'https://images.unsplash.com/photo-1579933113359-f65a43033118?w=800&q=80',
+    aiResults: {
+      overallScore: 85,
+      overallMessage:
+        'Great analysis results with strong performance across multiple areas.',
+      confidence: 0.9,
+      traitScores: {
+        primaryTrait: {
+          score: 90,
+          feedback: 'Excellent primary characteristic',
+          strengths: ['Strong foundation', 'Good structure'],
+          improvements: ['Minor refinements possible'],
+        },
+        secondaryTrait: {
+          score: 80,
+          feedback: 'Very good secondary aspect',
+          strengths: ['Well-balanced', 'Consistent quality'],
+          improvements: ['Some enhancement opportunities'],
+        },
+        tertiaryTrait: {
+          score: 85,
+          feedback: 'Strong tertiary element',
+          strengths: ['Natural appeal', 'Good proportions'],
+          improvements: ['Fine-tuning recommended'],
+        },
+      },
+      recommendations: [
+        'Continue maintaining current standards',
+        'Focus on areas with the most potential',
+        'Consider professional guidance for optimization',
+      ],
+      analysisType: 'generic_analysis',
+      processingTime: 2500,
+    },
+  };
+}

package/recipes/image-analysis-supabase/apps/native/src/features/image-analyzer/services/share-service.ts

@@ -0,0 +1,176 @@
+import * as FileSystem from 'expo-file-system';
+import { Alert, Platform, Share } from 'react-native';
+
+import type { AnalysisScores, LocalAnalysis } from './analysis-service';
+import { formatTraitName } from './analysis-service';
+
+export type ShareableAnalysisData = {
+  overallScore: number;
+  traitScores: AnalysisScores;
+  imageUrl?: string | null;
+  analysisType?: string;
+  recommendations?: string[];
+  overallMessage?: string;
+};
+
+/**
+ * Service for sharing analysis results
+ */
+export class ShareService {
+  /**
+   * Share analysis results with formatted text
+   */
+  static async shareAnalysisResults(
+    analysis: LocalAnalysis,
+    extractedScores: AnalysisScores,
+    imageUrl?: string | null,
+  ): Promise<void> {
+    try {
+      const shareData = await ShareService.prepareShareData({
+        overallScore: extractedScores.overall,
+        traitScores: extractedScores,
+        imageUrl,
+        analysisType: analysis.aiResults?.analysisType,
+        recommendations: analysis.aiResults?.recommendations,
+        overallMessage:
+          analysis.aiResults?.overallMessage || analysis.aiResults?.analysis, // Handle legacy field name
+      });
+
+      const result = await Share.share(shareData, {
+        dialogTitle: 'Share Analysis Results',
+        excludedActivityTypes: Platform.select({
+          ios: [
+            'com.apple.UIKit.activity.AssignToContact',
+            'com.apple.UIKit.activity.Print',
+          ],
+          default: undefined,
+        }),
+      });
+
+      if (result.action === Share.sharedAction) {
+        console.log('Analysis results shared successfully');
+      }
+    } catch (error) {
+      console.error('Error sharing analysis results:', error);
+      Alert.alert('Share Failed', 'Unable to share results. Please try again.');
+    }
+  }
+
+  /**
+   * Prepare shareable data with formatted text
+   */
+  private static async prepareShareData(data: ShareableAnalysisData): Promise<{
+    message: string;
+    url?: string;
+  }> {
+    const formattedText = ShareService.formatAnalysisText(data);
+
+    const shareData: { message: string; url?: string } = {
+      message: formattedText,
+    };
+
+    // Add image if available (for platforms that support it)
+    if (data.imageUrl && Platform.OS !== 'web') {
+      try {
+        // Verify the image is accessible
+        const fileInfo = await FileSystem.getInfoAsync(data.imageUrl);
+        if (fileInfo.exists) {
+          shareData.url = data.imageUrl;
+        }
+      } catch (error) {
+        console.warn('Could not attach image to share:', error);
+        // Continue without image
+      }
+    }
+
+    return shareData;
+  }
+
+  /**
+   * Format analysis results into readable text
+   */
+  private static formatAnalysisText(data: ShareableAnalysisData): string {
+    const { overallScore, traitScores, analysisType, recommendations } = data;
+
+    let text = '🔍 My Analysis Results\n\n';
+
+    // Overall score
+    text += `Overall Score: ${overallScore}/100\n`;
+    text += `${ShareService.getScoreLevelEmoji(overallScore)} ${ShareService.getScoreLevel(overallScore)}\n\n`;
+
+    // Overall message/feedback (if available)
+    if (data.overallMessage) {
+      text += `💬 Overall Assessment:\n${data.overallMessage}\n\n`;
+    }
+
+    // Individual trait scores
+    text += '📊 Trait Breakdown:\n';
+    Object.entries(traitScores)
+      .filter(([key]) => key !== 'overall')
+      .sort(([, a], [, b]) => b - a) // Sort by score descending
+      .forEach(([key, score]) => {
+        const formattedName = formatTraitName(key);
+        text += `• ${formattedName}: ${score}/100 ${ShareService.getScoreLevelEmoji(score)}\n`;
+      });
+
+    // Recommendations (if available)
+    if (recommendations && recommendations.length > 0) {
+      text += '\n💡 Key Recommendations:\n';
+      recommendations.slice(0, 3).forEach((rec, index) => {
+        text += `${index + 1}. ${rec}\n`;
+      });
+    }
+
+    // Analysis type context
+    if (analysisType) {
+      text += `\nAnalysis Type: ${analysisType}\n`;
+    }
+
+    text += '\n✨ Get your own analysis with ShipAppsFast!';
+
+    return text;
+  }
+
+  /**
+   * Get score level description
+   */
+  private static getScoreLevel(score: number): string {
+    if (score >= 80) return 'Excellent';
+    if (score >= 70) return 'Very Good';
+    if (score >= 60) return 'Good';
+    if (score >= 50) return 'Fair';
+    return 'Needs Improvement';
+  }
+
+  /**
+   * Get appropriate emoji for score level
+   */
+  private static getScoreLevelEmoji(score: number): string {
+    if (score >= 80) return '🌟';
+    if (score >= 70) return '💚';
+    if (score >= 60) return '💛';
+    if (score >= 50) return '🧡';
+    return '💙';
+  }
+
+  /**
+   * Share analysis results as a quick summary
+   */
+  static async shareQuickSummary(
+    overallScore: number,
+    topTrait: { name: string; score: number },
+  ): Promise<void> {
+    const text =
+      '🔍 Just completed my analysis!\n\n' +
+      `Overall Score: ${overallScore}/100 ${ShareService.getScoreLevelEmoji(overallScore)}\n` +
+      `Top Trait: ${topTrait.name} (${topTrait.score}/100)\n\n` +
+      '✨ Get your own analysis with ShipAppsFast!';
+
+    try {
+      await Share.share({ message: text });
+    } catch (error) {
+      console.error('Error sharing quick summary:', error);
+      Alert.alert('Share Failed', 'Unable to share. Please try again.');
+    }
+  }
+}