studio-lumiere-cli 0.1.0

package/src/config/options.ts

@@ -0,0 +1,15 @@
+export {
+  ETHNICITIES,
+  ETHNICITY_REGIONS,
+  SKIN_TONES,
+  HAIR_COLORS,
+  BACKGROUNDS,
+  BACKGROUND_TYPES,
+  VIBES,
+  RESOLUTIONS,
+  OCCASIONS,
+  getRandomLuxuryInterior,
+  getStylePoolForTemplate,
+  isMuseEnabledTemplate,
+  isVideoEnabledTemplate
+} from "./constants.js";

package/src/config/templates.ts

@@ -0,0 +1,4 @@
+import { TEMPLATES } from "./constants.js";
+
+export { TEMPLATES };
+export const TEMPLATE_MAP = new Map(TEMPLATES.map((t) => [t.id, t]));

package/src/config/tiredGirl.ts

@@ -0,0 +1,11 @@
+import { Option } from "../types.js";
+
+export const TIRED_GIRL_STYLES: Option[] = [
+  { id: "tired", name: "Tired", value: "slightly tired, soft under-eye shadows, relaxed expression, end-of-day fatigue" },
+  { id: "morning", name: "Morning", value: "freshly awake, gentle morning light, calm sleepy energy" },
+  { id: "no_makeup", name: "No Makeup", value: "completely bare faced, no makeup, natural skin texture" },
+  { id: "crazy_hair", name: "Crazy Hair", value: "messy, unstyled hair, a bit wild and uncombed" },
+  { id: "pyjama", name: "Pyjama", value: "cozy pajamas or loungewear, relaxed home vibe" }
+];
+
+export const TIRED_GIRL_STYLE_MAP = new Map(TIRED_GIRL_STYLES.map((s) => [s.id, s]));

package/src/image/annotate.ts

