@umituz/react-native-ai-generation-content 1.90.2 → 1.90.4

package/src/domains/generation/infrastructure/couple-generation-builder/builder-couple-prompt.ts

@@ -0,0 +1,69 @@
+/**
+ * Couple Image Generation Builder - Prompt Processing
+ *
+ * Handles prompt refinement and final prompt creation
+ */
+
+import {
+  prependContext,
+  refinePromptForCouple,
+  createPhotorealisticPrompt,
+} from "../../../../infrastructure/utils/couple-input.util";
+import { logBuilderStep } from "./utils";
+import type { CoupleGenerationInputParams } from "./types";
+
+export interface CouplePromptResult {
+  prompt: string;
+  refinedPrompt: string;
+}
+
+/**
+ * Process and refine prompt for couple generation
+ */
+export function processCouplePrompt(
+  params: CoupleGenerationInputParams,
+  appearanceContext: string,
+  prefix: string = "[CoupleBuilder]",
+): CouplePromptResult {
+  const {
+    basePrompt,
+    customInstructions,
+    isCoupleMode,
+  } = params;
+
+  // 3. REFINE FOR COUPLE + PREPEND CONTEXT - Wardrobe mantığı
+  logBuilderStep(prefix, "STEP 3: REFINE & PREPEND CONTEXT", {
+    basePromptLength: basePrompt.length,
+    isCoupleMode
+  });
+
+  const refinedPrompt = prependContext(
+    refinePromptForCouple(basePrompt, isCoupleMode),
+    appearanceContext,
+  );
+
+  logBuilderStep(prefix, "Refined Prompt Result", {
+    refinedPromptLength: refinedPrompt.length,
+    refinedPromptPreview: refinedPrompt.substring(0, 300),
+  });
+
+  // 4. CREATE FINAL PROMPT - Photorealistic
+  logBuilderStep(prefix, "STEP 4: CREATE PHOTOREALISTIC PROMPT", {
+    isCouple: isCoupleMode,
+    hasCustomInstructions: !!customInstructions
+  });
+
+  const prompt = createPhotorealisticPrompt(refinedPrompt, {
+    isCouple: isCoupleMode,
+    customInstructions,
+  });
+
+  logBuilderStep(prefix, "Final Prompt Result", {
+    promptLength: prompt.length,
+    promptPreview: prompt.substring(0, 500),
+    hasCustomInstructions: !!customInstructions,
+    customInstructions,
+  });
+
+  return { prompt, refinedPrompt };
+}

package/src/domains/generation/infrastructure/couple-generation-builder/builder-couple-resolution.ts

@@ -0,0 +1,77 @@
+/**
+ * Couple Image Generation Builder - Input Resolution
+ *
+ * Handles target resolution and final input building
+ */
+
+import {
+  resolveCoupleInput,
+} from "../../../../infrastructure/utils/couple-input.util";
+import { logBuilderStep, logBuilderEnd } from "./utils";
+import type {
+  CoupleGenerationInputParams,
+  CoupleGenerationInput,
+} from "./types";
+
+/**
+ * Build final couple generation input with resolved target and parameters
+ */
+export function buildCoupleGenerationResult(
+  params: CoupleGenerationInputParams,
+  prompt: string,
+  prefix: string = "[CoupleBuilder]",
+): CoupleGenerationInput {
+  const {
+    partner1PhotoUri,
+    partner2PhotoUri,
+    isCoupleMode,
+    aspectRatio = "3:4",
+    strength,
+  } = params;
+
+  // 5. RESOLVE COUPLE INPUT - Doğru target ve image'lar
+  logBuilderStep(prefix, "STEP 5: RESOLVE COUPLE INPUT", {
+    partner1Uri: partner1PhotoUri,
+    partner2Uri: partner2PhotoUri,
+    isCoupleMode,
+    singleTarget: "p-image-edit/pruna",
+    coupleTarget: "p-image-edit/pruna"
+  });
+
+  const { target, imageUrls } = resolveCoupleInput(
+    partner1PhotoUri,
+    partner2PhotoUri,
+    isCoupleMode,
+    { model: "p-image-edit", providerId: "pruna" }, // Single target
+    { model: "p-image-edit", providerId: "pruna" }, // Couple target
+  );
+
+  logBuilderStep(prefix, "Target Resolution Result", {
+    targetModel: target.model,
+    targetProvider: target.providerId,
+    imageUrlsCount: imageUrls.length,
+    image1: imageUrls[0],
+    image2: imageUrls[1],
+  });
+
+  // 6. BUILD PARAMS - Wardrobe formatında
+  logBuilderStep(prefix, "STEP 6: BUILD PARAMS", {
+    prompt,
+    imageUrls,
+    aspectRatio,
+    strength,
+  });
+
+  logBuilderEnd(prefix);
+
+  return {
+    target,
+    prompt,
+    params: {
+      prompt,
+      image_urls: imageUrls,
+      aspect_ratio: aspectRatio,
+      ...(strength !== undefined && { strength }),
+    },
+  };
+}

