@umituz/react-native-ai-generation-content 1.89.33 → 1.89.35

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.89.33",
+  "version": "1.89.35",
   "description": "Provider-agnostic AI generation orchestration for React Native with result preview components",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/domains/generation/wizard/infrastructure/strategies/image-generation.strategy.ts

@@ -7,9 +7,10 @@ import type { WizardScenarioData } from "../../presentation/hooks/useWizardGener
 import type { WizardStrategy } from "./wizard-strategy.types";
 import { DEFAULT_STYLE_VALUE, IMAGE_PROCESSING_PROMPTS } from "./wizard-strategy.constants";
 import { extractPrompt, extractSelection } from "../utils";
-import { extractPhotosAsBase64 } from "./shared/photo-extraction.utils";
+import { extractPhotosAsBase64, extractPhotoUris } from "./shared/photo-extraction.utils";
 import { executeImageGeneration } from "./image-generation.executor";
 import type { WizardImageInput, CreateImageStrategyOptions } from "./image-generation.types";
+import { enhancePromptWithAnalysis } from "../../../infrastructure/appearance-analysis";
 
 
 // ============================================================================
@@ -20,6 +21,8 @@ export async function buildImageInput(
   wizardData: Record<string, unknown>,
   scenario: WizardScenarioData,
 ): Promise<WizardImageInput | null> {
+  // Extract photo URIs first (for couple refinement)
+  const photoUris = extractPhotoUris(wizardData);
   const photos = await extractPhotosAsBase64(wizardData);
 
   // Extract prompt with fallback to default
@@ -38,6 +41,20 @@ export async function buildImageInput(
   let finalPrompt = prompt;
   if (photos.length > 0) {
     finalPrompt = applyStyleEnhancements(prompt, wizardData);
+
+    // ✅ Apply couple refinement (same logic as Wardrobe)
+    // This ensures consistency across all couple generation scenarios
+    const isCoupleMode = photos.length >= 2;
+    finalPrompt = await enhancePromptWithAnalysis(finalPrompt, photoUris, isCoupleMode);
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[ImageStrategy] Prompt enhanced with couple refinement", {
+        photoCount: photos.length,
+        isCoupleMode,
+        originalPromptLength: prompt.length,
+        finalPromptLength: finalPrompt.length,
+      });
+    }
   }
 
   // Extract style for text-to-image

package/src/domains/generation/wizard/infrastructure/strategies/shared/photo-extraction.utils.ts

@@ -3,9 +3,11 @@
  * Shared photo extraction logic for wizard strategies
  *
  * Resize strategy:
- * - Small images (<300px):  scale UP to 300px minimum (AI provider requirement)
+ * - Small images (<768px):  scale UP to 768px minimum (good face preservation)
  * - Large images (>1536px): scale DOWN to 1536px maximum (reduces upload size ~10x)
  * - Normal images:          pass through unchanged
+ *
+ * IMPORTANT: 768px minimum ensures AI models have enough detail for face preservation
  */
 
 import { readFileAsBase64 } from "@umituz/react-native-design-system/filesystem";
@@ -14,7 +16,7 @@ import { Image } from "react-native";
 import { PHOTO_KEY_PREFIX } from "../wizard-strategy.constants";
 
 
-const MIN_IMAGE_DIMENSION = 300;
+const MIN_IMAGE_DIMENSION = 768;  // Minimum for good face preservation
 const MAX_IMAGE_DIMENSION = 1536;
 
 /**
@@ -28,7 +30,7 @@ function getImageSize(uri: string): Promise<{ width: number; height: number }> {
 
 /**
  * Ensure image is within optimal dimensions for AI generation.
- * - Too small (<300px): scale up (AI providers require minimum dimensions)
+ * - Too small (<768px): scale up (good face preservation)
  * - Too large (>1536px): scale down (reduces upload size, prevents timeouts)
  * - Within range: return as-is
  */
@@ -37,49 +39,85 @@ async function ensureOptimalSize(uri: string): Promise<string> {
     const { width, height } = await getImageSize(uri);
     const maxDim = Math.max(width, height);
 
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[PhotoExtraction] Analyzing image", {
+        originalDimensions: `${width}x${height}`,
+        maxDim,
+        minDim: Math.min(width, height),
+        isTooSmall: width < MIN_IMAGE_DIMENSION || height < MIN_IMAGE_DIMENSION,
+        isTooLarge: maxDim > MAX_IMAGE_DIMENSION,
+      });
+    }
+
     // Already within optimal range
     if (width >= MIN_IMAGE_DIMENSION && height >= MIN_IMAGE_DIMENSION && maxDim <= MAX_IMAGE_DIMENSION) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[PhotoExtraction] Image already optimal, skipping resize", {
+          dimensions: `${width}x${height}`,
+          minRequired: MIN_IMAGE_DIMENSION,
+          maxAllowed: MAX_IMAGE_DIMENSION,
+        });
+      }
       return uri;
     }
 
     let newWidth: number;
     let newHeight: number;
+    let direction: string;
 
     if (maxDim > MAX_IMAGE_DIMENSION) {
       // Scale DOWN — largest dimension becomes MAX_IMAGE_DIMENSION
       const scale = MAX_IMAGE_DIMENSION / maxDim;
       newWidth = Math.round(width * scale);
       newHeight = Math.round(height * scale);
+      direction = "down";
     } else {
       // Scale UP — smallest dimension becomes MIN_IMAGE_DIMENSION
       const scale = Math.max(MIN_IMAGE_DIMENSION / width, MIN_IMAGE_DIMENSION / height);
       newWidth = Math.ceil(width * scale);
       newHeight = Math.ceil(height * scale);
+      direction = "up";
     }
 