@@ -0,0 +1,139 @@
+import sharp from "sharp";
+import { TextOverlayOptions, TextPosition } from "../types.js";
+
+const DEFAULT_FONT = "Montserrat";
+
+const getTextAnchor = (position: TextPosition): { anchor: string; align: string } => {
+  if (position.endsWith("left")) return { anchor: "start", align: "start" };
+  if (position.endsWith("right")) return { anchor: "end", align: "end" };
+  return { anchor: "middle", align: "middle" };
+};
+
+const wrapText = (text: string, maxChars: number): string[] => {
+  if (maxChars <= 0) return [text];
+  const words = text.split(/\s+/);
+  const lines: string[] = [];
+  let line = "";
+  for (const word of words) {
+    const candidate = line ? `${line} ${word}` : word;
+    if (candidate.length > maxChars) {
+      if (line) lines.push(line);
+      line = word;
+    } else {
+      line = candidate;
+    }
+  }
+  if (line) lines.push(line);
+  return lines;
+};
+
+const positionCoords = (
+  position: TextPosition,
+  width: number,
+  height: number,
+  padding: number,
+  extraOffset: number
+): { x: number; y: number; baseline: string } => {
+  switch (position) {
+    case "top-left":
+      return { x: padding, y: padding, baseline: "hanging" };
+    case "top-right":
+      return { x: width - padding, y: padding, baseline: "hanging" };
+    case "bottom-left":
+      return { x: padding, y: height - padding - extraOffset, baseline: "baseline" };
+    case "bottom-right":
+      return { x: width - padding, y: height - padding - extraOffset, baseline: "baseline" };
+    case "bottom-center":
+      return { x: width / 2, y: height - padding - extraOffset, baseline: "baseline" };
+    case "bottom-center-high":
+      return { x: width / 2, y: height - padding - extraOffset, baseline: "baseline" };
+    case "center":
+      return { x: width / 2, y: height / 2, baseline: "middle" };
+    case "top-center":
+    default:
+      return { x: width / 2, y: padding, baseline: "hanging" };
+  }
+};
+
+export const annotateImage = async (
+  inputPath: string,
+  outputPath: string,
+  text: string,
+  options: TextOverlayOptions = {}
+): Promise<void> => {
+  const image = sharp(inputPath);
+  const metadata = await image.metadata();
+  const width = metadata.width ?? 0;
+  const height = metadata.height ?? 0;
+  if (!width || !height) {
+    throw new Error("Unable to read image dimensions for annotation.");
+  }
+
+  const fontFamily = options.fontFamily ?? DEFAULT_FONT;
+  const fontSize = options.fontSize ?? Math.round(Math.min(width, height) * 0.05);
+  const fontWeight = options.fontWeight ?? 700;
+  const color = options.color ?? "#FFFFFF";
+  const strokeColor = options.strokeColor ?? "rgba(0,0,0,0.6)";
+  const strokeWidth = options.strokeWidth ?? Math.max(2, Math.round(fontSize * 0.08));
+  const banner = options.banner ?? false;
+  const bannerColor = options.bannerColor ?? "rgba(0,0,0,0.45)";
+  const bannerPadding = options.bannerPadding ?? Math.round(fontSize * 0.6);
+  const bannerRadius = options.bannerRadius ?? Math.round(fontSize * 0.4);
+  const position = options.position ?? "top-center";
+  const padding = options.padding ?? Math.round(fontSize * 0.8);
+  const maxWidthRatio = options.maxWidthRatio ?? 0.85;
+
+  const maxChars = Math.floor((width * maxWidthRatio) / (fontSize * 0.6));
+  const lines = wrapText(text, maxChars);
+  const lineHeight = Math.round(fontSize * 1.2);
+
+  const extraOffset = position === "bottom-center-high" ? Math.round(fontSize * 1.25) : 0;
+  let { x, y, baseline } = positionCoords(position, width, height, padding, extraOffset);
+  const { anchor } = getTextAnchor(position);
+
+  const svgLines = lines
+    .map((line, index) => {
+      const dy = index === 0 ? 0 : lineHeight;
+      return `<tspan x="${x}" dy="${dy}">${line}</tspan>`;
+    })
+    .join("");
+
+  const totalTextHeight = lineHeight * lines.length;
+  const textBlockWidth = Math.min(width * maxWidthRatio, width - padding * 2);
+  const bannerWidth = textBlockWidth + bannerPadding * 2;
+  const bannerHeight = totalTextHeight + bannerPadding * 2;
+  const bannerX = position.endsWith("left")
+    ? padding
+    : position.endsWith("right")
+      ? width - padding - bannerWidth
+      : (width - bannerWidth) / 2;
+  const bannerY =
+    position.startsWith("bottom")
+      ? height - padding - bannerHeight - extraOffset
+      : position === "center"
+        ? (height - bannerHeight) / 2
+        : padding;
+
+  const bannerRect = banner
+    ? `<rect x="${bannerX}" y="${bannerY}" width="${bannerWidth}" height="${bannerHeight}" rx="${bannerRadius}" ry="${bannerRadius}" fill="${bannerColor}" />`
+    : "";
+
+  if (banner) {
+    x = bannerX + bannerWidth / 2;
+    y = bannerY + bannerHeight / 2 - (totalTextHeight - lineHeight) / 2;
+    baseline = "middle";
+  }
+
+  const svg = `
+<svg width="${width}" height="${height}">
+  <style>
+    .title { font-family: '${fontFamily}', 'Poppins', 'Arial Black', Arial, sans-serif; font-size: ${fontSize}px; font-weight: ${fontWeight}; fill: ${color}; text-anchor: ${anchor}; paint-order: stroke fill; stroke: ${strokeColor}; stroke-width: ${strokeWidth}px; }
+  </style>
+  ${bannerRect}
+  <text x="${x}" y="${y}" dominant-baseline="${baseline}" class="title">${svgLines}</text>
+</svg>`;
+
+  await sharp(inputPath)
+    .composite([{ input: Buffer.from(svg), top: 0, left: 0 }])
+    .toFile(outputPath);
+};

package/src/image/grid.ts

@@ -0,0 +1,58 @@
+import sharp from "sharp";
+import path from "node:path";
+import { GridOptions } from "../types.js";
+
+export const createImageGrid = async (
+  inputPaths: string[],
+  outputPath: string,
+  options: GridOptions
+): Promise<void> => {
+  const columns = options.columns;
+  const rows = options.rows;
+  if (columns <= 0 || rows <= 0) throw new Error("Grid columns/rows must be positive.");
+
+  const padding = options.padding ?? 20;
+  const background = options.background ?? "#000000";
+
+  const metas = await Promise.all(inputPaths.map((p) => sharp(p).metadata()));
+  const widths = metas.map((m) => m.width ?? 0);
+  const heights = metas.map((m) => m.height ?? 0);
+
+  const tileWidth = options.tileWidth ?? Math.max(...widths);
+  const tileHeight = options.tileHeight ?? Math.max(...heights);
+
+  const canvasWidth = columns * tileWidth + (columns + 1) * padding;
+  const canvasHeight = rows * tileHeight + (rows + 1) * padding;
+
+  const composites: sharp.OverlayOptions[] = [];
+
+  for (let index = 0; index < rows * columns; index += 1) {
+    const input = inputPaths[index];
+    if (!input) break;
+    const row = Math.floor(index / columns);
+    const col = index % columns;
+
+    const left = padding + col * (tileWidth + padding);
+    const top = padding + row * (tileHeight + padding);
+
+    const resized = await sharp(input)
+      .resize(tileWidth, tileHeight, {
+        fit: "contain",
+        background
+      })
+      .toBuffer();
+
+    composites.push({ input: resized, top, left });
+  }
+
+  await sharp({
+    create: {
+      width: canvasWidth,
+      height: canvasHeight,
+      channels: 3,
+      background
+    }
+  })
+    .composite(composites)
+    .toFile(outputPath);
+};