package/src/domains/generation/infrastructure/couple-generation-builder/builder-couple.ts

@@ -0,0 +1,54 @@
+/**
+ * Couple Image Generation Builder - Couple Generation
+ *
+ * Merkezi couple generation input builder
+ */
+
+import type {
+  CoupleGenerationInputParams,
+  CoupleGenerationInput,
+} from "./types";
+import { logBuilderStart } from "./utils";
+import { prepareCoupleGeneration } from "./builder-couple-preparation";
+import { processCouplePrompt } from "./builder-couple-prompt";
+import { buildCoupleGenerationResult } from "./builder-couple-resolution";
+
+/**
+ * Merkezi couple generation input builder
+ *
+ * Wardrobe mantığını tüm couple generation için paylaştırır:
+ * 1. Appearance analysis (fotoğrafları analiz et)
+ * 2. Couple refinement (çift modu için iyileştir)
+ * 3. Context prepending (context'i prompt'a ekle)
+ * 4. Photorealistic prompt creation
+ * 5. Couple input resolution (doğru target ve image'lar)
+ *
+ * @param params - Generation parameters
+ * @returns Generation input with target, prompt, and params
+ */
+export async function buildCoupleGenerationInput(
+  params: CoupleGenerationInputParams,
+): Promise<CoupleGenerationInput> {
+  const prefix = "[CoupleBuilder]";
+
+  logBuilderStart(prefix, {
+    isCoupleMode: params.isCoupleMode,
+    basePromptLength: params.basePrompt.length,
+    aspectRatio: params.aspectRatio,
+    hasPartner2: !!params.partner2PhotoUri,
+    hasCustomInstructions: !!params.customInstructions,
+    hasStrength: params.strength !== undefined,
+    strength: params.strength,
+    partner1Uri: params.partner1PhotoUri,
+    partner2Uri: params.partner2PhotoUri,
+  });
+
+  // Phase 1: Prepare photo URIs and analyze appearance
+  const { appearanceContext } = await prepareCoupleGeneration(params, prefix);
+
+  // Phase 2: Process and refine prompt
+  const { prompt } = processCouplePrompt(params, appearanceContext, prefix);
+
+  // Phase 3: Build final result with resolved target
+  return buildCoupleGenerationResult(params, prompt, prefix);
+}

package/src/domains/generation/infrastructure/couple-generation-builder/builder-index.ts

@@ -0,0 +1,8 @@
+/**
+ * Couple Image Generation Builder - Main Builder Functions
+ *
+ * Merkezi couple generation input builder
+ */
+
+export { buildCoupleGenerationInput } from "./builder-couple";
+export { buildScenarioGenerationInput } from "./builder-scenario";

package/src/domains/generation/infrastructure/couple-generation-builder/builder-scenario.ts

