Art

# Copy to ~/.pi/agent/skills/art/.env or ~/.pi/.env if you want Pi-local credentials.
# The adapted tools also fall back to ~/.claude/.env automatically.

# Available backends
GOOGLE_API_KEY=
REPLICATE_API_TOKEN=
REMOVEBG_API_KEY=
OPENAI_API_KEY=
DISCORD_BOT_TOKEN=
MIDJOURNEY_CHANNEL_ID=

# Optional overrides
MIDJOURNEY_DEFAULT_VERSION=6.1
MIDJOURNEY_DEFAULT_QUALITY=1
MIDJOURNEY_DEFAULT_STYLIZE=100

/**
 * discord-bot.ts - Discord Bot Client for Midjourney Integration
 *
 * Official Discord bot wrapper using discord.js for legitimate interaction
 * with Midjourney bot. Handles connection, message sending, monitoring,
 * and image downloads.
 *
 * @see ${PAI_DIR}/skills/art/SKILL.md
 */

import {
  Client,
  GatewayIntentBits,
  Message,
  TextChannel,
  Partials
} from 'discord.js';
import { writeFile } from 'node:fs/promises';

// ============================================================================
// Constants
// ============================================================================

const MIDJOURNEY_BOT_ID = '936929561302675456'; // Official Midjourney bot ID

// ============================================================================
// Types
// ============================================================================

export interface DiscordBotConfig {
  token: string;
  channelId: string;
}

export interface WaitForResponseOptions {
  timeout: number; // in seconds
  pollInterval?: number; // in milliseconds
}

// ============================================================================
// Discord Bot Client
// ============================================================================

export class DiscordBotClient {
  private client: Client;
  private config: DiscordBotConfig;
  private connected: boolean = false;

  constructor(config: DiscordBotConfig) {
    this.config = config;

    // Initialize Discord client with required intents
    this.client = new Client({
      intents: [
        GatewayIntentBits.Guilds,
        GatewayIntentBits.GuildMessages,
        GatewayIntentBits.MessageContent,
      ],
      partials: [Partials.Message, Partials.Channel],
    });
  }

  /**
   * Connect to Discord
   */
  async connect(): Promise<void> {
    if (this.connected) {
      return;
    }

    return new Promise((resolve, reject) => {
      // Set up event handlers
      this.client.once('ready', () => {
        console.log(`✅ Discord bot connected as ${this.client.user?.tag}`);
        this.connected = true;
        resolve();
      });

      this.client.on('error', (error) => {
        console.error('❌ Discord client error:', error);
      });

      // Login with bot token
      this.client.login(this.config.token).catch(reject);
    });
  }

  /**
   * Send a message to the specified channel
   */
  async sendMessage(content: string): Promise<Message> {
    if (!this.connected) {
      throw new Error('Bot not connected. Call connect() first.');
    }

    const channel = await this.client.channels.fetch(this.config.channelId);

    if (!channel || !channel.isTextBased()) {
      throw new Error(`Channel ${this.config.channelId} is not a text channel`);
    }

    const message = await (channel as TextChannel).send(content);
    console.log(`📤 Sent message: ${content}`);

    return message;
  }

  /**
   * Wait for Midjourney's response to a prompt
   *
   * Polls the channel for messages from Midjourney bot that reference
   * our initial message. Returns when the response is complete (has image attachments).
   */
  async waitForMidjourneyResponse(
    initialMessageId: string,
    options: WaitForResponseOptions
  ): Promise<Message> {
    const { timeout, pollInterval = 5000 } = options;
    const startTime = Date.now();
    const timeoutMs = timeout * 1000;

    console.log(`⏳ Waiting for Midjourney response (timeout: ${timeout}s)...`);

    while (Date.now() - startTime < timeoutMs) {
      // Fetch recent messages from channel
      const channel = await this.client.channels.fetch(this.config.channelId);

      if (!channel || !channel.isTextBased()) {
        throw new Error('Channel not found or not text-based');
      }

      const messages = await (channel as TextChannel).messages.fetch({ limit: 20 });

      // Find Midjourney's response to our prompt
      for (const [_, message] of messages) {
        // Check if message is from Midjourney bot
        if (message.author.id !== MIDJOURNEY_BOT_ID) {
          continue;
        }

        // Check if this message references our initial prompt
        const referencesOurMessage =
          message.reference?.messageId === initialMessageId ||
          message.interaction?.id === initialMessageId ||
          message.content.includes(initialMessageId);

        if (!referencesOurMessage) {
          continue;
        }

        // Check if generation is complete
        if (this.isGenerationComplete(message)) {
          console.log(`✅ Midjourney generation complete!`);
          return message;
        } else {
          console.log(`⏳ Generation in progress... (${Math.floor((Date.now() - startTime) / 1000)}s)`);
        }
      }

      // Wait before next poll
      await this.sleep(pollInterval);
    }

    throw new Error(`Timeout waiting for Midjourney response after ${timeout}s`);
  }

  /**
   * Check if Midjourney generation is complete
   *
   * A complete generation has:
   * - Image attachments
   * - No "Waiting to start" or "%" progress indicators
   */
  private isGenerationComplete(message: Message): boolean {
    // Must have attachments (the generated image)
    if (message.attachments.size === 0) {
      return false;
    }

    // Check for in-progress indicators
    const content = message.content.toLowerCase();
    const inProgressIndicators = [
      'waiting to start',
      '(waiting)',
      '(0%)',
      '(1%)',
      '(2%)',
      '(3%)',
      '(4%)',
      '(5%)',
      '(6%)',
      '(7%)',
      '(8%)',
      '(9%)',
      // Continue patterns for progress
      '%)',
    ];

    for (const indicator of inProgressIndicators) {
      if (content.includes(indicator)) {
        return false;
      }
    }

    return true;
  }

  /**
   * Download image from URL to local path
   */
  async downloadImage(url: string, outputPath: string): Promise<void> {
    console.log(`📥 Downloading image from ${url}...`);

    const response = await fetch(url);

    if (!response.ok) {
      throw new Error(`Failed to download image: ${response.statusText}`);
    }

    const arrayBuffer = await response.arrayBuffer();
    const buffer = Buffer.from(arrayBuffer);

    await writeFile(outputPath, buffer);

    console.log(`✅ Image saved to ${outputPath}`);
  }

  /**
   * Disconnect from Discord
   */
  async disconnect(): Promise<void> {
    if (!this.connected) {
      return;
    }

    await this.client.destroy();
    this.connected = false;
    console.log('👋 Discord bot disconnected');
  }

  /**
   * Get the first image attachment URL from a message
   */
  getImageUrl(message: Message): string | null {
    if (message.attachments.size === 0) {
      return null;
    }

    // Get first attachment
    const attachment = message.attachments.first();

    if (!attachment) {
      return null;
    }

    // Verify it's an image
    const imageExtensions = ['.png', '.jpg', '.jpeg', '.webp', '.gif'];
    const isImage = imageExtensions.some(ext =>
      attachment.url.toLowerCase().includes(ext)
    );

    if (!isImage) {
      return null;
    }

    return attachment.url;
  }

  /**
   * Sleep utility
   */
  private sleep(ms: number): Promise<void> {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
}

/**
 * midjourney-client.ts - Midjourney Interaction Client
 *
 * High-level client for interacting with Midjourney bot through Discord.
 * Handles prompt formatting, command submission, response parsing,
 * and error detection.
 *
 * @see ${PAI_DIR}/skills/art/SKILL.md
 */

import { DiscordBotClient } from './discord-bot.js';
import { Message } from 'discord.js';

// ============================================================================
// Types
// ============================================================================

export interface MidjourneyOptions {
  prompt: string;
  aspectRatio?: string;
  version?: string;
  stylize?: number;
  quality?: number;
  chaos?: number;
  weird?: number;
  tile?: boolean;
  timeout?: number; // in seconds
}

export interface MidjourneyResult {
  imageUrl: string;
  prompt: string;
  messageId: string;
}

export type MidjourneyErrorType =
  | 'content_policy'
  | 'timeout'
  | 'connection'
  | 'invalid_params'
  | 'generation_failed'
  | 'no_image';

export class MidjourneyError extends Error {
  constructor(
    public type: MidjourneyErrorType,
    message: string,
    public originalPrompt?: string,
    public suggestion?: string
  ) {
    super(message);
    this.name = 'MidjourneyError';
  }
}

// ============================================================================
// Midjourney Client
// ============================================================================

export class MidjourneyClient {
  private discordBot: DiscordBotClient;