package/src/index.ts

@@ -0,0 +1,27 @@
+export * from "./types.js";
+export { generateImages } from "./pipelines/generateImages.js";
+export { refineImage } from "./pipelines/refineImage.js";
+export { upscaleImage } from "./pipelines/upscaleImage.js";
+export { generateTiredGirl } from "./pipelines/generateTiredGirl.js";
+export { createMuse, generateMuseVariations } from "./pipelines/createMuse.js";
+export { generateVideo } from "./pipelines/generateVideo.js";
+export { annotateImage } from "./image/annotate.js";
+export { createImageGrid } from "./image/grid.js";
+export { TEMPLATES, TEMPLATE_MAP } from "./config/templates.js";
+export {
+  ETHNICITIES,
+  ETHNICITY_REGIONS,
+  SKIN_TONES,
+  HAIR_COLORS,
+  BACKGROUNDS,
+  BACKGROUND_TYPES,
+  VIBES,
+  RESOLUTIONS,
+  OCCASIONS,
+  getRandomLuxuryInterior,
+  getStylePoolForTemplate,
+  isMuseEnabledTemplate,
+  isVideoEnabledTemplate
+} from "./config/options.js";
+export { TIRED_GIRL_STYLES, TIRED_GIRL_STYLE_MAP } from "./config/tiredGirl.js";
+

package/src/pipelines/createMuse.ts

@@ -0,0 +1,76 @@
+import path from "node:path";
+import { GeminiClient } from "../clients/geminiClient.js";
+import { LumiereConfig, CreateMuseRequest, CreateMuseResult, MuseRecord } from "../types.js";
+import { readImageAsPart, resolveOutputDir, saveBase64Image, writeJson } from "../storage/files.js";
+import { addMuse } from "../storage/museStore.js";
+
+const STYLE_HINTS = [
+  "Change pose and posture dramatically.",
+  "Change hair styling and wardrobe while keeping the same person.",
+  "Use a different simple studio background.",
+  "Shift lighting direction for a new mood.",
+  "Vary the camera angle slightly for a new perspective."
+];
+
+const variationPrompt = (styleHint: string) => `Generate exactly one chest-up portrait of this person.\n\nRules:\n- Output a single image only. No collages or grids.\n- Keep the exact same person (face, features, ethnicity, skin tone).\n- Change pose, hair, and wardrobe. ${styleHint}\n- Use a new simple background.\n- Do NOT include the jewelry from the source image. Use no jewelry or different jewelry only.\n`;
+
+export const generateMuseVariations = async (
+  config: LumiereConfig,
+  sourceImage: string,
+  count: number,
+  outputDir: string
+): Promise<string[]> => {
+  const client = new GeminiClient(config);
+  const imagePart = await readImageAsPart(sourceImage);
+  const outputs: string[] = [];
+
+  for (let i = 0; i < count; i += 1) {
+    const hint = STYLE_HINTS[i % STYLE_HINTS.length];
+    const images = await client.generateImage({
+      parts: [{ text: variationPrompt(hint) }, imagePart],
+      aspectRatio: "3:4",
+      imageSize: "2K"
+    });
+
+    const outputPath = path.join(outputDir, `variation_${i + 1}.png`);
+    await saveBase64Image(images[0], outputPath);
+    outputs.push(outputPath);
+  }
+
+  return outputs;
+};
+
+export const createMuse = async (
+  config: LumiereConfig,
+  request: CreateMuseRequest
+): Promise<CreateMuseResult> => {
+  const outputDir = resolveOutputDir(request.outputDir ?? config.outputDir, "muses");
+  const variationCount = request.variations ?? 3;
+
+  const variationPaths = await generateMuseVariations(
+    config,
+    request.sourceImage,
+    variationCount,
+    outputDir
+  );
+
+  const museImages = variationPaths.slice(0, 3);
+  if (museImages.length < 3) {
+    throw new Error("Muse creation requires at least 3 variations.");
+  }
+
+  const muse: MuseRecord = {
+    id: `muse_${Date.now()}`,
+    name: request.name,
+    imagePaths: museImages,
+    createdAt: new Date().toISOString()
+  };
+
+  await addMuse(request.outputDir ?? config.outputDir, muse);
+
+  const logPath = path.join(outputDir, "muse.json");
+  await writeJson(logPath, { muse, variationPaths });
+
+  return { muse, variationPaths, logPath };
+};
+