@@ -0,0 +1,112 @@
+/**
+ * Couple Image Generation Builder - Scenario Generation
+ *
+ * Scenario generation için özel wrapper
+ */
+
+import {
+  resolveCoupleInput,
+  refinePromptForCouple,
+  prependContext,
+} from "../../../../infrastructure/utils/couple-input.util";
+import { getAppearanceContext } from "../../appearance-analysis";
+import type {
+  ScenarioGenerationInputParams,
+  CoupleGenerationInput,
+} from "./types";
+import { logBuilderStart, logBuilderStep, logBuilderEnd } from "./utils";
+
+/**
+ * Scenario generation için özel wrapper
+ *
+ * Senaryo aiPrompt'larını (zaten createPhotorealisticPrompt ile oluşturulmuş)
+ * Wardrobe mantığı ile birleştirir.
+ */
+export async function buildScenarioGenerationInput(
+  params: ScenarioGenerationInputParams,
+): Promise<CoupleGenerationInput> {
+
+  const {
+    partner1PhotoUri,
+    partner2PhotoUri,
+    isCoupleMode,
+    scenarioPrompt,
+  } = params;
+
+  logBuilderStart("[ScenarioBuilder]", {
+    isCoupleMode,
+    scenarioPromptLength: scenarioPrompt.length,
+    scenarioPromptPreview: scenarioPrompt.substring(0, 200),
+    partner1Uri: partner1PhotoUri,
+    partner2Uri: partner2PhotoUri,
+  });
+
+  // 1. GET PHOTO URIs
+  const photoUris =
+    isCoupleMode && partner2PhotoUri
+      ? [partner1PhotoUri, partner2PhotoUri]
+      : [partner1PhotoUri];
+
+  logBuilderStep("[ScenarioBuilder]", "STEP 1: PHOTO URIs", {
+    photoUrisCount: photoUris.length,
+  });
+
+  // 2. ANALYZE APPEARANCE
+  logBuilderStep("[ScenarioBuilder]", "STEP 2: APPEARANCE ANALYSIS");
+
+  const appearanceContext = await getAppearanceContext(
+    photoUris,
+    isCoupleMode,
+  );
+
+  logBuilderStep("[ScenarioBuilder]", "Appearance Analysis Result", {
+    contextLength: appearanceContext.length,
+    contextPreview: appearanceContext.length > 0 ? appearanceContext.substring(0, 150) : "No context (vision disabled)",
+  });
+
+  // 3. REFINE FOR COUPLE + PREPEND CONTEXT
+  logBuilderStep("[ScenarioBuilder]", "STEP 3: REFINE & PREPEND CONTEXT");
+
+  const refinedPrompt = refinePromptForCouple(scenarioPrompt, isCoupleMode);
+  const finalPrompt = prependContext(refinedPrompt, appearanceContext);
+
+  logBuilderStep("[ScenarioBuilder]", "Refined Prompt Result", {
+    refinedPromptLength: refinedPrompt.length,
+    finalPromptLength: finalPrompt.length,
+    finalPromptPreview: finalPrompt.substring(0, 300),
+  });
+
+  // 4. RESOLVE COUPLE INPUT
+  logBuilderStep("[ScenarioBuilder]", "STEP 4: RESOLVE COUPLE INPUT");
+
+  const { target, imageUrls } = resolveCoupleInput(
+    partner1PhotoUri,
+    partner2PhotoUri,
+    isCoupleMode,
+    { model: "p-image-edit", providerId: "pruna" }, // Single target
+    { model: "p-image-edit", providerId: "pruna" }, // Couple target
+  );
+
+  logBuilderStep("[ScenarioBuilder]", "Target Resolution Result", {
+    targetModel: target.model,
+    targetProvider: target.providerId,
+    imageUrlsCount: imageUrls.length,
+  });
+
+  // 5. BUILD PARAMS - Scenario formatında
+  logBuilderStep("[ScenarioBuilder]", "STEP 5: BUILD PARAMS", {
+    aspectRatio: "3:4"
+  });
+
+  logBuilderEnd("[ScenarioBuilder]");
+
+  return {
+    target,
+    prompt: finalPrompt,
+    params: {
+      prompt: finalPrompt,
+      image_urls: imageUrls,
+      aspect_ratio: "3:4",
+    },
+  };
+}

package/src/domains/generation/infrastructure/couple-generation-builder/builder.ts

@@ -0,0 +1,7 @@
+/**
+ * Couple Image Generation Builder - Main Builder Functions
+ *
+ * Merkezi couple generation input builder
+ */
+
+export { buildCoupleGenerationInput, buildScenarioGenerationInput } from "./builder-index";

package/src/domains/generation/infrastructure/couple-generation-builder/index.ts