+    const compressQuality = maxDim > MAX_IMAGE_DIMENSION ? 0.8 : 1.0;  // Lossless for scale-up
+
     if (typeof __DEV__ !== "undefined" && __DEV__) {
-      const direction = maxDim > MAX_IMAGE_DIMENSION ? "down" : "up";
       console.log(`[PhotoExtraction] Resizing ${direction}`, {
         from: `${width}x${height}`,
         to: `${newWidth}x${newHeight}`,
+        scaleChange: `${((Math.max(newWidth, newHeight) / maxDim - 1) * 100).toFixed(0)}%`,
+        compressQuality,
       });
     }
 
     const result = await manipulateAsync(uri, [{ resize: { width: newWidth, height: newHeight } }], {
       format: SaveFormat.JPEG,
-      compress: maxDim > MAX_IMAGE_DIMENSION ? 0.8 : 0.9,
+      compress: compressQuality,
     });
 
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[PhotoExtraction] Resize complete", {
+        original: `${width}x${height}`,
+        resized: `${newWidth}x${newHeight}`,
+        action: direction,
+        quality: compressQuality === 1.0 ? "lossless" : `${compressQuality * 100}%`,
+      });
+    }
+
     return result.uri;
-  } catch {
+  } catch (error) {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.error("[PhotoExtraction] Resize failed, using original", error);
+    }
     return uri;
   }
 }
 
 /**
  * Extracts photo URIs from wizard data
+ * Exported for use in other strategies (e.g., couple refinement)
  */
-function extractPhotoUris(wizardData: Record<string, unknown>): string[] {
+export function extractPhotoUris(wizardData: Record<string, unknown>): string[] {
   const photoKeys = Object.keys(wizardData)
     .filter((k) => k.includes(PHOTO_KEY_PREFIX))
     .sort();
@@ -108,18 +146,27 @@ export async function extractPhotosAsBase64(
   enableDebugLogs = false,
 ): Promise<string[]> {
   if (enableDebugLogs && typeof __DEV__ !== "undefined" && __DEV__) {
-    console.log("[PhotoExtraction] Starting extraction", {
+    console.log("[PhotoExtraction] >>> extractPhotosAsBase64 START", {
       wizardDataKeys: Object.keys(wizardData),
+      photoKeyPrefix: PHOTO_KEY_PREFIX,
+      minDimension: MIN_IMAGE_DIMENSION,
+      maxDimension: MAX_IMAGE_DIMENSION,
     });
   }
 
   const photoUris = extractPhotoUris(wizardData);
 
   if (enableDebugLogs && typeof __DEV__ !== "undefined" && __DEV__) {
-    console.log("[PhotoExtraction] Found photo URIs", { count: photoUris.length });
+    console.log("[PhotoExtraction] Photo URIs extracted", {
+      count: photoUris.length,
+      keys: Object.keys(wizardData).filter(k => k.includes(PHOTO_KEY_PREFIX)),
+    });
   }
 
   if (photoUris.length === 0) {
+    if (enableDebugLogs && typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[PhotoExtraction] No photos found, returning empty array");
+    }
     return [];
   }
 
@@ -127,11 +174,29 @@ export async function extractPhotosAsBase64(
   const results = await Promise.allSettled(
     photoUris.map(async (uri, index) => {
       try {
+        if (enableDebugLogs && typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log(`[PhotoExtraction] Processing photo ${index + 1}/${photoUris.length}`, {
+            uri: uri.substring(0, 50) + "...",
+          });
+        }
+
         const optimizedUri = await ensureOptimalSize(uri);
-        return await readFileAsBase64(optimizedUri);
+        const base64 = await readFileAsBase64(optimizedUri);
+
+        if (enableDebugLogs && typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log(`[PhotoExtraction] Photo ${index + 1} processed`, {
+            sizeKB: (base64.length / 1024).toFixed(1),
+            originalUri: uri.substring(0, 30) + "...",
+          });
+        }
+
+        return base64;
       } catch (error) {
         if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.error(`[PhotoExtraction] Failed to read photo ${index}:`, error);
+          console.error(`[PhotoExtraction] ❌ Failed to process photo ${index + 1}:`, {
+            uri: uri.substring(0, 50) + "...",
+            error: error instanceof Error ? error.message : String(error),
+          });
         }
         return null;
       }
@@ -143,15 +208,21 @@ export async function extractPhotosAsBase64(
     .map((result) => (result.status === "fulfilled" ? result.value : null))
     .filter((photo): photo is string => typeof photo === "string" && photo.length > 0);
 
+  const failedCount = results.filter((r) => r.status === "rejected").length;
+
   if (enableDebugLogs && typeof __DEV__ !== "undefined" && __DEV__) {
-    const failedCount = results.filter((r) => r.status === "rejected").length;
-    console.log("[PhotoExtraction] Converted photos", {
+    console.log("[PhotoExtraction] <<< extractPhotosAsBase64 COMPLETE", {
       total: photoUris.length,
-      valid: validPhotos.length,
+      successful: validPhotos.length,
       failed: failedCount,
-      sizes: validPhotos.map((p) => `${(p.length / 1024).toFixed(1)}KB`),
+      sizes: validPhotos.map((p, i) => `Photo ${i + 1}: ${(p.length / 1024).toFixed(1)}KB`),
+      totalSizeMB: ((validPhotos.reduce((sum, p) => sum + p.length, 0) / 1024 / 1024).toFixed(2)),
     });
   }
 
+  if (failedCount > 0 && typeof __DEV__ !== "undefined" && __DEV__) {
+    console.warn(`[PhotoExtraction] ⚠️ ${failedCount} photo(s) failed to process`);
+  }
+
   return validPhotos;
 }