package/src/pipelines/generateImages.ts

@@ -0,0 +1,203 @@
+import path from "node:path";
+import { GeminiClient } from "../clients/geminiClient.js";
+import { LumiereConfig, GenerationRequest, GenerationResult } from "../types.js";
+import { buildLLMPrompt, buildSystemInstruction } from "../prompt/buildPrompt.js";
+import { readImageAsPart, resolveOutputDir, saveBase64Image, writeJson } from "../storage/files.js";
+import { getMuseById } from "../storage/museStore.js";
+import { getStylePoolForTemplate } from "../config/constants.js";
+import {
+  getTemplate,
+  resolveBackground,
+  resolveBackgroundType,
+  resolveEthnicity,
+  resolveHairColor,
+  resolveOccasion,
+  resolveResolution,
+  resolveSkinTone,
+  resolveTemplateOption,
+  resolveVibe
+} from "./resolve.js";
+
+export const generateImages = async (
+  config: LumiereConfig,
+  request: GenerationRequest
+): Promise<GenerationResult> => {
+  const client = new GeminiClient(config);
+  const outputDir = resolveOutputDir(request.outputDir ?? config.outputDir, "generations");
+
+  const template = getTemplate(request.selections.templateId);
+  const detail = resolveTemplateOption(template, request.selections.detailId, "primary");
+  const secondaryDetail = resolveTemplateOption(template, request.selections.secondaryDetailId, "secondary");
+  const tertiaryDetail = resolveTemplateOption(template, request.selections.tertiaryDetailId, "tertiary");
+  const ethnicity = resolveEthnicity(request.selections.ethnicityId);
+  const skinTone = resolveSkinTone(request.selections.skinToneId);
+  const hairColor = resolveHairColor(request.selections.hairColorId);
+  const background = resolveBackground(request.selections.backgroundId);
+  const backgroundType = resolveBackgroundType(request.selections.backgroundTypeId);
+  const vibe = resolveVibe(request.selections.vibeId);
+  const resolution = resolveResolution(request.selections.resolutionId);
+  const occasion = resolveOccasion(request.selections.occasionId);
+
+  const quantity = request.quantity ?? 1;
+  const imageParts = await Promise.all(request.inputImages.map((file: string) => readImageAsPart(file)));
+
+  let museImageParts: Array<{ inlineData: { mimeType: string; data: string } }> | undefined;
+  let museId = request.museId;
+
+  if (request.museImagePaths && request.museImagePaths.length > 0) {
+    museImageParts = await Promise.all(request.museImagePaths.map((file: string) => readImageAsPart(file)));
+  } else if (museId) {
+    const muse = await getMuseById(request.outputDir ?? config.outputDir, museId);
+    if (!muse) throw new Error(`Muse not found: ${museId}`);
+    museImageParts = await Promise.all(muse.imagePaths.map((file: string) => readImageAsPart(file)));
+  }
+
+  const isFloating = template.id === "floating_minimal";
+  const isFlatlay = template.id === "flatlay_creative";
+  const isHandModel = template.id === "hand_model";
+  const isMuseumExhibit = template.id === "museum_exhibit";
+  const isRomanticMood = template.id === "romantic_mood";
+  const skipEthnicity = !!museImageParts || isHandModel || isFloating || isFlatlay || isMuseumExhibit || isRomanticMood;
+
+  const stylePool = getStylePoolForTemplate(template.id);
+  const shuffledHints = stylePool.length > 0 ? [...stylePool].sort(() => 0.5 - Math.random()) : [];
+
+  const basePrompt = buildLLMPrompt(
+    template,
+    detail,
+    secondaryDetail,
+    tertiaryDetail,
+    skipEthnicity ? undefined : ethnicity,
+    skinTone,
+    hairColor,
+    background,
+    backgroundType,
+    vibe,
+    request.inputImages.length,
+    occasion,
+    false,
+    undefined
+  );
+
+  const systemInstruction = buildSystemInstruction(template, ethnicity);
+
+  const outputs: string[] = [];
+  let enhancedPrompt = "";
+
+  for (let i = 0; i < quantity; i += 1) {
+    const styleHint = request.styleHint ?? (shuffledHints.length > 0 ? shuffledHints[i % shuffledHints.length] : undefined);
+    const promptForImage = buildLLMPrompt(
+      template,
+      detail,
+      secondaryDetail,
+      tertiaryDetail,
+      skipEthnicity ? undefined : ethnicity,
+      skinTone,
+      hairColor,
+      background,
+      backgroundType,
+      vibe,
+      request.inputImages.length,
+      occasion,
+      false,
+      styleHint
+    );
+
+    let perImagePrompt = promptForImage;
+    if (request.enhancePrompt ?? true) {
+      try {
+        const enhanceParts = [
+          ...imageParts.map((part) => ({
+            inlineData: {
+              data: part.inlineData.data,
+              mimeType: part.inlineData.mimeType
+            }
+          })),
+          { text: promptForImage }
+        ];
+        perImagePrompt = await client.generateEnhancedPrompt({
+          parts: enhanceParts,
+          systemInstruction
+        });
+      } catch {
+        const ethnicityFallback = (ethnicity && ethnicity.id !== "none") ? ethnicity.value : "Professional female model";
+        perImagePrompt = `${template.basePrompt}. ${ethnicityFallback}, shot on Kodak Portra 400, soft film grain, natural light, peach fuzz. Wearing the specific jewelry item shown. No fake sparkles.`;
+      }
+    }
+
+    perImagePrompt = `${perImagePrompt} Ensure authenticity and high-end editorial aesthetic. IMPORTANT: Add slight film grain and micro-contrast.`;
+
+    if (museImageParts) {
+      perImagePrompt = `
+    ${perImagePrompt}
+
+    CRITICAL MODEL CONSISTENCY REQUIREMENT:
+    The last 3 images provided are reference images of a specific model (the "Muse").
+    The model in the generated image MUST match this Muse reference exactly.
+
+    **STRICT FORMATTING RULE**:
+    - Output exactly ONE single, unified photograph.
+    - ABSOLUTELY NO collages, NO grids, and NO split screens.
+    - Even though 3 reference images are provided, the final result must be a single shot of the person wearing the jewelry.
+
+    Use the Muse reference images to ensure consistency in:
+    - Exact facial features and structure
+    - Skin tone and texture
+    - Overall appearance and aesthetic
+    - The model should look like the SAME PERSON as in the Muse reference images
+
+    This is essential for brand consistency - the generated model must be recognizable
+    as the same person shown in the Muse reference images.
+  `;
+    }
+
+    const parts: Array<{ text?: string; inlineData?: { data: string; mimeType: string } }> = [
+      ...imageParts.map((part) => ({
+        inlineData: {
+          data: part.inlineData.data,
+          mimeType: part.inlineData.mimeType
+        }
+      }))
+    ];
+    if (museImageParts) {
+      parts.push(
+        ...museImageParts.map((part) => ({
+          inlineData: {
+            data: part.inlineData.data,
+            mimeType: part.inlineData.mimeType
+          }
+        }))
+      );
+    }
+    parts.push({ text: perImagePrompt });
+    const images = await client.generateImage({
+      parts,
+      aspectRatio: resolution.aspectRatio,
+      imageSize: "2K"
+    });
+
+    const imagePath = path.join(outputDir, `image_${i + 1}.png`);
+    await saveBase64Image(images[0], imagePath);
+    outputs.push(imagePath);
+
+    enhancedPrompt = perImagePrompt;
+  }
+
+  const logPath = path.join(outputDir, "generation.json");
+  await writeJson(logPath, {
+    template: template.id,
+    selections: request.selections,
+    quantity,
+    prompt: basePrompt,
+    enhancedPrompt,
+    outputs
+  });
+
+  return {
+    prompt: basePrompt,
+    enhancedPrompt,
+    outputImages: outputs,
+    logPath
+  };
+};
+