@@ -0,0 +1,20 @@
+/**
+ * Couple Image Generation Builder
+ *
+ * Wardrobe'da kusursuz çalışan mantığı tüm couple generation için paylaştırır.
+ * Bu utility'yi tüm çift görüntü oluşturma işlemleri kullanır.
+ *
+ * Kullanım alanları:
+ * - Senaryo generation (Home couple images)
+ * - Wardrobe generation
+ * - Background generation
+ * - Art style generation
+ * - Mood filter generation
+ */
+
+export type {
+  CoupleGenerationInputParams,
+  CoupleGenerationInput,
+  ScenarioGenerationInputParams,
+} from "./types";
+export { buildCoupleGenerationInput, buildScenarioGenerationInput } from "./builder";

package/src/domains/generation/infrastructure/couple-generation-builder/types.ts

@@ -0,0 +1,44 @@
+/**
+ * Couple Image Generation Builder - Type Definitions
+ *
+ * Wardrobe'da kusursuz çalışan mantığı tüm couple generation için paylaştırır.
+ * Bu utility'yi tüm çift görüntü oluşturma işlemleri kullanır.
+ */
+
+import type { GenerationTargetLike } from "../../../../infrastructure/utils/couple-input.util";
+
+/**
+ * Couple generation input parameters
+ */
+export interface CoupleGenerationInputParams {
+  // Required params
+  partner1PhotoUri: string;
+  partner2PhotoUri: string | null;
+  isCoupleMode: boolean;
+  basePrompt: string; // Scenario prompt, wardrobe prompt, background prompt, etc.
+
+  // Optional params
+  customInstructions?: string;
+  aspectRatio?: string; // Default: "3:4"
+  strength?: number; // Optional strength for some operations
+}
+
+/**
+ * Couple generation result
+ */
+export interface CoupleGenerationInput {
+  target: GenerationTargetLike;
+  prompt: string;
+  params: Record<string, unknown>;
+}
+
+/**
+ * Scenario generation input parameters
+ */
+export interface ScenarioGenerationInputParams {
+  partner1PhotoUri: string;
+  partner2PhotoUri: string | null;
+  isCoupleMode: boolean;
+  scenarioPrompt: string; // Senaryo prompt'u (aiPrompt)
+  customInstructions?: string;
+}

package/src/domains/generation/infrastructure/couple-generation-builder/utils/builder-end-logger.ts

@@ -0,0 +1,18 @@
+/**
+ * Couple Image Generation Builder - End Logger
+ */
+
+const DEV = typeof __DEV__ !== "undefined" && __DEV__;
+
+/**
+ * Log builder end
+ */
+export function logBuilderEnd(prefix: string): void {
+  if (!DEV) return;
+
+  console.log(`${prefix} ========================================`);
+  console.log(`${prefix} ===== BUILD COUPLE GENERATION END =====`);
+  console.log(`${prefix} ========================================`);
+  console.log(`${prefix} Returning: { target, prompt, params }`);
+  console.log("");
+}

package/src/domains/generation/infrastructure/couple-generation-builder/utils/builder-start-logger.ts