  constructor(discordBot: DiscordBotClient) {
    this.discordBot = discordBot;
  }

  /**
   * Generate image with Midjourney
   *
   * Submits prompt, waits for generation, and returns image URL
   */
  async generateImage(options: MidjourneyOptions): Promise<MidjourneyResult> {
    const {
      prompt,
      aspectRatio = '16:9',
      version = '6.1',
      stylize = 100,
      quality = 1,
      chaos,
      weird,
      tile = false,
      timeout = 120,
    } = options;

    // Format the Midjourney prompt
    const formattedPrompt = this.formatPrompt({
      prompt,
      aspectRatio,
      version,
      stylize,
      quality,
      chaos,
      weird,
      tile,
    });

    console.log(`🎨 Submitting to Midjourney: ${formattedPrompt}`);

    // Send the /imagine command
    const initialMessage = await this.discordBot.sendMessage(`/imagine prompt: ${formattedPrompt}`);

    // Wait for Midjourney to complete generation
    let responseMessage: Message;
    try {
      responseMessage = await this.discordBot.waitForMidjourneyResponse(initialMessage.id, {
        timeout,
        pollInterval: 5000,
      });
    } catch (error) {
      if (error instanceof Error && error.message.includes('Timeout')) {
        throw new MidjourneyError(
          'timeout',
          `Generation timed out after ${timeout}s. The image may still be processing in Discord.`,
          formattedPrompt,
          'Try checking Discord manually or increasing the timeout value.'
        );
      }
      throw error;
    }

    // Check for errors in response
    this.detectErrors(responseMessage, formattedPrompt);

    // Extract image URL
    const imageUrl = this.discordBot.getImageUrl(responseMessage);

    if (!imageUrl) {
      throw new MidjourneyError(
        'no_image',
        'No image found in Midjourney response',
        formattedPrompt,
        'The generation may have failed. Check Discord for error messages.'
      );
    }

    return {
      imageUrl,
      prompt: formattedPrompt,
      messageId: responseMessage.id,
    };
  }

  /**
   * Format Midjourney prompt with parameters
   *
   * Converts structured options into Midjourney command syntax
   */
  private formatPrompt(options: {
    prompt: string;
    aspectRatio: string;
    version: string;
    stylize: number;
    quality: number;
    chaos?: number;
    weird?: number;
    tile: boolean;
  }): string {
    const { prompt, aspectRatio, version, stylize, quality, chaos, weird, tile } = options;

    let formattedPrompt = prompt;

    // Add aspect ratio
    formattedPrompt += ` --ar ${aspectRatio}`;

    // Add version
    formattedPrompt += ` --v ${version}`;

    // Add stylize (default is 100, only add if different)
    if (stylize !== 100) {
      formattedPrompt += ` --s ${stylize}`;
    }

    // Add quality (default is 1, only add if different)
    if (quality !== 1) {
      formattedPrompt += ` --q ${quality}`;
    }

    // Add optional parameters
    if (chaos !== undefined) {
      formattedPrompt += ` --chaos ${chaos}`;
    }

    if (weird !== undefined) {
      formattedPrompt += ` --weird ${weird}`;
    }

    if (tile) {
      formattedPrompt += ` --tile`;
    }

    return formattedPrompt;
  }

  /**
   * Detect errors in Midjourney response
   */
  private detectErrors(message: Message, originalPrompt: string): void {
    const content = message.content.toLowerCase();

    // Content policy violations
    const contentPolicyIndicators = [
      'banned prompt',
      'content policy',
      'violates our community standards',
      'inappropriate content',
      'against our terms',
    ];

    for (const indicator of contentPolicyIndicators) {
      if (content.includes(indicator)) {
        throw new MidjourneyError(
          'content_policy',
          'Prompt violates Midjourney content policy',
          originalPrompt,
          'Try rephrasing your prompt to avoid potentially sensitive content.'
        );
      }
    }

    // Invalid parameters
    const invalidParamIndicators = [
      'invalid parameter',
      'unknown parameter',
      'invalid aspect ratio',
      'invalid version',
    ];

    for (const indicator of invalidParamIndicators) {
      if (content.includes(indicator)) {
        throw new MidjourneyError(
          'invalid_params',
          'Invalid Midjourney parameters',
          originalPrompt,
          'Check your aspect ratio, version, and other parameter values.'
        );
      }
    }

    // Generation failures
    const failureIndicators = [
      'failed to generate',
      'generation failed',
      'error generating',
      'something went wrong',
    ];

    for (const indicator of failureIndicators) {
      if (content.includes(indicator)) {
        throw new MidjourneyError(
          'generation_failed',
          'Midjourney generation failed',
          originalPrompt,
          'Try again or check Discord for more details.'
        );
      }
    }
  }

  /**
   * Parse Midjourney response to extract metadata
   */
  parseResponse(message: Message): {
    prompt: string;
    parameters: Record<string, string>;
  } {
    const content = message.content;

    // Extract prompt (usually before the first --)
    const promptMatch = content.match(/^(.+?)(?:\s+--|\s*$)/);
    const prompt = promptMatch ? promptMatch[1].trim() : content;

    // Extract parameters
    const parameters: Record<string, string> = {};
    const paramRegex = /--(\w+)\s+([^\s-]+)/g;
    let match;

    while ((match = paramRegex.exec(content)) !== null) {
      parameters[match[1]] = match[2];
    }

    return { prompt, parameters };
  }