package/src/pipelines/generateTiredGirl.ts

@@ -0,0 +1,86 @@
+import path from "node:path";
+import { GeminiClient } from "../clients/geminiClient.js";
+import { LumiereConfig, TiredGirlRequest, TiredGirlResult } from "../types.js";
+import { readImageAsPart, resolveOutputDir, saveBase64Image, writeJson } from "../storage/files.js";
+import { getMuseById } from "../storage/museStore.js";
+import { resolveTiredGirlStyles, buildTiredGirlPrompt } from "../prompt/tiredGirlPrompt.js";
+
+export const generateTiredGirl = async (
+  config: LumiereConfig,
+  request: TiredGirlRequest
+): Promise<TiredGirlResult> => {
+  const client = new GeminiClient(config);
+  const outputDir = resolveOutputDir(request.outputDir ?? config.outputDir, "tired_girl");
+
+  let referenceParts: Array<{ inlineData: { data: string; mimeType: string } }> = [];
+  let hasMuse = false;
+
+  if (request.museId) {
+    const muse = await getMuseById(request.outputDir ?? config.outputDir, request.museId);
+    if (!muse) throw new Error(`Muse not found: ${request.museId}`);
+    referenceParts = await Promise.all(muse.imagePaths.map((file) => readImageAsPart(file)));
+    hasMuse = true;
+  } else if (request.inputImage) {
+    referenceParts = [await readImageAsPart(request.inputImage)];
+  } else {
+    throw new Error("Either museId or inputImage is required for tired_girl generation.");
+  }
+
+  const quantity = request.quantity ?? 1;
+  const styles = resolveTiredGirlStyles(request.styleIds, quantity);
+
+  const outputs: string[] = [];
+  const prompts: string[] = [];
+
+  for (let i = 0; i < quantity; i += 1) {
+    const style = styles[i % styles.length];
+    const userPrompt = buildTiredGirlPrompt(style, hasMuse);
+
+    const enhanceParts = [
+      ...referenceParts.map((part) => ({
+        inlineData: {
+          data: part.inlineData.data,
+          mimeType: part.inlineData.mimeType
+        }
+      })),
+      { text: userPrompt }
+    ];
+
+    const enhanced = await client.generateEnhancedPrompt({
+      parts: enhanceParts,
+      systemInstruction: "You are a world-class portrait photographer. Follow all jewelry removal constraints strictly."
+    });
+
+    const generationParts: Array<{ text?: string; inlineData?: { data: string; mimeType: string } }> = [
+      ...referenceParts.map((part) => ({
+        inlineData: {
+          data: part.inlineData.data,
+          mimeType: part.inlineData.mimeType
+        }
+      })),
+      { text: enhanced }
+    ];
+
+    const images = await client.generateImage({
+      parts: generationParts,
+      imageSize: "2K"
+    });
+
+    const imagePath = path.join(outputDir, `tired_girl_${i + 1}.png`);
+    await saveBase64Image(images[0], imagePath);
+    outputs.push(imagePath);
+    prompts.push(enhanced);
+  }
+
+  const logPath = path.join(outputDir, "tired_girl.json");
+  await writeJson(logPath, {
+    museId: request.museId,
+    inputImage: request.inputImage,
+    styles: styles.map((s) => s.id),
+    quantity,
+    prompts,
+    outputs
+  });
+
+  return { outputImages: outputs, logPath };
+};