@@ -0,0 +1,57 @@
+/**
+ * Couple Image Generation Builder - Start Logger
+ */
+
+import type { BuilderStartParams } from "./types";
+
+const DEV = typeof __DEV__ !== "undefined" && __DEV__;
+
+/**
+ * Log builder start with parameters
+ */
+export function logBuilderStart(
+  prefix: string,
+  params: BuilderStartParams
+): void {
+  if (!DEV) return;
+
+  console.log(`${prefix} ========================================`);
+  console.log(`${prefix} ===== BUILD COUPLE GENERATION START =====`);
+  console.log(`${prefix} ========================================`);
+  console.log(`${prefix} ===== INPUT PARAMS =====`);
+
+  if (params.isCoupleMode !== undefined) {
+    console.log(`${prefix} Is couple mode:`, params.isCoupleMode);
+  }
+  if (params.basePromptLength !== undefined) {
+    console.log(`${prefix} Base prompt length:`, params.basePromptLength);
+    console.log(`${prefix} Base prompt preview:`, params.basePromptLength.toString().substring(0, 200) + "...");
+  }
+  if (params.scenarioPromptLength !== undefined) {
+    console.log(`${prefix} Scenario prompt length:`, params.scenarioPromptLength);
+  }
+  if (params.scenarioPromptPreview !== undefined) {
+    console.log(`${prefix} Scenario prompt preview:`, params.scenarioPromptPreview);
+  }
+  if (params.aspectRatio !== undefined) {
+    console.log(`${prefix} Aspect ratio:`, params.aspectRatio);
+  }
+  if (params.hasPartner2 !== undefined) {
+    console.log(`${prefix} Has partner 2:`, params.hasPartner2);
+  }
+  if (params.hasCustomInstructions !== undefined) {
+    console.log(`${prefix} Has custom instructions:`, params.hasCustomInstructions);
+  }
+  if (params.hasStrength !== undefined) {
+    console.log(`${prefix} Has strength:`, params.hasStrength);
+  }
+  if (params.strength !== undefined) {
+    console.log(`${prefix} Strength value:`, params.strength);
+  }
+  if (params.partner1Uri !== undefined) {
+    console.log(`${prefix} Partner 1 URI:`, params.partner1Uri.substring(0, 80) + "...");
+  }
+  if (params.partner2Uri !== undefined) {
+    console.log(`${prefix} Partner 2 URI:`, params.partner2Uri.substring(0, 80) + "...");
+  }
+}

package/src/domains/generation/infrastructure/couple-generation-builder/utils/builder-step-logger.ts

@@ -0,0 +1,106 @@
+/**
+ * Couple Image Generation Builder - Step Logger
+ */
+
+import type { BuilderStepParams } from "./types";
+
+const DEV = typeof __DEV__ !== "undefined" && __DEV__;
+
+/**
+ * Log builder step with details
+ */
+export function logBuilderStep(
+  prefix: string,
+  stepName: string,
+  params: BuilderStepParams = {}
+): void {
+  if (!DEV) return;
+
+  console.log(`${prefix} ===== ${stepName} =====`);
+
+  if (params.photoUrisCount !== undefined) {
+    console.log(`${prefix} Photo URIs count:`, params.photoUrisCount);
+  }
+  if (params.photo1 !== undefined) {
+    console.log(`${prefix} Photo 1:`, params.photo1.substring(0, 60) + "...");
+  }
+  if (params.photo2 !== undefined) {
+    console.log(`${prefix} Photo 2:`, params.photo2.substring(0, 60) + "...");
+  }
+  if (params.photoCount !== undefined) {
+    console.log(`${prefix} Photo count:`, params.photoCount);
+  }
+  if (params.isCoupleMode !== undefined) {
+    console.log(`${prefix} Is couple mode:`, params.isCoupleMode);
+  }
+  if (params.basePromptLength !== undefined) {
+    console.log(`${prefix} Base prompt length:`, params.basePromptLength);
+  }
+  if (params.contextLength !== undefined) {
+    console.log(`${prefix} Appearance context length:`, params.contextLength);
+  }
+  if (params.contextPreview !== undefined) {
+    if (params.contextPreview.length > 0) {
+      console.log(`${prefix} Appearance context preview:`, params.contextPreview + "...");
+    } else {
+      console.log(`${prefix} ℹ️ No appearance context returned (vision disabled)`);
+    }
+  }
+  if (params.refinedPromptLength !== undefined) {
+    console.log(`${prefix} Refined prompt length:`, params.refinedPromptLength);
+  }
+  if (params.refinedPromptPreview !== undefined) {
+    console.log(`${prefix} Refined prompt preview:`, params.refinedPromptPreview + "...");
+  }
+  if (params.finalPromptLength !== undefined) {
+    console.log(`${prefix} Final prompt length:`, params.finalPromptLength);
+  }
+  if (params.finalPromptPreview !== undefined) {
+    console.log(`${prefix} Final prompt preview:`, params.finalPromptPreview + "...");
+  }
+  if (params.promptLength !== undefined) {
+    console.log(`${prefix} Prompt length:`, params.promptLength);
+  }
+  if (params.promptPreview !== undefined) {
+    console.log(`${prefix} Prompt preview:`, params.promptPreview + "...");
+  }
+  if (params.hasCustomInstructions !== undefined) {
+    console.log(`${prefix} Has custom instructions:`, params.hasCustomInstructions);
+  }
+  if (params.customInstructions !== undefined) {
+    console.log(`${prefix} Custom instructions:`, params.customInstructions);
+  }
+  if (params.partner1Uri !== undefined) {
+    console.log(`${prefix} Partner 1 URI:`, params.partner1Uri.substring(0, 50) + "...");
+  }
+  if (params.partner2Uri !== undefined) {
+    console.log(`${prefix} Partner 2 URI:`, params.partner2Uri ? params.partner2Uri.substring(0, 50) + "..." : null);
+  }
+  if (params.singleTarget !== undefined) {
+    console.log(`${prefix} Single target:`, params.singleTarget);
+  }
+  if (params.coupleTarget !== undefined) {
+    console.log(`${prefix} Couple target:`, params.coupleTarget);
+  }
+  if (params.targetModel !== undefined) {
+    console.log(`${prefix} Target model:`, params.targetModel);
+  }
+  if (params.targetProvider !== undefined) {
+    console.log(`${prefix} Target provider:`, params.targetProvider);
+  }
+  if (params.imageUrlsCount !== undefined) {
+    console.log(`${prefix} Image URLs count:`, params.imageUrlsCount);
+  }
+  if (params.image1 !== undefined) {
+    console.log(`${prefix} Image 1:`, params.image1.substring(0, 80) + "...");
+  }
+  if (params.image2 !== undefined) {
+    console.log(`${prefix} Image 2:`, params.image2?.substring(0, 80) + "...");
+  }
+  if (params.aspectRatio !== undefined) {
+    console.log(`${prefix} Aspect ratio:`, params.aspectRatio);
+  }
+  if (params.strength !== undefined) {
+    console.log(`${prefix} Strength:`, params.strength);
+  }
+}

