studio-lumiere-cli 0.1.0

package/src/cli.ts

@@ -0,0 +1,259 @@
+#!/usr/bin/env node
+import "dotenv/config";
+import { Command } from "commander";
+import {
+  generateImages,
+  refineImage,
+  upscaleImage,
+  generateTiredGirl,
+  createMuse,
+  generateVideo,
+  annotateImage,
+  createImageGrid,
+  TEMPLATES,
+  ETHNICITIES,
+  SKIN_TONES,
+  HAIR_COLORS,
+  BACKGROUNDS,
+  BACKGROUND_TYPES,
+  VIBES,
+  RESOLUTIONS,
+  OCCASIONS
+} from "./index.js";
+import { LumiereConfig } from "./types.js";
+
+const program = new Command();
+
+const parseList = (value: string): string[] => value.split(",").map((v) => v.trim()).filter(Boolean);
+
+const loadConfig = (): LumiereConfig => {
+  const apiKey = process.env.GEMINI_API_KEY;
+  if (!apiKey) {
+    throw new Error("Missing GEMINI_API_KEY in environment.");
+  }
+  return {
+    apiKey,
+    outputDir: process.env.LUMIERE_OUTPUT_DIR ?? "outputs"
+  };
+};
+
+program
+  .name("lumiere")
+  .description("Local Studio Lumiere SDK + CLI")
+  .version("0.1.0");
+
+program
+  .command("list")
+  .argument("type", "templates|ethnicities|skin-tones|hair-colors|backgrounds|background-types|vibes|resolutions|occasions")
+  .action((type) => {
+    const map: Record<string, unknown> = {
+      templates: TEMPLATES,
+      ethnicities: ETHNICITIES,
+      "skin-tones": SKIN_TONES,
+      "hair-colors": HAIR_COLORS,
+      backgrounds: BACKGROUNDS,
+      "background-types": BACKGROUND_TYPES,
+      vibes: VIBES,
+      resolutions: RESOLUTIONS,
+      occasions: OCCASIONS
+    };
+    const payload = map[type];
+    if (!payload) {
+      throw new Error(`Unknown list type: ${type}`);
+    }
+    console.log(JSON.stringify(payload, null, 2));
+  });
+
+program
+  .command("generate")
+  .requiredOption("--images <paths>", "Comma-separated image paths")
+  .requiredOption("--template <id>", "Template id")
+  .option("--detail <id>")
+  .option("--secondary-detail <id>")
+  .option("--tertiary-detail <id>")
+  .option("--ethnicity <id>")
+  .option("--skin-tone <id>")
+  .option("--hair-color <id>")
+  .option("--background <id>")
+  .option("--background-type <id>")
+  .option("--vibe <id>")
+  .option("--resolution <id>")
+  .option("--occasion <id>")
+  .option("--quantity <n>", "Number of images", "1")
+  .option("--muse-id <id>")
+  .option("--muse-images <paths>", "Comma-separated muse image paths")
+  .option("--no-enhance", "Skip prompt enhancement")
+  .action(async (options) => {
+    const config = loadConfig();
+    const result = await generateImages(config, {
+      inputImages: parseList(options.images),
+      quantity: Number(options.quantity),
+      selections: {
+        templateId: options.template,
+        detailId: options.detail,
+        secondaryDetailId: options.secondaryDetail,
+        tertiaryDetailId: options.tertiaryDetail,
+        ethnicityId: options.ethnicity,
+        skinToneId: options.skinTone,
+        hairColorId: options.hairColor,
+        backgroundId: options.background,
+        backgroundTypeId: options.backgroundType,
+        vibeId: options.vibe,
+        resolutionId: options.resolution,
+        occasionId: options.occasion
+      },
+      museId: options.museId,
+      museImagePaths: options.museImages ? parseList(options.museImages) : undefined,
+      enhancePrompt: options.enhance
+    });
+    console.log(JSON.stringify(result, null, 2));
+  });
+
+program
+  .command("refine")
+  .requiredOption("--image <path>")
+  .requiredOption("--instruction <text>")
+  .option("--size <percent>")
+  .action(async (options) => {
+    const config = loadConfig();
+    const output = await refineImage(config, {
+      inputImage: options.image,
+      instruction: options.instruction,
+      sizeAdjustment: options.size ? Number(options.size) : undefined
+    });
+    console.log(output);
+  });
+
+program
+  .command("upscale")
+  .requiredOption("--image <path>")
+  .option("--scale <number>", "Scale factor", "2")
+  .action(async (options) => {
+    const config = loadConfig();
+    const output = await upscaleImage(config, {
+      inputImage: options.image,
+      scale: Number(options.scale)
+    });
+    console.log(output);
+  });
+
+program
+  .command("muse")
+  .requiredOption("--name <name>")
+  .requiredOption("--source <path>")
+  .option("--variations <n>", "Number of variations", "3")
+  .action(async (options) => {
+    const config = loadConfig();
+    const result = await createMuse(config, {
+      name: options.name,
+      sourceImage: options.source,
+      variations: Number(options.variations)
+    });
+    console.log(JSON.stringify(result, null, 2));
+  });
+
+program
+  .command("video")
+  .requiredOption("--prompt <text>")
+  .option("--aspect <ratio>")
+  .option("--duration <seconds>")
+  .action(async (options) => {
+    const config = loadConfig();
+    const result = await generateVideo(config, {
+      prompt: options.prompt,
+      aspectRatio: options.aspect,
+      durationSeconds: options.duration ? Number(options.duration) : undefined
+    });
+    console.log(JSON.stringify(result, null, 2));
+  });
+
+program
+  .command("tired-girl")
+  .option("--muse-id <id>", "Muse ID (preferred)")
+  .option("--image <path>", "Single reference image (used if no muse-id)")
+  .option("--styles <ids>", "Comma-separated style IDs")
+  .option("--quantity <n>", "Number of variants", "1")
+  .action(async (options) => {
+    const config = loadConfig();
+    const result = await generateTiredGirl(config, {
+      museId: options.museId,
+      inputImage: options.image,
+      styleIds: options.styles ? parseList(options.styles) : undefined,
+      quantity: Number(options.quantity)
+    });
+    console.log(JSON.stringify(result, null, 2));
+  });
+
+program
+  .command("annotate")
+  .requiredOption("--input <path>", "Input image path")
+  .requiredOption("--output <path>", "Output image path")
+  .requiredOption("--text <text>", "Overlay text")
+  .option("--font <name>", "Font family (default: Poppins)")
+  .option("--size <px>", "Font size in px")
+  .option("--weight <n>", "Font weight (default: 700)")
+  .option("--color <hex>", "Text color (default: #FFFFFF)")
+  .option("--stroke-color <value>", "Stroke/outline color (default: rgba(0,0,0,0.6))")
+  .option("--stroke-width <px>", "Stroke/outline width (default: fontSize * 0.08)")
+  .option("--banner", "Enable semi-transparent banner behind text")
+  .option("--banner-color <value>", "Banner color (default: rgba(0,0,0,0.45))")
+  .option("--banner-padding <px>", "Banner padding (default: fontSize * 0.6)")
+  .option("--banner-radius <px>", "Banner corner radius (default: fontSize * 0.4)")
+  .option(
+    "--position <pos>",
+    "top-center|top-left|top-right|bottom-center|bottom-center-high|bottom-left|bottom-right|center"
+  )
+  .option("--padding <px>", "Padding from edges")
+  .option("--max-width <ratio>", "Max width ratio (0-1)")
+  .action(async (options) => {
+    await annotateImage(
+      options.input,
+      options.output,
+      options.text,
+      {
+        fontFamily: options.font,
+        fontSize: options.size ? Number(options.size) : undefined,
+        fontWeight: options.weight ? Number(options.weight) : undefined,
+        color: options.color,
+        strokeColor: options.strokeColor,
+        strokeWidth: options.strokeWidth ? Number(options.strokeWidth) : undefined,
+        banner: options.banner ?? false,
+        bannerColor: options.bannerColor,
+        bannerPadding: options.bannerPadding ? Number(options.bannerPadding) : undefined,
+        bannerRadius: options.bannerRadius ? Number(options.bannerRadius) : undefined,
+        position: options.position,
+        padding: options.padding ? Number(options.padding) : undefined,
+        maxWidthRatio: options.maxWidth ? Number(options.maxWidth) : undefined
+      }
+    );
+    console.log(options.output);
+  });
+
+program
+  .command("grid")
+  .requiredOption("--inputs <paths>", "Comma-separated image paths")
+  .requiredOption("--output <path>", "Output image path")
+  .option("--columns <n>", "Number of columns", "2")
+  .option("--rows <n>", "Number of rows", "2")
+  .option("--padding <px>", "Padding between tiles (default: 20)")
+  .option("--background <hex>", "Background color (default: #000000)")
+  .option("--tile-width <px>", "Fixed tile width")
+  .option("--tile-height <px>", "Fixed tile height")
+  .action(async (options) => {
+    await createImageGrid(
+      parseList(options.inputs),
+      options.output,
+      {
+        columns: Number(options.columns),
+        rows: Number(options.rows),
+        padding: options.padding ? Number(options.padding) : undefined,
+        background: options.background,
+        tileWidth: options.tileWidth ? Number(options.tileWidth) : undefined,
+        tileHeight: options.tileHeight ? Number(options.tileHeight) : undefined
+      }
+    );
+    console.log(options.output);
+  });
+
+program.parseAsync();
+