  /**
   * Validate Midjourney options before submission
   */
  static validateOptions(options: MidjourneyOptions): void {
    // Validate aspect ratio
    const validAspectRatios = [
      '1:1', '16:9', '9:16', '2:3', '3:2', '4:5', '5:4', '7:4', '4:7',
      '21:9', '9:21', '3:4', '4:3'
    ];

    if (options.aspectRatio && !validAspectRatios.includes(options.aspectRatio)) {
      throw new Error(
        `Invalid aspect ratio: ${options.aspectRatio}. Valid ratios: ${validAspectRatios.join(', ')}`
      );
    }

    // Validate version
    const validVersions = ['6.1', '6', '5.2', '5.1', '5', 'niji', 'niji 6'];

    if (options.version && !validVersions.includes(options.version)) {
      throw new Error(
        `Invalid version: ${options.version}. Valid versions: ${validVersions.join(', ')}`
      );
    }

    // Validate stylize (0-1000)
    if (options.stylize !== undefined && (options.stylize < 0 || options.stylize > 1000)) {
      throw new Error('Stylize must be between 0 and 1000');
    }

    // Validate quality
    const validQualities = [0.25, 0.5, 1, 2];

    if (options.quality !== undefined && !validQualities.includes(options.quality)) {
      throw new Error('Quality must be 0.25, 0.5, 1, or 2');
    }

    // Validate chaos (0-100)
    if (options.chaos !== undefined && (options.chaos < 0 || options.chaos > 100)) {
      throw new Error('Chaos must be between 0 and 100');
    }

    // Validate weird (0-3000)
    if (options.weird !== undefined && (options.weird < 0 || options.weird > 3000)) {
      throw new Error('Weird must be between 0 and 3000');
    }

    // Validate timeout
    if (options.timeout !== undefined && options.timeout < 30) {
      throw new Error('Timeout must be at least 30 seconds');
    }
  }
}

# dependencies (bun install)
node_modules

# output
out
dist
*.tgz

# code coverage
coverage
*.lcov

# logs
logs
_.log
report.[0-9]_.[0-9]_.[0-9]_.[0-9]_.json

# dotenv environment variable files
.env
.env.development.local
.env.test.local
.env.production.local
.env.local

# caches
.eslintcache
.cache
*.tsbuildinfo

# IntelliJ based IDEs
.idea

# Finder (MacOS) folder config
.DS_Store

#!/usr/bin/env bun

/**
 * ComposeThumbnail - YouTube Thumbnail Composition CLI
 *
 * Composites background, headshot, and text into a YouTube thumbnail.
 * Uses ImageMagick for all composition operations.
 *
 * Features:
 * - Dynamic headshot positioning (left, center, right)
 * - Solid black backdrop boxes behind text for readability
 * - Full-height headshot that dominates the frame
 * - Colored border (Tokyo Night purple default)
 */

import { spawn } from "node:child_process";
import { existsSync, unlinkSync } from "node:fs";
import { resolve, dirname } from "node:path";

// ============================================================================
// Types
// ============================================================================

interface CLIArgs {
  background: string;
  headshot: string;
  title: string;
  subtitle: string;
  output: string;
  titleColor?: string;
  subtitleColor?: string;
  borderColor?: string;
  font?: string;
  headshotPosition?: "left" | "center" | "right";
}

// ============================================================================
// Configuration
// ============================================================================

const DEFAULTS = {
  titleColor: "#7dcfff",        // Tokyo Night cyan - VIBRANT by default
  subtitleColor: "#FFFFFF",     // White text for contrast
  borderColor: "#bb9af7",       // Tokyo Night Vivid Purple
  font: "Helvetica-Bold",       // System font that actually exists
  headshotPosition: "left" as const,
  output: `${process.env.HOME}/Downloads/yt-thumbnail-${Date.now()}.png`,
};

const LAYOUT = {
  width: 1280,
  height: 720,
  borderWidth: 16,
  // TEXT - BILLBOARD STYLE (large, bold, dominant)
  titleSize: 100,         // DOMINANT - fills the space
  subtitleSize: 50,       // Proportionally sized, still readable
  titleStroke: 4,         // Bold outline for visibility
  subtitleStroke: 3,      // Visible outline
  textPadding: 6,
  textBoxPadding: 20,
  // Safe zones - headshot and text never overlap
  headshotMaxWidth: 0.40, // Headshot takes max 40% width
  textZoneWidth: 0.55,    // Text zone is 55% width (FILLS the space)
  textZoneGap: 0.05,      // 5% gap between zones
};

// Color presets for text (Tokyo Night palette + extras)
const COLOR_PRESETS: Record<string, string> = {
  white: "#FFFFFF",
  cyan: "#7dcfff",
  purple: "#bb9af7",
  blue: "#7aa2f7",
  magenta: "#ff007c",
  yellow: "#e0af68",
  green: "#9ece6a",
  orange: "#ff9e64",
  red: "#f7768e",
};

function resolveColor(color: string): string {
  // If it's a preset name, return the hex value
  const preset = COLOR_PRESETS[color.toLowerCase()];
  if (preset) return preset;
  // Otherwise assume it's already a hex color
  return color;
}

// ============================================================================
// Error Handling
// ============================================================================

class CLIError extends Error {
  constructor(message: string, public exitCode: number = 1) {
    super(message);
    this.name = "CLIError";
  }
}

// ============================================================================
// Helpers
// ============================================================================

function printHelp(): void {
  console.log(`
ComposeThumbnail - YouTube Thumbnail Composition CLI

USAGE:
  bun ${PAI_DIR}/skills/Media/Art/Tools/ComposeThumbnail.ts [OPTIONS]

REQUIRED:
  --background <path>     Background image (dramatic tech art)
  --headshot <path>       Headshot image (transparent background)
  --title <text>          Title text (max 6 words, auto-capitalized)
  --subtitle <text>       Subtitle text (max 12 words, auto-capitalized)

OPTIONAL:
  --output <path>         Output path (default: ~/Downloads/yt-thumbnail-{timestamp}.png)
  --position <pos>        Headshot position: left, center, right (default: left)
  --font <name>           Font name (default: Helvetica-Bold)
  --title-color <hex>     Title color (default: #FFFFFF)
  --subtitle-color <hex>  Subtitle color (default: #FFFFFF)
  --border-color <hex>    Border color (default: #bb9af7 Tokyo Night Purple)
  --help, -h              Show this help message

EXAMPLE:
  bun ${PAI_DIR}/skills/Media/Art/Tools/ComposeThumbnail.ts \\
    --background ~/Downloads/tech-background.png \\
    --headshot ~/Downloads/headshot-nobg.png \\
    --title "AI AGENTS KILLING SOFTWARE" \\
    --subtitle "WHY TRADITIONAL DEVELOPMENT IS DEAD" \\
    --position left \\
    --output ~/Downloads/thumbnail.png

LAYOUT:
  Canvas:     1280x720 px
  Border:     16px colored border (Tokyo Night purple)
  Headshot:   Full height inside border, positioned left/center/right
  Text:       White text with minimal black backdrop boxes
`);
}

function parseArgs(args: string[]): CLIArgs {
  const result: Partial<CLIArgs> = {};

  for (let i = 0; i < args.length; i++) {
    const arg = args[i];
    const next = args[i + 1];

    switch (arg) {
      case "--help":
      case "-h":
        printHelp();
        process.exit(0);
      case "--background":
        result.background = next;
        i++;
        break;
      case "--headshot":
        result.headshot = next;
        i++;
        break;
      case "--title":
        result.title = next;
        i++;
        break;
      case "--subtitle":
        result.subtitle = next;
        i++;
        break;
      case "--output":
        result.output = next;
        i++;
        break;
      case "--position":
        if (next === "left" || next === "center" || next === "right") {
          result.headshotPosition = next;
        }
        i++;
        break;
      case "--title-color":
        result.titleColor = next;
        i++;
        break;
      case "--subtitle-color":
        result.subtitleColor = next;
        i++;
        break;
      case "--border-color":
        result.borderColor = next;
        i++;
        break;
      case "--font":
        result.font = next;
        i++;
        break;
    }
  }

  // Validate required args
  if (!result.background) throw new CLIError("--background is required");
  if (!result.headshot) throw new CLIError("--headshot is required");
  if (!result.title) throw new CLIError("--title is required");
  if (!result.subtitle) throw new CLIError("--subtitle is required");

  // Validate files exist
  if (!existsSync(result.background)) {
    throw new CLIError(`Background file not found: ${result.background}`);
  }
  if (!existsSync(result.headshot)) {
    throw new CLIError(`Headshot file not found: ${result.headshot}`);
  }

  return {
    background: resolve(result.background),
    headshot: resolve(result.headshot),
    title: result.title.toUpperCase(),
    subtitle: result.subtitle.toUpperCase(),
    output: result.output ? resolve(result.output) : DEFAULTS.output,
    titleColor: result.titleColor || DEFAULTS.titleColor,
    subtitleColor: result.subtitleColor || DEFAULTS.subtitleColor,
    borderColor: result.borderColor || DEFAULTS.borderColor,
    font: result.font || DEFAULTS.font,
    headshotPosition: result.headshotPosition || DEFAULTS.headshotPosition,
  };
}

async function runCommand(cmd: string, args: string[]): Promise<string> {
  return new Promise((resolve, reject) => {
    const proc = spawn(cmd, args);
    let stdout = "";
    let stderr = "";

    proc.stdout.on("data", (data) => (stdout += data.toString()));
    proc.stderr.on("data", (data) => (stderr += data.toString()));

    proc.on("close", (code) => {
      if (code === 0) {
        resolve(stdout);
      } else {
        reject(new CLIError(`Command failed: ${cmd} ${args.join(" ")}\n${stderr}`, code || 1));
      }
    });
  });
}

// ============================================================================
// Headshot Processing
// ============================================================================

/**
 * Crop headshot to FACE ONLY - removes shoulders/body and zooms into face.
 * This ensures the face dominates the frame without clipped body parts.
 */
async function cropToFaceOnly(headshotPath: string, outputPath: string): Promise<void> {
  // Get original dimensions
  const dimensions = await runCommand("magick", [
    "identify", "-format", "%wx%h", headshotPath
  ]);
  const [width, height] = dimensions.trim().split("x").map(Number);

  // Crop bottom 25% (removes shoulders/body) and zoom 135% into face
  await runCommand("magick", [
    headshotPath,
    "-gravity", "north",           // Anchor to top (face area)
    "-crop", `100%x75%+0+0`,       // Crop bottom 25% (shoulders/body)
    "+repage",
    "-resize", "135%",             // Zoom into face
    "-gravity", "center",
    "-extent", `${width}x${height}`, // Restore original dimensions
    outputPath,
  ]);
}

// ============================================================================
// Main Composition
// ============================================================================

async function composeThumbnail(args: CLIArgs): Promise<void> {
  const outputDir = dirname(args.output);
  const timestamp = Date.now();

  // Intermediate files
  const resizedBg = `${outputDir}/.yt-bg-${timestamp}.png`;
  const croppedHeadshot = `${outputDir}/.yt-cropped-${timestamp}.png`;
  const withHeadshot = `${outputDir}/.yt-headshot-${timestamp}.png`;
  const withText = `${outputDir}/.yt-text-${timestamp}.png`;

  const intermediates = [resizedBg, croppedHeadshot, withHeadshot, withText];

  try {
    console.log("🎨 Composing YouTube thumbnail...");

    // Step 1: Resize background to exact dimensions
    console.log("   📐 Resizing background to 1280x720...");
    await runCommand("magick", [
      args.background,
      "-resize", `${LAYOUT.width}x${LAYOUT.height}^`,
      "-gravity", "center",
      "-extent", `${LAYOUT.width}x${LAYOUT.height}`,
      resizedBg,
    ]);

    // Step 2: Crop headshot to FACE ONLY (remove shoulders/body)
    console.log(`   ✂️  Cropping headshot to face only...`);
    await cropToFaceOnly(args.headshot, croppedHeadshot);

    // Step 3: Composite headshot based on position
    console.log(`   👤 Adding headshot (${args.headshotPosition})...`);

    // Calculate headshot height - FULL HEIGHT inside border
    // Face should fill ~95% of vertical space inside the border
    const headshotHeight = LAYOUT.height - (LAYOUT.borderWidth * 2); // 688px

    // Determine gravity and offset based on position
    let gravity: string;
    let geometryOffset: string;

    switch (args.headshotPosition) {
      case "left":
        gravity = "west";
        geometryOffset = "+20+0";
        break;
      case "center":
        gravity = "center";
        geometryOffset = "+0+0";
        break;
      case "right":
        gravity = "east";
        geometryOffset = "+20+0";
        break;
      default:
        gravity = "west";
        geometryOffset = "+20+0";
    }

    await runCommand("magick", [
      resizedBg,
      "(",
        croppedHeadshot,  // Use cropped headshot (face only)
        "-resize", `x${headshotHeight}`,
      ")",
      "-gravity", gravity,
      "-geometry", geometryOffset,
      "-composite",
      withHeadshot,
    ]);

    // Step 4: Add text with stroke outline
    console.log("   📝 Adding text with stroke outlines...");

    // For left/right positions: create combined text block, center in available region
    // For center position: separate title (top) and subtitle (bottom)

    // Resolve colors (support preset names like "cyan" or hex like "#ff007c")
    const titleColorResolved = resolveColor(args.titleColor!);
    const subtitleColorResolved = resolveColor(args.subtitleColor!);

    if (args.headshotPosition === "center") {
      // CENTER: Title at top, subtitle at bottom (outside headshot zone)
      const titleWithStroke = `${outputDir}/.yt-title-${timestamp}.png`;
      const subtitleWithStroke = `${outputDir}/.yt-subtitle-${timestamp}.png`;
      intermediates.push(titleWithStroke, subtitleWithStroke);

      // Create title (WIDE canvas for 100pt BILLBOARD text)
      await runCommand("magick", [
        "-size", "1400x200",
        "xc:transparent",
        "-font", args.font!,
        "-pointsize", String(LAYOUT.titleSize),
        "-gravity", "center",
        "-stroke", "#000000", "-strokewidth", String(LAYOUT.titleStroke), "-fill", "none",
        "-annotate", "+0+0", args.title,
        "-stroke", "none", "-fill", titleColorResolved,
        "-annotate", "+0+0", args.title,
        "-trim", "+repage",
        titleWithStroke,
      ]);

      // Create subtitle (WIDE canvas for 50pt BILLBOARD text)
      await runCommand("magick", [
        "-size", "1400x120",
        "xc:transparent",
        "-font", args.font!,
        "-pointsize", String(LAYOUT.subtitleSize),
        "-gravity", "center",
        "-stroke", "#000000", "-strokewidth", String(LAYOUT.subtitleStroke), "-fill", "none",
        "-annotate", "+0+0", args.subtitle,
        "-stroke", "none", "-fill", subtitleColorResolved,
        "-annotate", "+0+0", args.subtitle,
        "-trim", "+repage",
        subtitleWithStroke,
      ]);

      // Composite title at top (inside border, above headshot zone)
      const withTitle = `${outputDir}/.yt-with-title-${timestamp}.png`;
      intermediates.push(withTitle);
      await runCommand("magick", [
        withHeadshot,
        titleWithStroke,
        "-gravity", "north",
        "-geometry", "+0+25",
        "-composite",
        withTitle,
      ]);

      // Composite subtitle at bottom (inside border, below headshot zone)
      await runCommand("magick", [
        withTitle,
        subtitleWithStroke,
        "-gravity", "south",
        "-geometry", "+0+25",
        "-composite",
        withText,
      ]);

    } else {
      // LEFT or RIGHT: Create text in safe zone (NEVER overlap headshot)

      // Calculate text zone center (opposite side from headshot)
      // Position at 62% or 38% of canvas width with generous margins
      // Account for 16px border + compression during final resize
      const textZoneCenter = args.headshotPosition === "left"
        ? Math.round(LAYOUT.width * 0.62) // 794px - text on right with generous margin
        : Math.round(LAYOUT.width * 0.38); // 486px - text on left with generous margin

      // Create title and subtitle with BILLBOARD sizing
      const titleImg = `${outputDir}/.yt-title-${timestamp}.png`;
      const subtitleImg = `${outputDir}/.yt-subtitle-${timestamp}.png`;
      intermediates.push(titleImg, subtitleImg);

      // Create title - 100pt BILLBOARD text on WIDE canvas (prevents cutoff)
      await runCommand("magick", [
        "-size", "1400x200",
        "xc:transparent",
        "-font", args.font!,
        "-gravity", "center",
        "-pointsize", String(LAYOUT.titleSize),
        "-stroke", "#000000", "-strokewidth", String(LAYOUT.titleStroke), "-fill", "none",
        "-annotate", "+0+0", args.title,
        "-stroke", "none", "-fill", titleColorResolved,
        "-annotate", "+0+0", args.title,
        "-trim", "+repage",
        titleImg,
      ]);

      // Create subtitle - 50pt BILLBOARD text on WIDE canvas (prevents cutoff)
      await runCommand("magick", [
        "-size", "1400x120",
        "xc:transparent",
        "-font", args.font!,
        "-gravity", "center",
        "-pointsize", String(LAYOUT.subtitleSize),
        "-stroke", "#000000", "-strokewidth", String(LAYOUT.subtitleStroke), "-fill", "none",
        "-annotate", "+0+0", args.subtitle,
        "-stroke", "none", "-fill", subtitleColorResolved,
        "-annotate", "+0+0", args.subtitle,
        "-trim", "+repage",
        subtitleImg,
      ]);

      // Position text at center of text zone using absolute coordinates
      // Composite title above center
      const withTitle = `${outputDir}/.yt-with-title-${timestamp}.png`;
      intermediates.push(withTitle);

      // Calculate absolute X position for centering in text zone
      // We'll use page geometry to position at exact coordinates
      // Larger fonts need more vertical spread
      const titleY = Math.round(LAYOUT.height / 2) - 80; // Above center (for 100pt)
      const subtitleY = Math.round(LAYOUT.height / 2) + 50; // Below center (for 50pt)

      await runCommand("magick", [
        withHeadshot,
        titleImg,
        "-gravity", "north",
        "-geometry", `+${textZoneCenter - LAYOUT.width/2}+${titleY}`,
        "-composite",
        withTitle,
      ]);

      // Composite subtitle below title
      await runCommand("magick", [
        withTitle,
        subtitleImg,
        "-gravity", "north",
        "-geometry", `+${textZoneCenter - LAYOUT.width/2}+${subtitleY}`,
        "-composite",
        withText,
      ]);
    }

    // Step 5: Add colored border
    console.log("   🖼️  Adding border...");
    await runCommand("magick", [
      withText,
      "-bordercolor", args.borderColor!,
      "-border", String(LAYOUT.borderWidth),
      "-resize", `${LAYOUT.width}x${LAYOUT.height}!`,
      args.output,
    ]);

    console.log(`✅ Thumbnail saved to ${args.output}`);

    // Verify dimensions
    const identify = await runCommand("magick", ["identify", "-format", "%wx%h", args.output]);
    console.log(`   📏 Dimensions: ${identify.trim()}`);

  } finally {
    // Cleanup intermediate files
    for (const file of intermediates) {
      try {
        if (existsSync(file)) {
          unlinkSync(file);
        }
      } catch {
        // Ignore cleanup errors
      }
    }
  }
}

// ============================================================================
// Main
// ============================================================================

async function main(): Promise<void> {
  try {
    const args = parseArgs(process.argv.slice(2));
    await composeThumbnail(args);
  } catch (error) {
    if (error instanceof CLIError) {
      console.error(`❌ Error: ${error.message}`);
      process.exit(error.exitCode);
    }
    throw error;
  }
}

main();

#!/usr/bin/env bun

/**
 * generate - Image Generation CLI
 *
 * Generate {YOUR_BUSINESS_NAME} branded images using Flux 1.1 Pro, Nano Banana, Nano Banana Pro, or GPT-image-1.
 * Follows llcli pattern for deterministic, composable CLI design.
 *
 * Usage:
 *   generate --model nano-banana-pro --prompt "..." --size 16:9 --output /tmp/image.png
 *
 * @see ${PAI_DIR}/skills/art/README.md
 */

import Replicate from "replicate";
import OpenAI from "openai";
import { GoogleGenAI } from "@google/genai";
import { writeFile, readFile } from "node:fs/promises";
import { extname, resolve } from "node:path";

// ============================================================================
// Environment Loading
// ============================================================================

/**
 * Load environment variables from the first available .env file.
 * Search order:
 * 1. $PAI_DIR/.env (if set)
 * 2. This skill's .env
 * 3. ~/.pi/.env
 * 4. ~/.claude/.env
 */
async function loadEnv(): Promise<void> {
  const skillDir = resolve(import.meta.dir, '..');
  const envPaths = [
    process.env.PAI_DIR ? resolve(process.env.PAI_DIR, '.env') : undefined,
    resolve(skillDir, '.env'),
    resolve(process.env.HOME!, '.pi', '.env'),
    resolve(process.env.HOME!, '.claude', '.env'),
  ].filter(Boolean) as string[];

  for (const envPath of envPaths) {
    try {
      const envContent = await readFile(envPath, 'utf-8');
      for (const line of envContent.split('\n')) {
        const trimmed = line.trim();
        if (!trimmed || trimmed.startsWith('#')) continue;
        const eqIndex = trimmed.indexOf('=');
        if (eqIndex === -1) continue;
        const key = trimmed.slice(0, eqIndex).trim();
        let value = trimmed.slice(eqIndex + 1).trim();
        if ((value.startsWith('"') && value.endsWith('"')) ||
            (value.startsWith("'") && value.endsWith("'"))) {
          value = value.slice(1, -1);
        }
        if (!process.env[key]) {
          process.env[key] = value;
        }
      }
      return;
    } catch {
      // Try next candidate.
    }
  }
}

// ============================================================================
// Types
// ============================================================================

type Model = "flux" | "nano-banana" | "nano-banana-pro" | "gpt-image-1";
type ReplicateSize = "1:1" | "16:9" | "3:2" | "2:3" | "3:4" | "4:3" | "4:5" | "5:4" | "9:16" | "21:9";
type OpenAISize = "1024x1024" | "1536x1024" | "1024x1536";
type GeminiSize = "1K" | "2K" | "4K";
type Size = ReplicateSize | OpenAISize | GeminiSize;

interface CLIArgs {
  model: Model;
  prompt: string;
  size: Size;
  output: string;
  creativeVariations?: number;
  aspectRatio?: ReplicateSize; // For Gemini models
  transparent?: boolean; // Enable transparent background
  referenceImages?: string[]; // Reference image paths (Nano Banana Pro only) - up to 14 total
  removeBg?: boolean; // Remove background after generation using remove.bg API
  addBg?: string; // Add background color (hex) to transparent image
  thumbnail?: boolean; // Generate additional thumbnail with #EAE9DF background for social previews
}

// ============================================================================
// Configuration
// ============================================================================

const DEFAULTS = {
  model: "flux" as Model,
  size: "16:9" as Size,
  output: `${process.env.HOME}/Downloads/generated-image.png`,
};

const REPLICATE_SIZES: ReplicateSize[] = ["1:1", "16:9", "3:2", "2:3", "3:4", "4:3", "4:5", "5:4", "9:16", "21:9"];
const OPENAI_SIZES: OpenAISize[] = ["1024x1024", "1536x1024", "1024x1536"];
const GEMINI_SIZES: GeminiSize[] = ["1K", "2K", "4K"];

// Aspect ratio mapping for Gemini (used with image size like 2K)
const GEMINI_ASPECT_RATIOS: ReplicateSize[] = ["1:1", "2:3", "3:2", "3:4", "4:3", "4:5", "5:4", "9:16", "16:9", "21:9"];

// ============================================================================
// Error Handling
// ============================================================================

class CLIError extends Error {
  constructor(message: string, public exitCode: number = 1) {
    super(message);
    this.name = "CLIError";
  }
}

function handleError(error: unknown): never {
  if (error instanceof CLIError) {
    console.error(`❌ Error: ${error.message}`);
    process.exit(error.exitCode);
  }

  if (error instanceof Error) {
    console.error(`❌ Unexpected error: ${error.message}`);
    console.error(error.stack);
    process.exit(1);
  }

  console.error(`❌ Unknown error:`, error);
  process.exit(1);
}

// ============================================================================
// Image Format Detection
// ============================================================================

/**
 * Detect actual image format from magic bytes.
 * Prevents MIME type mismatch when API returns different format than requested.
 */
function detectImageFormat(data: Buffer | Uint8Array): { format: string; ext: string; mime: string } | null {
  if (data.length < 12) return null;
  if (data[0] === 0x89 && data[1] === 0x50 && data[2] === 0x4e && data[3] === 0x47)
    return { format: "png", ext: ".png", mime: "image/png" };
  if (data[0] === 0xff && data[1] === 0xd8 && data[2] === 0xff)
    return { format: "jpeg", ext: ".jpg", mime: "image/jpeg" };
  if (data[0] === 0x52 && data[1] === 0x49 && data[2] === 0x46 && data[3] === 0x46 &&
      data[8] === 0x57 && data[9] === 0x45 && data[10] === 0x42 && data[11] === 0x50)
    return { format: "webp", ext: ".webp", mime: "image/webp" };
  if (data[0] === 0x47 && data[1] === 0x49 && data[2] === 0x46)
    return { format: "gif", ext: ".gif", mime: "image/gif" };
  return null;
}

/**
 * Save image data with correct file extension based on actual content format.
 * Returns the final path (may differ from requested if format mismatch detected).
 */
async function saveImage(data: Buffer | Uint8Array | any, requestedPath: string): Promise<string> {
  const buffer = data instanceof Buffer ? data : Buffer.from(data as any);
  const detected = detectImageFormat(buffer);
  if (detected) {
    const requestedExt = extname(requestedPath).toLowerCase();
    if (requestedExt && requestedExt !== detected.ext) {
      const correctedPath = requestedPath.replace(/\.[^.]+$/, detected.ext);
      console.warn(`⚠️ API returned ${detected.format.toUpperCase()} data (requested ${requestedExt.slice(1).toUpperCase()}). Saving as ${correctedPath}`);
      await writeFile(correctedPath, buffer);
      return correctedPath;
    }
  }
  await writeFile(requestedPath, buffer);
  return requestedPath;
}

/**
 * Detect MIME type from image file content (magic bytes), falling back to extension.
 */
async function detectMimeType(filePath: string): Promise<string> {
  try {
    const data = await readFile(filePath);
    const detected = detectImageFormat(data);
    if (detected) return detected.mime;
  } catch {
    // Fall through to extension-based detection
  }
  const ext = extname(filePath).toLowerCase();
  switch (ext) {
    case ".png": return "image/png";
    case ".jpg": case ".jpeg": return "image/jpeg";
    case ".webp": return "image/webp";
    default: throw new CLIError(`Unsupported image format: ${ext}. Supported: .png, .jpg, .jpeg, .webp`);
  }
}

// ============================================================================
// Help Text
// ============================================================================

// Skill directory for documentation paths
const SKILL_DIR = resolve(import.meta.dir, '..');

function showHelp(): void {
  console.log(`
generate - Image Generation CLI

Generate {YOUR_BUSINESS_NAME} branded images using Flux 1.1 Pro, Nano Banana, or GPT-image-1.

USAGE:
  generate --model <model> --prompt "<prompt>" [OPTIONS]

REQUIRED:
  --model <model>      Model to use: flux, nano-banana, nano-banana-pro, gpt-image-1
  --prompt <text>      Image generation prompt (quote if contains spaces)

OPTIONS:
  --size <size>              Image size/aspect ratio (default: 16:9)
                             Replicate (flux, nano-banana): 1:1, 16:9, 3:2, 2:3, 3:4, 4:3, 4:5, 5:4, 9:16, 21:9
                             OpenAI (gpt-image-1): 1024x1024, 1536x1024, 1024x1536
                             Gemini (nano-banana-pro): 1K, 2K, 4K (resolution); aspect ratio inferred from context or defaults to 16:9
  --aspect-ratio <ratio>     Aspect ratio for Gemini nano-banana-pro (default: 16:9)
                             Options: 1:1, 2:3, 3:2, 3:4, 4:3, 4:5, 5:4, 9:16, 16:9, 21:9
  --output <path>            Output file path (default: /tmp/generated-image.png)
  --reference-image <path>   Reference image for style/character consistency (Nano Banana Pro only)
                             Can specify MULTIPLE times for improved consistency
                             Accepts: PNG, JPEG, WebP images
                             API Limits: Up to 5 human refs, 6 object refs, 14 total max
  --transparent              Enable transparent background (adds transparency instructions to prompt)
                             Note: Not all models support transparency natively; may require post-processing
  --remove-bg                Remove background after generation using remove.bg API
                             Creates true transparency by removing the generated background
  --add-bg <hex>             Add background color to a transparent image (e.g., "#EAE9DF")
                             Useful for creating thumbnails/social previews from transparent images
  --thumbnail                Generate BOTH transparent AND thumbnail versions for blog headers
                             Creates: output.png (transparent) + output-thumb.png (#EAE9DF background)
                             Automatically enables --remove-bg
  --creative-variations <n>  Generate N variations (appends -v1, -v2, etc. to output filename)
                             Use with the be-creative skill for true prompt diversity
                             CLI mode: generates N images with same prompt (tests model variability)
  --help, -h                 Show this help message

EXAMPLES:
  # Generate blog header with Nano Banana Pro (16:9, 2K quality)
  generate --model nano-banana-pro --prompt "Abstract illustration..." --size 2K --aspect-ratio 16:9

  # Generate high-res 4K image with Nano Banana Pro
  generate --model nano-banana-pro --prompt "Editorial cover..." --size 4K --aspect-ratio 3:2

  # Generate blog header with original Nano Banana (16:9)
  generate --model nano-banana --prompt "Abstract illustration..." --size 16:9

  # Generate square image with Flux
  generate --model flux --prompt "Minimal geometric art..." --size 1:1 --output /tmp/header.png

  # Generate portrait with GPT-image-1
  generate --model gpt-image-1 --prompt "Editorial cover..." --size 1024x1536

  # Generate 3 creative variations (for testing model variability)
  generate --model gpt-image-1 --prompt "..." --creative-variations 3 --output /tmp/essay.png
  # Outputs: /tmp/essay-v1.png, /tmp/essay-v2.png, /tmp/essay-v3.png

  # Single reference image for style guidance (Nano Banana Pro only)
  generate --model nano-banana-pro --prompt "Tokyo Night themed illustration..." \\
    --reference-image /tmp/style-reference.png --size 2K --aspect-ratio 16:9

  # MULTIPLE reference images for character consistency (Nano Banana Pro only)
  generate --model nano-banana-pro --prompt "Person from references at a party..." \\
    --reference-image face1.jpg --reference-image face2.jpg --reference-image face3.jpg \\
    --size 2K --aspect-ratio 16:9

NOTE: For true creative diversity with different prompts, use the creative workflow which
integrates the be-creative skill. CLI creative mode generates multiple images with the SAME prompt.

MULTI-REFERENCE LIMITS (Gemini API):
  - Up to 5 human reference images for character consistency
  - Up to 6 object reference images
  - Maximum 14 total reference images per request

ENVIRONMENT VARIABLES:
  REPLICATE_API_TOKEN  Required for flux and nano-banana models
  OPENAI_API_KEY       Required for gpt-image-1 model
  GOOGLE_API_KEY       Required for nano-banana-pro model
  REMOVEBG_API_KEY     Required for --remove-bg flag

ERROR CODES:
  0  Success
  1  General error (invalid arguments, API error, file write error)

MORE INFO:
  Documentation: ${SKILL_DIR}/SKILL.md
  Source: ${SKILL_DIR}/Tools/Generate.ts
`);
  process.exit(0);
}

// ============================================================================
// Argument Parsing
// ============================================================================

function parseArgs(argv: string[]): CLIArgs {
  const args = argv.slice(2);

  // Check for help flag
  if (args.includes("--help") || args.includes("-h") || args.length === 0) {
    showHelp();
  }

  const parsed: Partial<CLIArgs> = {
    model: DEFAULTS.model,
    output: DEFAULTS.output,
  };

  // Collect reference images into array
  const referenceImages: string[] = [];

  // Parse arguments
  for (let i = 0; i < args.length; i++) {
    const flag = args[i];

    if (!flag.startsWith("--")) {
      throw new CLIError(`Invalid flag: ${flag}. Flags must start with --`);
    }

    const key = flag.slice(2);

    // Handle boolean flags (no value)
    if (key === "transparent") {
      parsed.transparent = true;
      continue;
    }
    if (key === "remove-bg") {
      parsed.removeBg = true;
      continue;
    }
    if (key === "thumbnail") {
      parsed.thumbnail = true;
      parsed.removeBg = true; // Thumbnail mode requires remove-bg
      continue;
    }

    // Handle flags with values
    const value = args[i + 1];
    if (!value || value.startsWith("--")) {
      throw new CLIError(`Missing value for flag: ${flag}`);
    }

    switch (key) {
      case "model":
        if (value !== "flux" && value !== "nano-banana" && value !== "nano-banana-pro" && value !== "gpt-image-1") {
          throw new CLIError(`Invalid model: ${value}. Must be: flux, nano-banana, nano-banana-pro, or gpt-image-1`);
        }
        parsed.model = value;
        i++; // Skip next arg (value)
        break;
      case "prompt":
        parsed.prompt = value;
        i++; // Skip next arg (value)
        break;
      case "size":
        parsed.size = value as Size;
        i++; // Skip next arg (value)
        break;
      case "aspect-ratio":
        parsed.aspectRatio = value as ReplicateSize;
        i++; // Skip next arg (value)
        break;
      case "output":
        parsed.output = value;
        i++; // Skip next arg (value)
        break;
      case "reference-image":
        // Collect multiple reference images into array
        referenceImages.push(value);
        i++; // Skip next arg (value)
        break;
      case "creative-variations":
        const variations = parseInt(value, 10);
        if (isNaN(variations) || variations < 1 || variations > 10) {
          throw new CLIError(`Invalid creative-variations: ${value}. Must be 1-10`);
        }
        parsed.creativeVariations = variations;
        i++; // Skip next arg (value)
        break;
      case "add-bg":
        // Validate hex color format
        if (!/^#[0-9A-Fa-f]{6}$/.test(value)) {
          throw new CLIError(`Invalid hex color: ${value}. Must be in format #RRGGBB (e.g., #EAE9DF)`);
        }
        parsed.addBg = value;
        i++; // Skip next arg (value)
        break;
      default:
        throw new CLIError(`Unknown flag: ${flag}`);
    }
  }

  // Assign collected reference images if any
  if (referenceImages.length > 0) {
    parsed.referenceImages = referenceImages;
  }

  // Validate required arguments
  if (!parsed.prompt) {
    throw new CLIError("Missing required argument: --prompt");
  }

  if (!parsed.model) {
    throw new CLIError("Missing required argument: --model");
  }

  // Validate reference-image is only used with nano-banana-pro
  if (parsed.referenceImages && parsed.referenceImages.length > 0 && parsed.model !== "nano-banana-pro") {
    throw new CLIError("--reference-image is only supported with --model nano-banana-pro");
  }

  // Validate reference image count (API limits: 5 human, 6 object, 14 total max)
  if (parsed.referenceImages && parsed.referenceImages.length > 14) {
    throw new CLIError(`Too many reference images: ${parsed.referenceImages.length}. Maximum is 14 total (5 human, 6 object)`);
  }

  // Set model-appropriate default size if not explicitly provided
  if (!parsed.size) {
    switch (parsed.model) {
      case "gpt-image-1":
        parsed.size = "1024x1024";
        break;
      case "nano-banana-pro":
        parsed.size = "2K";
        break;
      default: // flux, nano-banana
        parsed.size = "16:9";
        break;
    }
  }

  // Validate size based on model
  if (parsed.model === "gpt-image-1") {
    if (!OPENAI_SIZES.includes(parsed.size as OpenAISize)) {
      throw new CLIError(`Invalid size for gpt-image-1: ${parsed.size}. Must be: ${OPENAI_SIZES.join(", ")}`);
    }
  } else if (parsed.model === "nano-banana-pro") {
    if (!GEMINI_SIZES.includes(parsed.size as GeminiSize)) {
      throw new CLIError(`Invalid size for nano-banana-pro: ${parsed.size}. Must be: ${GEMINI_SIZES.join(", ")}`);
    }
    // Validate aspect ratio if provided
    if (parsed.aspectRatio && !GEMINI_ASPECT_RATIOS.includes(parsed.aspectRatio)) {
      throw new CLIError(`Invalid aspect-ratio for nano-banana-pro: ${parsed.aspectRatio}. Must be: ${GEMINI_ASPECT_RATIOS.join(", ")}`);
    }
    // Default to 16:9 if not specified
    if (!parsed.aspectRatio) {
      parsed.aspectRatio = "16:9";
    }
  } else {
    if (!REPLICATE_SIZES.includes(parsed.size as ReplicateSize)) {
      throw new CLIError(`Invalid size for ${parsed.model}: ${parsed.size}. Must be: ${REPLICATE_SIZES.join(", ")}`);
    }
  }

  return parsed as CLIArgs;
}

// ============================================================================
// Prompt Enhancement
// ============================================================================

function enhancePromptForTransparency(prompt: string): string {
  const transparencyPrefix = "CRITICAL: Transparent background (PNG with alpha channel) - NO background color, pure transparency. Object floating in transparent space. ";
  return transparencyPrefix + prompt;
}

// ============================================================================
// Background Removal
// ============================================================================

import { exec } from "node:child_process";
import { promisify } from "node:util";

const execAsync = promisify(exec);

// ============================================================================
// Background Operations
// ============================================================================

/**
 * Add a solid background color to a transparent PNG image
 * Uses ImageMagick to composite the transparent image onto a colored background
 */
async function addBackgroundColor(inputPath: string, outputPath: string, hexColor: string): Promise<void> {
  console.log(`🎨 Adding background color ${hexColor} to image...`);

  // Use ImageMagick to composite the transparent image onto a colored background
  // -background sets the fill color, -flatten composites onto that background
  const command = `magick "${inputPath}" -background "${hexColor}" -flatten "${outputPath}"`;

  try {
    await execAsync(command);
    console.log(`✅ Thumbnail saved to ${outputPath}`);
  } catch (error) {
    throw new CLIError(`Failed to add background color: ${error instanceof Error ? error.message : String(error)}`);
  }
}

async function removeBackground(imagePath: string): Promise<void> {
  const apiKey = process.env.REMOVEBG_API_KEY;
  if (!apiKey) {
    throw new CLIError("Missing environment variable: REMOVEBG_API_KEY");
  }

  console.log("🔲 Removing background with remove.bg API...");

  const imageBuffer = await readFile(imagePath);
  const formData = new FormData();
  formData.append("image_file", new Blob([imageBuffer]), "image.png");
  formData.append("size", "auto");

  const response = await fetch("https://api.remove.bg/v1.0/removebg", {
    method: "POST",
    headers: {
      "X-Api-Key": apiKey,
    },
    body: formData,
  });

  if (!response.ok) {
    const errorText = await response.text();
    throw new CLIError(`remove.bg API error: ${response.status} - ${errorText}`);
  }

  const resultBuffer = Buffer.from(await response.arrayBuffer());
  await writeFile(imagePath, resultBuffer);
  console.log("✅ Background removed successfully");
}

// ============================================================================
// Image Generation
// ============================================================================

async function generateWithFlux(prompt: string, size: ReplicateSize, output: string): Promise<string> {
  const token = process.env.REPLICATE_API_TOKEN;
  if (!token) {
    throw new CLIError("Missing environment variable: REPLICATE_API_TOKEN");
  }

  const replicate = new Replicate({ auth: token });

  console.log("🎨 Generating with Flux 1.1 Pro...");

  const result = await replicate.run("black-forest-labs/flux-1.1-pro", {
    input: {
      prompt,
      aspect_ratio: size,
      output_format: "png",
      output_quality: 95,
      prompt_upsampling: false,
    },
  });

  const finalPath = await saveImage(result, output);
  console.log(`✅ Image saved to ${finalPath}`);
  return finalPath;
}

async function generateWithNanoBanana(prompt: string, size: ReplicateSize, output: string): Promise<string> {
  const token = process.env.REPLICATE_API_TOKEN;
  if (!token) {
    throw new CLIError("Missing environment variable: REPLICATE_API_TOKEN");
  }

  const replicate = new Replicate({ auth: token });

  console.log("🍌 Generating with Nano Banana...");

  const result = await replicate.run("google/nano-banana", {
    input: {
      prompt,
      aspect_ratio: size,
      output_format: "png",
    },
  });

  const finalPath = await saveImage(result, output);
  console.log(`✅ Image saved to ${finalPath}`);
  return finalPath;
}

async function generateWithGPTImage(prompt: string, size: OpenAISize, output: string): Promise<string> {
  const apiKey = process.env.OPENAI_API_KEY;
  if (!apiKey) {
    throw new CLIError("Missing environment variable: OPENAI_API_KEY");
  }

  const openai = new OpenAI({ apiKey });

  console.log("🤖 Generating with GPT-image-1...");

  const response = await openai.images.generate({
    model: "gpt-image-1",
    prompt,
    size,
    n: 1,
  });

  const imageData = response.data[0].b64_json;
  if (!imageData) {
    throw new CLIError("No image data returned from OpenAI API");
  }

  const imageBuffer = Buffer.from(imageData, "base64");
  const finalPath = await saveImage(imageBuffer, output);
  console.log(`✅ Image saved to ${finalPath}`);
  return finalPath;
}

async function generateWithNanoBananaPro(
  prompt: string,
  size: GeminiSize,
  aspectRatio: ReplicateSize,
  output: string,
  referenceImages?: string[]
): Promise<string> {
  const apiKey = process.env.GOOGLE_API_KEY;
  if (!apiKey) {
    throw new CLIError("Missing environment variable: GOOGLE_API_KEY");
  }

  const ai = new GoogleGenAI({ apiKey });

  if (referenceImages && referenceImages.length > 0) {
    console.log(`🍌✨ Generating with Nano Banana Pro (Gemini 3 Pro) at ${size} ${aspectRatio} with ${referenceImages.length} reference image(s)...`);
  } else {
    console.log(`🍌✨ Generating with Nano Banana Pro (Gemini 3 Pro) at ${size} ${aspectRatio}...`);
  }

  // Prepare content parts
  const parts: Array<{ text?: string; inlineData?: { mimeType: string; data: string } }> = [];

  // Add all reference images if provided
  if (referenceImages && referenceImages.length > 0) {
    for (const referenceImage of referenceImages) {
      // Read image file
      const imageBuffer = await readFile(referenceImage);
      const imageBase64 = imageBuffer.toString("base64");

      // Detect MIME type from actual file content (magic bytes), not just extension
      const mimeType = await detectMimeType(referenceImage);

      parts.push({
        inlineData: {
          mimeType,
          data: imageBase64,
        },
      });
    }
  }

  // Add text prompt
  parts.push({ text: prompt });

  const response = await ai.models.generateContent({
    model: "gemini-3-pro-image-preview",
    contents: [{ parts }],
    config: {
      responseModalities: ["TEXT", "IMAGE"],
      imageConfig: {
        aspectRatio: aspectRatio,
        imageSize: size,
      },
    },
  });

  // Extract image data from response
  let imageData: string | undefined;

  if (response.candidates && response.candidates.length > 0) {
    const parts = response.candidates[0].content.parts;
    for (const part of parts) {
      // Check if this part contains inline image data
      if (part.inlineData && part.inlineData.data) {
        imageData = part.inlineData.data;
        break;
      }
    }
  }

  if (!imageData) {
    throw new CLIError("No image data returned from Gemini API");
  }

  const imageBuffer = Buffer.from(imageData, "base64");
  const finalPath = await saveImage(imageBuffer, output);
  console.log(`✅ Image saved to ${finalPath}`);
  return finalPath;
}

// ============================================================================
// Main
// ============================================================================

async function main(): Promise<void> {
  try {
    // Load API keys from ${PAI_DIR}/.env
    await loadEnv();

    const args = parseArgs(process.argv);

    // Enhance prompt for transparency if requested
    const finalPrompt = args.transparent
      ? enhancePromptForTransparency(args.prompt)
      : args.prompt;

    if (args.transparent) {
      console.log("🔲 Transparent background mode enabled");
      console.log("💡 Note: Not all models support transparency natively; may require post-processing\n");
    }

    // Handle creative variations mode
    if (args.creativeVariations && args.creativeVariations > 1) {
      console.log(`🎨 Creative Mode: Generating ${args.creativeVariations} variations...`);
      console.log(`💡 Note: CLI mode uses same prompt for all variations (tests model variability)`);
      console.log(`   For true creative diversity, use the creative workflow with be-creative skill\n`);

      const basePath = args.output.replace(/\.[^.]+$/, "");
      const promises: Promise<string>[] = [];

      for (let i = 1; i <= args.creativeVariations; i++) {
        const varOutput = `${basePath}-v${i}.png`;
        console.log(`Variation ${i}/${args.creativeVariations}: ${varOutput}`);

        if (args.model === "flux") {
          promises.push(generateWithFlux(finalPrompt, args.size as ReplicateSize, varOutput));
        } else if (args.model === "nano-banana") {
          promises.push(generateWithNanoBanana(finalPrompt, args.size as ReplicateSize, varOutput));
        } else if (args.model === "nano-banana-pro") {
          promises.push(
            generateWithNanoBananaPro(
              finalPrompt,
              args.size as GeminiSize,
              args.aspectRatio!,
              varOutput,
              args.referenceImages
            )
          );
        } else if (args.model === "gpt-image-1") {
          promises.push(generateWithGPTImage(finalPrompt, args.size as OpenAISize, varOutput));
        }
      }

      const actualPaths = await Promise.all(promises);
      console.log(`\n✅ Generated ${args.creativeVariations} variations`);
      console.log(`   Files: ${actualPaths.join(", ")}`);
      return;
    }

    // Standard single image generation — track actual output path (may differ if format corrected)
    let actualOutput: string = args.output;
    if (args.model === "flux") {
      actualOutput = await generateWithFlux(finalPrompt, args.size as ReplicateSize, args.output);
    } else if (args.model === "nano-banana") {
      actualOutput = await generateWithNanoBanana(finalPrompt, args.size as ReplicateSize, args.output);
    } else if (args.model === "nano-banana-pro") {
      actualOutput = await generateWithNanoBananaPro(
        finalPrompt,
        args.size as GeminiSize,
        args.aspectRatio!,
        args.output,
        args.referenceImages
      );
    } else if (args.model === "gpt-image-1") {
      actualOutput = await generateWithGPTImage(finalPrompt, args.size as OpenAISize, args.output);
    }

    // Remove background if requested (use actual output path)
    if (args.removeBg) {
      await removeBackground(actualOutput);
    }

    // Add background color if requested (standalone mode)
    if (args.addBg && !args.thumbnail) {
      // For standalone --add-bg, modify the image in place
      const tempPath = actualOutput.replace(/\.[^.]+$/, "-temp.png");
      await addBackgroundColor(actualOutput, tempPath, args.addBg);
      // Replace original with the one with background
      const { rename } = await import("node:fs/promises");
      await rename(tempPath, actualOutput);
    }

    // Generate thumbnail with background color if requested (blog header mode)
    if (args.thumbnail) {
      const thumbPath = actualOutput.replace(/\.[^.]+$/, "-thumb.png");
      const THUMBNAIL_BG_COLOR = "#EAE9DF"; // Brand background color for social previews
      await addBackgroundColor(actualOutput, thumbPath, THUMBNAIL_BG_COLOR);
      console.log(`\n📸 Blog header mode: Created both versions`);
      console.log(`   Transparent: ${actualOutput}`);
      console.log(`   Thumbnail:   ${thumbPath}`);
    }
  } catch (error) {
    handleError(error);
  }
}

main();