package/src/domains/generation/infrastructure/couple-generation-builder/utils/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Couple Image Generation Builder - Utility Functions
+ */
+
+export { logBuilderStart } from "./builder-start-logger";
+export { logBuilderStep } from "./builder-step-logger";
+export { logBuilderEnd } from "./builder-end-logger";
+export type { BuilderStartParams, BuilderStepParams } from "./types";

package/src/domains/generation/infrastructure/couple-generation-builder/utils/types.ts

@@ -0,0 +1,49 @@
+/**
+ * Couple Image Generation Builder - Type Definitions
+ */
+
+export interface BuilderStartParams {
+  isCoupleMode?: boolean;
+  basePromptLength?: number;
+  scenarioPromptLength?: number;
+  aspectRatio?: string;
+  hasPartner2?: boolean;
+  hasCustomInstructions?: boolean;
+  hasStrength?: boolean;
+  strength?: number;
+  partner1Uri?: string;
+  partner2Uri?: string;
+  scenarioPromptPreview?: string;
+}
+
+export interface BuilderStepParams {
+  photoUrisCount?: number;
+  photo1?: string;
+  photo2?: string;
+  photoCount?: number;
+  isCoupleMode?: boolean;
+  basePromptLength?: number;
+  contextLength?: number;
+  contextPreview?: string;
+  refinedPromptLength?: number;
+  refinedPromptPreview?: string;
+  finalPromptLength?: number;
+  finalPromptPreview?: string;
+  promptLength?: number;
+  promptPreview?: string;
+  hasCustomInstructions?: boolean;
+  customInstructions?: string;
+  partner1Uri?: string;
+  partner2Uri?: string;
+  singleTarget?: string;
+  coupleTarget?: string;
+  targetModel?: string;
+  targetProvider?: string;
+  imageUrlsCount?: number;
+  image1?: string;
+  image2?: string;
+  prompt?: string;
+  imageUrls?: string[];
+  aspectRatio?: string;
+  strength?: number;
+}

package/src/domains/generation/infrastructure/couple-generation-builder/utils.ts

@@ -0,0 +1,8 @@
+/**
+ * Couple Image Generation Builder - Utility Functions
+ *
+ * Logging and helper functions for the couple generation builder
+ */
+
+export { logBuilderStart, logBuilderStep, logBuilderEnd } from "./utils/index";
+export type { BuilderStartParams, BuilderStepParams } from "./utils/types";