package/src/pipelines/generateVideo.ts

@@ -0,0 +1,36 @@
+import path from "node:path";
+import { GeminiClient } from "../clients/geminiClient.js";
+import { LumiereConfig, VideoRequest, VideoResult } from "../types.js";
+import { resolveOutputDir, saveBinary, writeJson } from "../storage/files.js";
+
+export const generateVideo = async (
+  config: LumiereConfig,
+  request: VideoRequest
+): Promise<VideoResult> => {
+  const client = new GeminiClient(config);
+  const outputDir = resolveOutputDir(request.outputDir ?? config.outputDir, "videos");
+
+  const result = await client.generateVideo({
+    prompt: request.prompt,
+    aspectRatio: request.aspectRatio,
+    durationSeconds: request.durationSeconds
+  });
+
+  let videoPath: string | undefined;
+  if (result.videoBytes) {
+    videoPath = path.join(outputDir, "video.mp4");
+    await saveBinary(result.videoBytes, videoPath);
+  }
+
+  const logPath = path.join(outputDir, "video.json");
+  await writeJson(logPath, {
+    prompt: request.prompt,
+    aspectRatio: request.aspectRatio,
+    durationSeconds: request.durationSeconds,
+    operationName: result.operationName,
+    videoPath
+  });
+
+  return { operationName: result.operationName, videoPath, logPath };
+};
+