package/src/clients/geminiClient.ts

@@ -0,0 +1,168 @@
+import { GoogleGenAI } from "@google/genai";
+import { AspectRatio, LumiereConfig } from "../types.js";
+
+type RetryConfig = {
+  maxRetries: number;
+  baseDelayMs: number;
+  maxDelayMs: number;
+};
+
+type ModelConfig = {
+  prompt: string;
+  image: string;
+  video: string;
+};
+
+const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+
+const isRetryableError = (error: unknown): boolean => {
+  const message = String((error as any)?.message || "").toLowerCase();
+  return (
+    message.includes("429") ||
+    message.includes("503") ||
+    message.includes("overloaded") ||
+    message.includes("unavailable") ||
+    message.includes("timeout")
+  );
+};
+
+const withRetry = async <T>(fn: () => Promise<T>, config: RetryConfig): Promise<T> => {
+  let lastError: unknown;
+  for (let attempt = 0; attempt <= config.maxRetries; attempt += 1) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt === config.maxRetries || !isRetryableError(error)) {
+        throw error;
+      }
+      const delay = Math.min(config.baseDelayMs * 2 ** attempt, config.maxDelayMs);
+      await sleep(delay + Math.random() * 0.3 * delay);
+    }
+  }
+  throw lastError;
+};
+
+export class GeminiClient {
+  private ai: GoogleGenAI;
+  private models: ModelConfig;
+  private retry: RetryConfig;
+
+  constructor(config: LumiereConfig) {
+    this.ai = new GoogleGenAI({ apiKey: config.apiKey });
+    this.models = {
+      prompt: config.models?.prompt ?? "gemini-3-flash-preview",
+      image: config.models?.image ?? "gemini-3-pro-image-preview",
+      video: config.models?.video ?? "veo-3.1-generate-preview"
+    };
+    this.retry = {
+      maxRetries: config.retry?.maxRetries ?? 3,
+      baseDelayMs: config.retry?.baseDelayMs ?? 1500,
+      maxDelayMs: config.retry?.maxDelayMs ?? 12000
+    };
+  }
+
+  async generateText(prompt: string): Promise<string> {
+    return withRetry(async () => {
+      const response = await this.ai.models.generateContent({
+        model: this.models.prompt,
+        contents: prompt
+      });
+      return response.text ?? "";
+    }, this.retry);
+  }
+
+  async generateEnhancedPrompt(params: {
+    parts: Array<{ text?: string; inlineData?: { mimeType: string; data: string } }>;
+    systemInstruction?: string;
+  }): Promise<string> {
+    return withRetry(async () => {
+      const response = await this.ai.models.generateContent({
+        model: this.models.prompt,
+        contents: [
+          {
+            role: "user",
+            parts: params.parts
+          }
+        ],
+        config: {
+          systemInstruction: params.systemInstruction
+        }
+      });
+      return response.text ?? "";
+    }, this.retry);
+  }
+
+  async generateImage(params: {
+    parts: Array<{ text?: string; inlineData?: { mimeType: string; data: string } }>;
+    aspectRatio?: AspectRatio;
+    imageSize?: "1K" | "2K" | "4K";
+  }): Promise<string[]> {
+    return withRetry(async () => {
+      const response = await this.ai.models.generateContent({
+        model: this.models.image,
+        contents: [
+          {
+            role: "user",
+            parts: params.parts
+          }
+        ],
+        config: {
+          imageConfig: {
+            aspectRatio: params.aspectRatio,
+            imageSize: params.imageSize ?? "2K"
+          }
+        }
+      });
+
+      const images: string[] = [];
+      const parts = response.candidates?.[0]?.content?.parts ?? [];
+      for (const part of parts) {
+        const inlineData = (part as any)?.inlineData;
+        if (inlineData?.data) {
+          images.push(`data:${inlineData.mimeType ?? "image/png"};base64,${inlineData.data}`);
+        }
+      }
+      if (images.length === 0) {
+        throw new Error("No image data returned from Gemini.");
+      }
+      return images;
+    }, this.retry);
+  }
+
+  async generateVideo(params: {
+    prompt: string;
+    aspectRatio?: AspectRatio;
+    durationSeconds?: number;
+  }): Promise<{ operationName?: string; videoBytes?: Uint8Array }>{
+    return withRetry(async () => {
+      let operation = await this.ai.models.generateVideos({
+        model: this.models.video,
+        prompt: params.prompt,
+        config: {
+          aspectRatio: params.aspectRatio,
+          durationSeconds: params.durationSeconds
+        }
+      });
+
+      while (!operation.done) {
+        await sleep(10000);
+        operation = await this.ai.operations.getVideosOperation({ operation });
+      }
+
+      const generated = operation.response?.generatedVideos?.[0]?.video;
+      if (!generated) {
+        return { operationName: operation.name };
+      }
+
+      const rawBytes = (generated as any).videoBytes;
+      let videoBytes: Uint8Array | undefined;
+      if (rawBytes) {
+        videoBytes = typeof rawBytes === "string" ? Buffer.from(rawBytes, "base64") : rawBytes;
+      }
+
+      return { operationName: operation.name, videoBytes };
+    }, this.retry);
+  }
+}
+