@nogataka/imgen 0.1.0

package/dist/index.js

@@ -0,0 +1,1365 @@
+#!/usr/bin/env node
+
+// src/commands/index.ts
+import { Command as Command8 } from "commander";
+
+// src/commands/configure.ts
+import { Command } from "commander";
+import inquirer from "inquirer";
+
+// src/lang.ts
+var LANGUAGE_DESCRIPTIONS = {
+  ja: "\u65E5\u672C\u8A9E",
+  en: "\u82F1\u8A9E",
+  zh: "\u4E2D\u56FD\u8A9E",
+  ko: "\u97D3\u56FD\u8A9E",
+  es: "\u30B9\u30DA\u30A4\u30F3\u8A9E",
+  fr: "\u30D5\u30E9\u30F3\u30B9\u8A9E",
+  de: "\u30C9\u30A4\u30C4\u8A9E",
+  it: "\u30A4\u30BF\u30EA\u30A2\u8A9E",
+  ru: "\u30ED\u30B7\u30A2\u8A9E",
+  vi: "\u30D9\u30C8\u30CA\u30E0\u8A9E"
+};
+
+// src/utils/config.ts
+import * as fs from "fs/promises";
+import * as os from "os";
+import * as path from "path";
+var DEFAULT_CONFIG = {
+  defaultLanguage: "ja",
+  defaultImageSize: "1024x1024",
+  defaultImageQuality: "high",
+  defaultImageFormat: "png",
+  logLevel: "info"
+};
+function getConfigDir() {
+  return path.join(os.homedir(), ".imgen");
+}
+function getConfigPath() {
+  return path.join(getConfigDir(), "config.json");
+}
+async function loadConfig() {
+  try {
+    const text = await fs.readFile(getConfigPath(), "utf-8");
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+async function saveConfig(config) {
+  const configPath = getConfigPath();
+  await fs.mkdir(path.dirname(configPath), { recursive: true });
+  await fs.writeFile(configPath, JSON.stringify(config, null, 2));
+}
+async function getAzureConfig() {
+  const config = await loadConfig();
+  const endpoint = process.env.AZURE_OPENAI_ENDPOINT || config?.azureEndpoint;
+  const apiKey = process.env.AZURE_OPENAI_API_KEY || config?.azureApiKey;
+  const deploymentName = process.env.AZURE_OPENAI_DEPLOYMENT_NAME || config?.azureDeploymentName;
+  const imageDeploymentName = process.env.AZURE_OPENAI_DEPLOYMENT_NAME_IMAGE || config?.azureImageDeploymentName;
+  const apiVersion = process.env.AZURE_OPENAI_API_VERSION || config?.azureApiVersion || "2024-02-15-preview";
+  const imageApiVersion = process.env.AZURE_OPENAI_IMAGE_API_VERSION || config?.azureImageApiVersion || "2025-04-01-preview";
+  if (!endpoint || !apiKey || !deploymentName || !imageDeploymentName) {
+    throw new Error(
+      "Azure OpenAI \u306E\u8A2D\u5B9A\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3002`imgen configure` \u30B3\u30DE\u30F3\u30C9\u3067\u8A2D\u5B9A\u3059\u308B\u304B\u3001\u74B0\u5883\u5909\u6570\u3092\u8A2D\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+    );
+  }
+  return { endpoint, apiKey, deploymentName, imageDeploymentName, apiVersion, imageApiVersion };
+}
+
+// src/commands/configure.ts
+function configureCommand() {
+  return new Command("configure").description("API\u8A2D\u5B9A\u3092\u884C\u3044\u307E\u3059").option("--show", "\u73FE\u5728\u306E\u8A2D\u5B9A\u3092\u8868\u793A").option("--reset", "\u8A2D\u5B9A\u3092\u30EA\u30BB\u30C3\u30C8").action(async (options) => {
+    try {
+      if (options.show) {
+        await showConfig();
+        return;
+      }
+      if (options.reset) {
+        await resetConfig();
+        return;
+      }
+      await interactiveConfig();
+    } catch (error) {
+      if (error instanceof Error) {
+        console.error("\u30A8\u30E9\u30FC:", error.message);
+      } else {
+        console.error("\u4E0D\u660E\u306A\u30A8\u30E9\u30FC\u304C\u767A\u751F\u3057\u307E\u3057\u305F");
+      }
+      process.exit(1);
+    }
+  });
+}
+async function showConfig() {
+  const config = await loadConfig();
+  const configPath = getConfigPath();
+  console.log(`
+\u8A2D\u5B9A\u30D5\u30A1\u30A4\u30EB: ${configPath}
+`);
+  if (!config) {
+    console.log("\u8A2D\u5B9A\u30D5\u30A1\u30A4\u30EB\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3002");
+    console.log("\n\u30C7\u30D5\u30A9\u30EB\u30C8\u5024:");
+    console.log(JSON.stringify(DEFAULT_CONFIG, null, 2));
+    return;
+  }
+  const displayConfig = { ...config };
+  if (displayConfig.azureApiKey) {
+    displayConfig.azureApiKey = "****" + displayConfig.azureApiKey.slice(-4);
+  }
+  console.log("\u73FE\u5728\u306E\u8A2D\u5B9A:");
+  console.log(JSON.stringify(displayConfig, null, 2));
+}
+async function resetConfig() {
+  const { confirm } = await inquirer.prompt([
+    {
+      type: "confirm",
+      name: "confirm",
+      message: "\u8A2D\u5B9A\u3092\u30EA\u30BB\u30C3\u30C8\u3057\u307E\u3059\u304B\uFF1F\uFF08API\u8A2D\u5B9A\u3082\u524A\u9664\u3055\u308C\u307E\u3059\uFF09",
+      default: false
+    }
+  ]);
+  if (confirm) {
+    await saveConfig({});
+    console.log("\u8A2D\u5B9A\u3092\u30EA\u30BB\u30C3\u30C8\u3057\u307E\u3057\u305F\u3002");
+  } else {
+    console.log("\u30AD\u30E3\u30F3\u30BB\u30EB\u3057\u307E\u3057\u305F\u3002");
+  }
+}
+async function interactiveConfig() {
+  const { action } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "action",
+      message: "\u8A2D\u5B9A\u9805\u76EE\u3092\u9078\u629E\u3057\u3066\u304F\u3060\u3055\u3044",
+      choices: [
+        { name: "Azure OpenAI\u63A5\u7D9A\u8A2D\u5B9A", value: "azure" },
+        { name: "\u30C7\u30D5\u30A9\u30EB\u30C8\u5024\u3092\u8A2D\u5B9A", value: "defaults" },
+        { name: "\u73FE\u5728\u306E\u8A2D\u5B9A\u3092\u8868\u793A", value: "show" },
+        { name: "\u8A2D\u5B9A\u3092\u30EA\u30BB\u30C3\u30C8", value: "reset" },
+        { name: "\u7D42\u4E86", value: "exit" }
+      ]
+    }
+  ]);
+  switch (action) {
+    case "azure":
+      await configureAzure();
+      break;
+    case "defaults":
+      await configureDefaults();
+      break;
+    case "show":
+      await showConfig();
+      break;
+    case "reset":
+      await resetConfig();
+      break;
+    case "exit":
+      return;
+  }
+}
+async function configureAzure() {
+  const config = await loadConfig() || {};
+  const envEndpoint = process.env.AZURE_OPENAI_ENDPOINT;
+  const envKey = process.env.AZURE_OPENAI_API_KEY;
+  if (envEndpoint && envKey) {
+    console.log("\n\u74B0\u5883\u5909\u6570\u3067Azure OpenAI\u8A2D\u5B9A\u304C\u691C\u51FA\u3055\u308C\u307E\u3057\u305F\u3002");
+    const { useEnv } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "useEnv",
+        message: "\u74B0\u5883\u5909\u6570\u306E\u5024\u3092\u8A2D\u5B9A\u30D5\u30A1\u30A4\u30EB\u306B\u4FDD\u5B58\u3057\u307E\u3059\u304B\uFF1F",
+        default: true
+      }
+    ]);
+    if (useEnv) {
+      config.azureEndpoint = envEndpoint;
+      config.azureApiKey = envKey;
+      config.azureDeploymentName = process.env.AZURE_OPENAI_DEPLOYMENT_NAME || "gpt-5.1";
+      config.azureImageDeploymentName = process.env.AZURE_OPENAI_DEPLOYMENT_NAME_IMAGE || "gpt-image-1.5";
+      config.azureApiVersion = process.env.AZURE_OPENAI_API_VERSION || "2024-02-15-preview";
+      config.azureImageApiVersion = process.env.AZURE_OPENAI_IMAGE_API_VERSION || "2025-04-01-preview";
+      await saveConfig(config);
+      console.log("\u8A2D\u5B9A\u3092\u4FDD\u5B58\u3057\u307E\u3057\u305F\u3002");
+      return;
+    }
+  }
+  const answers = await inquirer.prompt([
+    {
+      type: "input",
+      name: "endpoint",
+      message: "Azure OpenAI \u30A8\u30F3\u30C9\u30DD\u30A4\u30F3\u30C8:",
+      default: config.azureEndpoint || "",
+      validate: (input) => input.startsWith("https://") || "https:// \u3067\u59CB\u307E\u308BURL\u3092\u5165\u529B\u3057\u3066\u304F\u3060\u3055\u3044"
+    },
+    {
+      type: "password",
+      name: "apiKey",
+      message: "Azure OpenAI API\u30AD\u30FC:",
+      mask: "*",
+      validate: (input) => input.length > 0 || "API\u30AD\u30FC\u3092\u5165\u529B\u3057\u3066\u304F\u3060\u3055\u3044"
+    },
+    {
+      type: "input",
+      name: "deploymentName",
+      message: "\u30C1\u30E3\u30C3\u30C8\u30E2\u30C7\u30EB\u30C7\u30D7\u30ED\u30A4\u540D:",
+      default: config.azureDeploymentName || "gpt-5.1"
+    },
+    {
+      type: "input",
+      name: "imageDeploymentName",
+      message: "\u753B\u50CF\u30E2\u30C7\u30EB\u30C7\u30D7\u30ED\u30A4\u540D:",
+      default: config.azureImageDeploymentName || "gpt-image-1.5"
+    },
+    {
+      type: "input",
+      name: "apiVersion",
+      message: "\u30C1\u30E3\u30C3\u30C8 API \u30D0\u30FC\u30B8\u30E7\u30F3:",
+      default: config.azureApiVersion || "2024-02-15-preview"
+    },
+    {
+      type: "input",
+      name: "imageApiVersion",
+      message: "\u753B\u50CF API \u30D0\u30FC\u30B8\u30E7\u30F3:",
+      default: config.azureImageApiVersion || "2025-04-01-preview"
+    }
+  ]);
+  config.azureEndpoint = answers.endpoint;
+  config.azureApiKey = answers.apiKey;
+  config.azureDeploymentName = answers.deploymentName;
+  config.azureImageDeploymentName = answers.imageDeploymentName;
+  config.azureApiVersion = answers.apiVersion;
+  config.azureImageApiVersion = answers.imageApiVersion;
+  await saveConfig(config);
+  console.log("\nAzure OpenAI\u8A2D\u5B9A\u3092\u4FDD\u5B58\u3057\u307E\u3057\u305F\u3002");
+}
+async function configureDefaults() {
+  const config = await loadConfig() || {};
+  const answers = await inquirer.prompt([
+    {
+      type: "list",
+      name: "language",
+      message: "\u30C7\u30D5\u30A9\u30EB\u30C8\u8A00\u8A9E",
+      choices: Object.entries(LANGUAGE_DESCRIPTIONS).map(([key, value]) => ({
+        name: `${key}: ${value}`,
+        value: key
+      })),
+      default: config.defaultLanguage || DEFAULT_CONFIG.defaultLanguage
+    },
+    {
+      type: "list",
+      name: "imageSize",
+      message: "\u30C7\u30D5\u30A9\u30EB\u30C8\u753B\u50CF\u30B5\u30A4\u30BA",
+      choices: [
+        { name: "1024x1024 (\u6B63\u65B9\u5F62)", value: "1024x1024" },
+        { name: "1536x1024 (\u6A2A\u9577)", value: "1536x1024" },
+        { name: "1024x1536 (\u7E26\u9577)", value: "1024x1536" }
+      ],
+      default: config.defaultImageSize || DEFAULT_CONFIG.defaultImageSize
+    },
+    {
+      type: "list",
+      name: "imageQuality",
+      message: "\u30C7\u30D5\u30A9\u30EB\u30C8\u753B\u50CF\u54C1\u8CEA",
+      choices: [
+        { name: "high (\u9AD8\u54C1\u8CEA)", value: "high" },
+        { name: "medium (\u6A19\u6E96)", value: "medium" },
+        { name: "low (\u9AD8\u901F)", value: "low" }
+      ],
+      default: config.defaultImageQuality || DEFAULT_CONFIG.defaultImageQuality
+    },
+    {
+      type: "list",
+      name: "imageFormat",
+      message: "\u30C7\u30D5\u30A9\u30EB\u30C8\u753B\u50CF\u30D5\u30A9\u30FC\u30DE\u30C3\u30C8",
+      choices: [
+        { name: "PNG", value: "png" },
+        { name: "JPG", value: "jpg" },
+        { name: "WebP", value: "webp" }
+      ],
+      default: config.defaultImageFormat || DEFAULT_CONFIG.defaultImageFormat
+    }
+  ]);
+  config.defaultLanguage = answers.language;
+  config.defaultImageSize = answers.imageSize;
+  config.defaultImageQuality = answers.imageQuality;
+  config.defaultImageFormat = answers.imageFormat;
+  await saveConfig(config);
+  console.log("\n\u30C7\u30D5\u30A9\u30EB\u30C8\u8A2D\u5B9A\u3092\u4FDD\u5B58\u3057\u307E\u3057\u305F\u3002");
+}
+
+// src/commands/image/index.ts
+import { Command as Command5 } from "commander";
+
+// src/commands/image/edit.ts
+import * as fs4 from "fs/promises";
+import * as path3 from "path";
+import { Command as Command2, Option } from "commander";
+
+// src/utils/file.ts
+import * as fs2 from "fs/promises";
+async function generateUniqueFilePath(outputPath, maxRetries = 3) {
+  let finalPath = outputPath;
+  let retryCount = 0;
+  while (retryCount < maxRetries) {
+    try {
+      await fs2.stat(finalPath);
+      const baseName = finalPath.slice(0, finalPath.lastIndexOf("."));
+      const ext = finalPath.slice(finalPath.lastIndexOf("."));
+      const rand = Math.floor(Math.random() * 1e4).toString().padStart(4, "0");
+      finalPath = `${baseName}-${rand}${ext}`;
+      retryCount++;
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return finalPath;
+      }
+      throw error;
+    }
+  }
+  throw new Error(
+    `\u30D5\u30A1\u30A4\u30EB\u540D\u306E\u751F\u6210\u306B\u5931\u6557\u3057\u307E\u3057\u305F\u3002${maxRetries}\u56DE\u8A66\u884C\u3057\u307E\u3057\u305F\u304C\u3001\u3059\u3079\u3066\u65E2\u5B58\u306E\u30D5\u30A1\u30A4\u30EB\u540D\u3068\u885D\u7A81\u3057\u3066\u3044\u307E\u3059\u3002`
+  );
+}
+async function saveFileWithUniqueNameIfExists(outputPath, data, maxRetries = 3) {
+  const finalPath = await generateUniqueFilePath(outputPath, maxRetries);
+  await fs2.writeFile(finalPath, data);
+  return finalPath;
+}
+async function loadContextFile(contextPath) {
+  if (!contextPath) return "";
+  try {
+    return await fs2.readFile(contextPath, "utf-8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new Error(`\u30B3\u30F3\u30C6\u30AD\u30B9\u30C8\u30D5\u30A1\u30A4\u30EB\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093: ${contextPath}`);
+    }
+    if (error instanceof Error) {
+      throw new Error(`\u30B3\u30F3\u30C6\u30AD\u30B9\u30C8\u30D5\u30A1\u30A4\u30EB\u306E\u8AAD\u307F\u8FBC\u307F\u306B\u5931\u6557\u3057\u307E\u3057\u305F: ${error.message}`);
+    }
+    throw new Error(`\u30B3\u30F3\u30C6\u30AD\u30B9\u30C8\u30D5\u30A1\u30A4\u30EB\u306E\u8AAD\u307F\u8FBC\u307F\u306B\u5931\u6557\u3057\u307E\u3057\u305F: ${String(error)}`);
+  }
+}
+async function fileExists(filePath) {
+  try {
+    await fs2.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/utils/azure-chat.ts
+import { AzureOpenAI } from "openai";
+
+// src/utils/logger.ts
+import * as fs3 from "fs/promises";
+import * as path2 from "path";
+import * as os2 from "os";
+import { format } from "date-fns";
+var Logger = class _Logger {
+  constructor(name) {
+    this.name = name;
+    const home = os2.homedir();
+    this.logDir = path2.join(home, ".imgen", "logs");
+    this.currentLogFile = this.generateLogFileName();
+  }
+  static instances = /* @__PURE__ */ new Map();
+  static globalConfig = {
+    destination: "CONSOLE" /* CONSOLE */,
+    minLevel: "INFO" /* INFO */
+  };
+  static currentContext = "default";
+  logDir;
+  currentLogFile;
+  static setGlobalConfig(config) {
+    _Logger.globalConfig = { ..._Logger.globalConfig, ...config };
+  }
+  static setContext(name) {
+    _Logger.currentContext = name;
+  }
+  static getInstance(options) {
+    const { name } = options;
+    if (!_Logger.instances.has(name)) {
+      _Logger.instances.set(name, new _Logger(name));
+    }
+    return _Logger.instances.get(name);
+  }
+  generateLogFileName() {
+    return path2.join(this.logDir, `${this.name}-${format(/* @__PURE__ */ new Date(), "yyyy-MM-dd")}.log`);
+  }
+  async ensureLogDirectory() {
+    await fs3.mkdir(this.logDir, { recursive: true });
+  }
+  formatLogEntry(level, message, data) {
+    return { timestamp: (/* @__PURE__ */ new Date()).toISOString(), level, message, data };
+  }
+  shouldLog(level) {
+    const priority = {
+      ["DEBUG" /* DEBUG */]: 0,
+      ["INFO" /* INFO */]: 1,
+      ["WARN" /* WARN */]: 2,
+      ["ERROR" /* ERROR */]: 3
+    };
+    return priority[level] >= priority[_Logger.globalConfig.minLevel];
+  }
+  async writeLog(entry) {
+    if (!this.shouldLog(entry.level)) return;
+    const { destination } = _Logger.globalConfig;
+    if (destination === "CONSOLE" /* CONSOLE */ || destination === "BOTH" /* BOTH */) {
+      this.writeToConsole(entry);
+    }
+    if (destination === "FILE" /* FILE */ || destination === "BOTH" /* BOTH */) {
+      await this.writeToFile(entry);
+    }
+  }
+  writeToConsole(entry) {
+    const ts = entry.timestamp.replace("T", " ").replace(/\.\d+Z$/, "");
+    const dataStr = entry.data ? ` ${JSON.stringify(entry.data)}` : "";
+    const msg = `[${ts}] [${this.name}] [${entry.level}] ${entry.message}${dataStr}`;
+    switch (entry.level) {
+      case "DEBUG" /* DEBUG */:
+        console.debug(msg);
+        break;
+      case "INFO" /* INFO */:
+        console.info(msg);
+        break;
+      case "WARN" /* WARN */:
+        console.warn(msg);
+        break;
+      case "ERROR" /* ERROR */:
+        console.error(msg);
+        break;
+    }
+  }
+  async writeToFile(entry) {
+    await this.ensureLogDirectory();
+    try {
+      await fs3.appendFile(this.currentLogFile, JSON.stringify(entry) + "\n");
+    } catch (error) {
+      console.error(
+        `\u30ED\u30B0\u306E\u66F8\u304D\u8FBC\u307F\u306B\u5931\u6557\u3057\u307E\u3057\u305F: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  debug(message, data) {
+    return this.writeLog(this.formatLogEntry("DEBUG" /* DEBUG */, message, data));
+  }
+  info(message, data) {
+    return this.writeLog(this.formatLogEntry("INFO" /* INFO */, message, data));
+  }
+  warn(message, data) {
+    return this.writeLog(this.formatLogEntry("WARN" /* WARN */, message, data));
+  }
+  error(message, data) {
+    return this.writeLog(this.formatLogEntry("ERROR" /* ERROR */, message, data));
+  }
+  static debug(message, data) {
+    return _Logger.getInstance({ name: _Logger.currentContext }).debug(message, data);
+  }
+  static info(message, data) {
+    return _Logger.getInstance({ name: _Logger.currentContext }).info(message, data);
+  }
+  static warn(message, data) {
+    return _Logger.getInstance({ name: _Logger.currentContext }).warn(message, data);
+  }
+  static error(message, data) {
+    return _Logger.getInstance({ name: _Logger.currentContext }).error(message, data);
+  }
+  getLatestLogFilePath() {
+    return this.currentLogFile;
+  }
+  async getLogEntries(minLevel = "INFO" /* INFO */, maxEntries = 100) {
+    try {
+      await this.ensureLogDirectory();
+      const content = await fs3.readFile(this.currentLogFile, "utf-8");
+      const lines = content.trim().split("\n");
+      const priority = {
+        ["DEBUG" /* DEBUG */]: 0,
+        ["INFO" /* INFO */]: 1,
+        ["WARN" /* WARN */]: 2,
+        ["ERROR" /* ERROR */]: 3
+      };
+      const entries = [];
+      for (let i = lines.length - 1; i >= 0 && entries.length < maxEntries; i--) {
+        try {
+          const entry = JSON.parse(lines[i]);
+          if (priority[entry.level] >= priority[minLevel]) entries.unshift(entry);
+        } catch {
+          continue;
+        }
+      }
+      return entries;
+    } catch (error) {
+      if (error.code === "ENOENT") return [];
+      throw error;
+    }
+  }
+};
+
+// src/utils/azure-chat.ts
+var AzureChatClient = class {
+  client;
+  deploymentName;
+  logger;
+  constructor(config) {
+    this.client = new AzureOpenAI({
+      endpoint: config.endpoint,
+      apiKey: config.apiKey,
+      apiVersion: config.apiVersion,
+      deployment: config.deploymentName
+    });
+    this.deploymentName = config.deploymentName;
+    this.logger = Logger.getInstance({ name: "azure-chat" });
+  }
+  /**
+   * Generates a detailed image-generation prompt from a short theme description.
+   * Optionally accepts additional context to guide prompt generation.
+   */
+  async generatePrompt(theme, context = "") {
+    if (!theme) throw new Error("\u30C6\u30FC\u30DE\u304C\u7A7A\u3067\u3059");
+    const prompt = `
+Generate a detailed image generation prompt based on the following information.
+
+Theme: ${theme}
+${context ? `Context:
+${context}
+` : ""}
+Please generate a prompt that meets the following criteria:
+1. Include specific and detailed descriptions
+2. Clearly specify the image style and atmosphere
+3. Include all necessary elements
+4. Output in English
+5. Focus on visual elements and composition
+6. Include lighting and color descriptions
+7. Specify the mood and emotional tone
+8. Limit the output to approximately 1500 characters
+
+Prompt:
+`;
+    try {
+      const response = await this.client.chat.completions.create({
+        model: this.deploymentName,
+        messages: [{ role: "user", content: prompt }]
+      });
+      return response.choices[0]?.message?.content ?? "";
+    } catch (error) {
+      this.logger.error("\u30D7\u30ED\u30F3\u30D7\u30C8\u751F\u6210\u306B\u5931\u6557\u3057\u307E\u3057\u305F", { error });
+      throw new Error("\u30D7\u30ED\u30F3\u30D7\u30C8\u306E\u751F\u6210\u306B\u5931\u6557\u3057\u307E\u3057\u305F");
+    }
+  }
+  /**
+   * Generates a sanitized file name (lowercase alphanumeric + hyphens only) from a theme.
+   */
+  async generateFileName(theme, maxLength = 40) {
+    if (!theme) throw new Error("\u30C6\u30FC\u30DE\u304C\u7A7A\u3067\u3059");
+    try {
+      const response = await this.client.chat.completions.create({
+        model: this.deploymentName,
+        messages: [
+          {
+            role: "user",
+            content: `\u4EE5\u4E0B\u306E\u30C6\u30FC\u30DE\u304B\u3089\u753B\u50CF\u306E\u30D5\u30A1\u30A4\u30EB\u540D\u3092\u751F\u6210\u3057\u3066\u304F\u3060\u3055\u3044\u3002\u82F1\u5C0F\u6587\u5B57\u3068\u30CF\u30A4\u30D5\u30F3\u306E\u307F\u3001${maxLength}\u6587\u5B57\u4EE5\u5185\u3002\u62E1\u5F35\u5B50\u306A\u3057\u3002
+
+\u30C6\u30FC\u30DE: ${theme}
+
+\u30D5\u30A1\u30A4\u30EB\u540D:`
+          }
+        ]
+      });
+      let fileName = (response.choices[0]?.message?.content ?? "").trim();
+      fileName = fileName.toLowerCase().replace(/[^a-z0-9-]/g, "").replace(/-+/g, "-").replace(/^-|-$/g, "");
+      if (fileName.length > maxLength) fileName = fileName.substring(0, maxLength);
+      return fileName || "image";
+    } catch (error) {
+      this.logger.error("\u30D5\u30A1\u30A4\u30EB\u540D\u751F\u6210\u306B\u5931\u6557\u3057\u307E\u3057\u305F", { error });
+      throw new Error("\u30D5\u30A1\u30A4\u30EB\u540D\u306E\u751F\u6210\u306B\u5931\u6557\u3057\u307E\u3057\u305F");
+    }
+  }
+  /**
+   * Generates a detailed explanation of an image using multimodal (vision) input.
+   * The explanation language is controlled by the `lang` parameter.
+   */
+  async generateExplanation(imageData, lang = "ja", context) {
+    try {
+      const response = await this.client.chat.completions.create({
+        model: this.deploymentName,
+        messages: [
+          {
+            role: "user",
+            content: [
+              {
+                type: "image_url",
+                image_url: { url: `data:${imageData.mimeType};base64,${imageData.data}` }
+              },
+              {
+                type: "text",
+                text: `\u3053\u306E\u753B\u50CF\u306B\u3064\u3044\u3066\u3001${lang}\u3067\u8A73\u7D30\u306A\u8AAC\u660E\u3092\u751F\u6210\u3057\u3066\u304F\u3060\u3055\u3044\u3002${context ? `
+
+\u30B3\u30F3\u30C6\u30AD\u30B9\u30C8\u60C5\u5831:
+${context}` : ""}`
+              }
+            ]
+          }
+        ]
+      });
+      return response.choices[0]?.message?.content ?? "";
+    } catch (error) {
+      this.logger.error("\u753B\u50CF\u8AAC\u660E\u306E\u751F\u6210\u306B\u5931\u6557\u3057\u307E\u3057\u305F", { error });
+      throw new Error("\u753B\u50CF\u306E\u8AAC\u660E\u751F\u6210\u306B\u5931\u6557\u3057\u307E\u3057\u305F");
+    }
+  }
+};
+
+// src/utils/azure-image.ts
+import { AzureOpenAI as AzureOpenAI2 } from "openai";
+var AzureImageClient = class {
+  client;
+  config;
+  logger;
+  constructor(config) {
+    this.config = config;
+    this.client = new AzureOpenAI2({
+      endpoint: config.endpoint,
+      apiKey: config.apiKey,
+      apiVersion: config.imageApiVersion,
+      deployment: config.imageDeploymentName
+    });
+    this.logger = Logger.getInstance({ name: "azure-image" });
+  }
+  /**
+   * Generates an image from a text prompt using the Azure OpenAI SDK.
+   * Returns raw image bytes as a Uint8Array.
+   */
+  async generateImage(prompt, options) {
+    const { size = "1024x1024", quality = "high" } = options;
+    this.logger.debug("\u753B\u50CF\u751F\u6210\u30EA\u30AF\u30A8\u30B9\u30C8", { prompt: prompt.substring(0, 100), size, quality });
+    try {
+      const response = await this.client.images.generate({
+        model: this.config.imageDeploymentName,
+        prompt,
+        n: 1,
+        size,
+        quality,
+        output_format: "png"
+      });
+      if (!response.data || response.data.length === 0 || !response.data[0].b64_json) {
+        throw new Error("\u753B\u50CF\u30C7\u30FC\u30BF\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093");
+      }
+      const b64 = response.data[0].b64_json;
+      const binary = atob(b64);
+      const bytes = new Uint8Array(binary.length);
+      for (let i = 0; i < binary.length; i++) {
+        bytes[i] = binary.charCodeAt(i);
+      }
+      return bytes;
+    } catch (error) {
+      if (error instanceof Error && error.message === "\u753B\u50CF\u30C7\u30FC\u30BF\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093") throw error;
+      this.logger.error("\u753B\u50CF\u751F\u6210\u306B\u5931\u6557\u3057\u307E\u3057\u305F", { error });
+      throw new Error(
+        `\u753B\u50CF\u751F\u6210\u306B\u5931\u6557\u3057\u307E\u3057\u305F: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * Edits an existing image using the Azure OpenAI REST API.
+   * Uses fetch + FormData because the SDK's image editing support is unreliable.
+   * Returns raw image bytes as a Uint8Array.
+   */
+  async editImage(imageBuffer, prompt, options = {}) {
+    const { size = "1024x1024" } = options;
+    this.logger.debug("\u753B\u50CF\u7DE8\u96C6\u30EA\u30AF\u30A8\u30B9\u30C8 (REST API)", { prompt: prompt.substring(0, 100), size });
+    const url = `${this.config.endpoint}/openai/deployments/${this.config.imageDeploymentName}/images/edits?api-version=${this.config.imageApiVersion}`;
+    const blob = new Blob([imageBuffer], { type: "image/png" });
+    const formData = new FormData();
+    formData.append("image", blob, "image.png");
+    formData.append("prompt", prompt);
+    formData.append("size", size);
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: { "api-key": this.config.apiKey },
+        body: formData
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Azure API error (${response.status}): ${errorText}`);
+      }
+      const json = await response.json();
+      if (!json.data || json.data.length === 0 || !json.data[0].b64_json) {
+        throw new Error("\u753B\u50CF\u30C7\u30FC\u30BF\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093");
+      }
+      const b64 = json.data[0].b64_json;
+      const binary = atob(b64);
+      const bytes = new Uint8Array(binary.length);
+      for (let i = 0; i < binary.length; i++) {
+        bytes[i] = binary.charCodeAt(i);
+      }
+      return bytes;
+    } catch (error) {
+      if (error instanceof Error && error.message === "\u753B\u50CF\u30C7\u30FC\u30BF\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093") throw error;
+      this.logger.error("\u753B\u50CF\u7DE8\u96C6\u306B\u5931\u6557\u3057\u307E\u3057\u305F", { error });
+      throw new Error(
+        `\u753B\u50CF\u7DE8\u96C6\u306B\u5931\u6557\u3057\u307E\u3057\u305F: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+};
+
+// src/utils/output.ts
+function createSuccessOutput(command, result) {
+  return { success: true, command, result };
+}
+function createErrorOutput(command, message, code) {
+  return {
+    success: false,
+    command,
+    error: { message, ...code ? { code } : {} }
+  };
+}
+function printJson(output) {
+  console.log(JSON.stringify(output, null, 2));
+}
+
+// src/commands/image/edit.ts
+var SUPPORTED_EXTENSIONS = [".jpg", ".jpeg", ".png", ".gif", ".webp"];
+function imageEditCommand() {
+  return new Command2("edit").description("\u753B\u50CF\u3092AI\u7DE8\u96C6").argument("<file>", "\u7DE8\u96C6\u3059\u308B\u753B\u50CF\u30D5\u30A1\u30A4\u30EB\u306E\u30D1\u30B9").argument("<prompt>", "\u7DE8\u96C6\u306E\u6307\u793A").option("-o, --output <path>", "\u51FA\u529B\u30D1\u30B9").addOption(
+    new Option("-f, --format <format>", "\u51FA\u529B\u30D5\u30A9\u30FC\u30DE\u30C3\u30C8").choices(["png", "jpg", "webp"]).default("png")
+  ).addOption(
+    new Option("-s, --size <size>", "\u51FA\u529B\u30B5\u30A4\u30BA").choices(["1024x1024", "1536x1024", "1024x1536"]).default("1024x1024")
+  ).option("--json", "JSON\u5F62\u5F0F\u3067\u51FA\u529B", false).option("--dry-run", "\u5B9F\u884C\u305B\u305A\u306B\u8A2D\u5B9A\u3092\u78BA\u8A8D", false).action(async (filePath, prompt, options) => {
+    const ext = path3.extname(filePath).toLowerCase();
+    if (!SUPPORTED_EXTENSIONS.includes(ext)) {
+      const msg = `\u30B5\u30DD\u30FC\u30C8\u3055\u308C\u3066\u3044\u306A\u3044\u30D5\u30A1\u30A4\u30EB\u5F62\u5F0F\u3067\u3059: ${ext}`;
+      if (options.json) {
+        printJson(createErrorOutput("image edit", msg));
+      } else {
+        console.error("\u30A8\u30E9\u30FC:", msg);
+      }
+      process.exit(1);
+    }
+    if (!await fileExists(filePath)) {
+      const msg = `\u30D5\u30A1\u30A4\u30EB\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093: ${filePath}`;
+      if (options.json) {
+        printJson(createErrorOutput("image edit", msg));
+      } else {
+        console.error("\u30A8\u30E9\u30FC:", msg);
+      }
+      process.exit(1);
+    }
+    const config = await loadConfig();
+    const effectiveSize = options.size !== "1024x1024" ? options.size : config?.defaultImageSize || options.size;
+    const effectiveFormat = options.format !== "png" ? options.format : config?.defaultImageFormat || options.format;
+    Logger.setGlobalConfig({ destination: "BOTH" /* BOTH */, minLevel: "INFO" /* INFO */ });
+    const logger = Logger.getInstance({ name: "image-edit" });
+    if (options.dryRun) {
+      const info = {
+        file: filePath,
+        prompt,
+        size: effectiveSize,
+        format: effectiveFormat,
+        output: options.output || "(\u81EA\u52D5\u751F\u6210)"
+      };
+      if (options.json) {
+        printJson(createSuccessOutput("image edit", { dryRun: true, ...info }));
+      } else {
+        console.log("\n[DRY-RUN] \u753B\u50CF\u7DE8\u96C6");
+        console.log("  \u5165\u529B:", filePath);
+        console.log("  \u30D7\u30ED\u30F3\u30D7\u30C8:", prompt);
+        console.log("  \u30B5\u30A4\u30BA:", effectiveSize);
+        console.log("  \u30D5\u30A9\u30FC\u30DE\u30C3\u30C8:", effectiveFormat);
+        console.log("  \u51FA\u529B\u5148:", options.output || "(\u81EA\u52D5\u751F\u6210)");
+        console.log("\nAPI\u306F\u547C\u3073\u51FA\u3055\u308C\u307E\u305B\u3093\u3002\u5B9F\u884C\u3059\u308B\u306B\u306F --dry-run \u3092\u5916\u3057\u3066\u304F\u3060\u3055\u3044\u3002");
+      }
+      return;
+    }
+    try {
+      const azureConfig = await getAzureConfig();
+      const chatClient = new AzureChatClient(azureConfig);
+      const imageClient = new AzureImageClient(azureConfig);
+      const imageBuffer = Buffer.from(await fs4.readFile(filePath));
+      const editedData = await imageClient.editImage(imageBuffer, prompt, {
+        size: effectiveSize
+      });
+      const baseName = path3.basename(filePath, ext);
+      const fileName = await chatClient.generateFileName(`${baseName} edited`);
+      let outputPath;
+      if (options.output) {
+        try {
+          const stat4 = await fs4.stat(options.output);
+          if (stat4.isDirectory()) {
+            outputPath = path3.join(options.output, `${fileName}.${effectiveFormat}`);
+          } else {
+            outputPath = options.output;
+          }
+        } catch {
+          outputPath = options.output;
+        }
+      } else {
+        outputPath = `${fileName}.${effectiveFormat}`;
+      }
+      const finalPath = await saveFileWithUniqueNameIfExists(outputPath, editedData);
+      await logger.info("\u753B\u50CF\u3092\u7DE8\u96C6\u3057\u307E\u3057\u305F", {
+        input: filePath,
+        output: finalPath,
+        size: effectiveSize
+      });
+      if (options.json) {
+        printJson(
+          createSuccessOutput("image edit", {
+            input: filePath,
+            path: finalPath,
+            format: effectiveFormat,
+            size: effectiveSize
+          })
+        );
+      } else {
+        console.log(`\u753B\u50CF\u3092\u7DE8\u96C6\u3057\u307E\u3057\u305F: ${finalPath}`);
+      }
+    } catch (error) {
+      if (error instanceof Error) {
+        await logger.error("\u753B\u50CF\u7DE8\u96C6\u306B\u5931\u6557\u3057\u307E\u3057\u305F", { error: error.message });
+        if (options.json) {
+          printJson(createErrorOutput("image edit", error.message));
+        } else {
+          console.error("\u30A8\u30E9\u30FC:", error.message);
+        }
+      } else {
+        await logger.error("\u4E0D\u660E\u306A\u30A8\u30E9\u30FC\u304C\u767A\u751F\u3057\u307E\u3057\u305F");
+        if (options.json) {
+          printJson(createErrorOutput("image edit", "\u4E0D\u660E\u306A\u30A8\u30E9\u30FC\u304C\u767A\u751F\u3057\u307E\u3057\u305F"));
+        } else {
+          console.error("\u4E0D\u660E\u306A\u30A8\u30E9\u30FC\u304C\u767A\u751F\u3057\u307E\u3057\u305F");
+        }
+      }
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/image/explain.ts
+import * as fs6 from "fs/promises";
+import { Command as Command3 } from "commander";
+
+// src/utils/image.ts
+import * as fs5 from "fs/promises";
+async function readImageFile(filePath) {
+  try {
+    const buffer = await fs5.readFile(filePath);
+    return {
+      data: buffer.toString("base64"),
+      mimeType: getMimeType(filePath)
+    };
+  } catch (error) {
+    if (error instanceof Error && error.message.startsWith("\u30B5\u30DD\u30FC\u30C8\u3055\u308C\u3066\u3044\u306A\u3044")) {
+      throw error;
+    }
+    throw new Error(
+      `\u753B\u50CF\u30D5\u30A1\u30A4\u30EB\u306E\u8AAD\u307F\u8FBC\u307F\u306B\u5931\u6557\u3057\u307E\u3057\u305F: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function getMimeType(filePath) {
+  const ext = filePath.toLowerCase().split(".").pop();
+  const map = {
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    png: "image/png",
+    gif: "image/gif",
+    webp: "image/webp"
+  };
+  if (ext && map[ext]) return map[ext];
+  throw new Error(`\u30B5\u30DD\u30FC\u30C8\u3055\u308C\u3066\u3044\u306A\u3044\u30D5\u30A1\u30A4\u30EB\u5F62\u5F0F\u3067\u3059: .${ext}`);
+}
+
+// src/commands/image/explain.ts
+function imageExplainCommand() {
+  return new Command3("explain").description("\u753B\u50CF\u306E\u5185\u5BB9\u3092\u8AAC\u660E").argument("<file>", "\u753B\u50CF\u30D5\u30A1\u30A4\u30EB\u306E\u30D1\u30B9").option(
+    "-l, --lang <lang>",
+    `\u51FA\u529B\u8A00\u8A9E (${Object.keys(LANGUAGE_DESCRIPTIONS).join(", ")})`,
+    "ja"
+  ).option("-f, --format <format>", "\u51FA\u529B\u30D5\u30A9\u30FC\u30DE\u30C3\u30C8 (markdown | json)", "markdown").option("-c, --context <context>", "\u30B3\u30F3\u30C6\u30AD\u30B9\u30C8\u60C5\u5831").option("-o, --output <path>", "\u51FA\u529B\u30D5\u30A1\u30A4\u30EB\u30D1\u30B9").action(async (filePath, options) => {
+    try {
+      const config = await loadConfig();
+      const lang = options.lang === "ja" && config?.defaultLanguage ? config.defaultLanguage : options.lang;
+      const validLangs = Object.keys(LANGUAGE_DESCRIPTIONS);
+      const effectiveLang = validLangs.includes(lang) ? lang : "ja";
+      const azureConfig = await getAzureConfig();
+      const chatClient = new AzureChatClient(azureConfig);
+      const imageData = await readImageFile(filePath);
+      let context;
+      if (options.context) {
+        if (options.context.endsWith(".md") || options.context.endsWith(".txt")) {
+          context = await fs6.readFile(options.context, "utf-8");
+        } else {
+          context = options.context;
+        }
+      }
+      const explanation = await chatClient.generateExplanation(imageData, effectiveLang, context);
+      let output;
+      if (options.format === "json") {
+        output = JSON.stringify({ file: filePath, type: "image", explanation }, null, 2);
+      } else {
+        output = `# ${filePath}
+
+**\u7A2E\u985E:** \u753B\u50CF
+
+${explanation}`;
+      }
+      if (options.output) {
+        await fs6.writeFile(options.output, output, "utf-8");
+        console.log(`\u8AAC\u660E\u3092\u4FDD\u5B58\u3057\u307E\u3057\u305F: ${options.output}`);
+      } else {
+        console.log(output);
+      }
+    } catch (error) {
+      console.error("\u30A8\u30E9\u30FC:", error instanceof Error ? error.message : "\u4E0D\u660E\u306A\u30A8\u30E9\u30FC");
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/image/gen.ts
+import * as fs8 from "fs/promises";
+import * as path5 from "path";
+import { Command as Command4, Option as Option2 } from "commander";
+
+// src/utils/preset.ts
+import * as fs7 from "fs/promises";
+import * as path4 from "path";
+var BUILTIN_PRESETS = {
+  "builtin:square": { size: "1024x1024", quality: "high" },
+  "builtin:landscape": { size: "1536x1024", quality: "high" },
+  "builtin:portrait": { size: "1024x1536", quality: "high" },
+  "builtin:draft": { size: "1024x1024", quality: "low" },
+  "builtin:photo": { size: "1536x1024", quality: "high" }
+};
+function getPresetsPath() {
+  return path4.join(getConfigDir(), "presets.json");
+}
+async function loadPresets() {
+  try {
+    const text = await fs7.readFile(getPresetsPath(), "utf-8");
+    return JSON.parse(text);
+  } catch {
+    return {};
+  }
+}
+async function savePresets(presets) {
+  const p = getPresetsPath();
+  await fs7.mkdir(path4.dirname(p), { recursive: true });
+  await fs7.writeFile(p, JSON.stringify(presets, null, 2));
+}
+async function getPreset(name) {
+  if (name.startsWith("builtin:") && BUILTIN_PRESETS[name]) {
+    return BUILTIN_PRESETS[name];
+  }
+  const presets = await loadPresets();
+  return presets[name] || null;
+}
+async function savePreset(name, preset) {
+  if (name.startsWith("builtin:")) {
+    throw new Error("\u30D3\u30EB\u30C8\u30A4\u30F3\u30D7\u30EA\u30BB\u30C3\u30C8\u306F\u4E0A\u66F8\u304D\u3067\u304D\u307E\u305B\u3093");
+  }
+  const presets = await loadPresets();
+  presets[name] = preset;
+  await savePresets(presets);
+}
+async function deletePreset(name) {
+  if (name.startsWith("builtin:")) {
+    throw new Error("\u30D3\u30EB\u30C8\u30A4\u30F3\u30D7\u30EA\u30BB\u30C3\u30C8\u306F\u524A\u9664\u3067\u304D\u307E\u305B\u3093");
+  }
+  const presets = await loadPresets();
+  if (!presets[name]) return false;
+  delete presets[name];
+  await savePresets(presets);
+  return true;
+}
+async function listAllPresets() {
+  const result = [];
+  for (const [name, preset] of Object.entries(BUILTIN_PRESETS)) {
+    result.push({ name, preset, builtin: true });
+  }
+  const presets = await loadPresets();
+  for (const [name, preset] of Object.entries(presets)) {
+    result.push({ name, preset, builtin: false });
+  }
+  return result;
+}
+
+// src/commands/image/gen.ts
+var VALID_FORMATS = ["png", "jpg", "webp"];
+function validateImageFormat(ext, specifiedFormat) {
+  if (!VALID_FORMATS.includes(ext)) {
+    throw new Error(`\u30B5\u30DD\u30FC\u30C8\u3055\u308C\u3066\u3044\u306A\u3044\u753B\u50CF\u30D5\u30A9\u30FC\u30DE\u30C3\u30C8\u3067\u3059: ${ext}`);
+  }
+  if (specifiedFormat && ext !== specifiedFormat) {
+    throw new Error(
+      `\u51FA\u529B\u30D5\u30A1\u30A4\u30EB\u306E\u62E1\u5F35\u5B50(${ext})\u3068\u6307\u5B9A\u3055\u308C\u305F\u30D5\u30A9\u30FC\u30DE\u30C3\u30C8(${specifiedFormat})\u304C\u4E00\u81F4\u3057\u307E\u305B\u3093`
+    );
+  }
+}
+async function resolveOutputPath(outputPath, defaultFormat, fileName) {
+  let format2 = defaultFormat;
+  if (!outputPath) {
+    return { path: `${fileName}.${format2}`, format: format2 };
+  }
+  try {
+    const stat4 = await fs8.stat(outputPath);
+    if (stat4.isDirectory()) {
+      return { path: path5.join(outputPath, `${fileName}.${format2}`), format: format2 };
+    }
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  const ext = path5.extname(outputPath).toLowerCase().slice(1);
+  if (ext) {
+    validateImageFormat(ext, defaultFormat);
+    format2 = ext;
+  } else {
+    outputPath = `${outputPath}.${format2}`;
+  }
+  return { path: outputPath, format: format2 };
+}
+function imageGenCommand() {
+  return new Command4("gen").description("\u30C6\u30AD\u30B9\u30C8\u304B\u3089\u753B\u50CF\u3092\u751F\u6210").argument("<theme>", "\u753B\u50CF\u751F\u6210\u306E\u30C6\u30FC\u30DE").option("-c, --context <file>", "\u30B3\u30F3\u30C6\u30AD\u30B9\u30C8\u30D5\u30A1\u30A4\u30EB\u306E\u30D1\u30B9").option("-o, --output <path>", "\u51FA\u529B\u30D1\u30B9\uFF08\u30D5\u30A1\u30A4\u30EB\u307E\u305F\u306F\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\uFF09").addOption(
+    new Option2("-s, --size <size>", "\u753B\u50CF\u30B5\u30A4\u30BA").choices(["1024x1024", "1536x1024", "1024x1536"]).default("1024x1024")
+  ).addOption(
+    new Option2("-q, --quality <quality>", "\u753B\u50CF\u54C1\u8CEA").choices(["low", "medium", "high"]).default("high")
+  ).addOption(
+    new Option2("-f, --format <format>", "\u753B\u50CF\u30D5\u30A9\u30FC\u30DE\u30C3\u30C8").choices(["png", "jpg", "webp"]).default("png")
+  ).option("-d, --debug", "\u30C7\u30D0\u30C3\u30B0\u30E2\u30FC\u30C9", false).option("--json", "JSON\u5F62\u5F0F\u3067\u51FA\u529B", false).option("--dry-run", "\u5B9F\u884C\u305B\u305A\u306B\u8A2D\u5B9A\u3092\u78BA\u8A8D", false).option("-p, --preset <name>", "\u30D7\u30EA\u30BB\u30C3\u30C8\u540D").action(async (theme, options) => {
+    if (!theme) {
+      console.log("\u30C6\u30FC\u30DE\u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044");
+      process.exit(1);
+    }
+    let presetSize;
+    let presetQuality;
+    let presetFormat;
+    if (options.preset) {
+      const preset = await getPreset(options.preset);
+      if (!preset) {
+        const errorMsg = `\u30D7\u30EA\u30BB\u30C3\u30C8 '${options.preset}' \u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3002
+imgen preset list \u3067\u4E00\u89A7\u3092\u78BA\u8A8D\u3057\u3066\u304F\u3060\u3055\u3044\u3002`;
+        if (options.json) {
+          printJson(createErrorOutput("image gen", errorMsg, "PRESET_NOT_FOUND"));
+        } else {
+          console.error("\u30A8\u30E9\u30FC:", errorMsg);
+        }
+        process.exit(1);
+      }
+      presetSize = preset.size;
+      presetQuality = preset.quality;
+      presetFormat = preset.format;
+    }
+    const config = await loadConfig();
+    const effectiveSize = options.size !== "1024x1024" ? options.size : presetSize || config?.defaultImageSize || options.size;
+    const effectiveQuality = options.quality !== "high" ? options.quality : presetQuality || config?.defaultImageQuality || options.quality;
+    const effectiveFormat = options.format !== "png" ? options.format : presetFormat || config?.defaultImageFormat || options.format;
+    Logger.setGlobalConfig({
+      destination: "BOTH" /* BOTH */,
+      minLevel: options.debug ? "DEBUG" /* DEBUG */ : "INFO" /* INFO */
+    });
+    const logger = Logger.getInstance({ name: "image-gen" });
+    if (options.dryRun) {
+      const dryRunInfo = {
+        theme,
+        size: effectiveSize,
+        quality: effectiveQuality,
+        format: effectiveFormat,
+        output: options.output || `(\u81EA\u52D5\u751F\u6210).${effectiveFormat}`,
+        ...options.preset ? { preset: options.preset } : {},
+        ...options.context ? { context: options.context } : {}
+      };
+      if (options.json) {
+        printJson(createSuccessOutput("image gen", { dryRun: true, ...dryRunInfo }));
+      } else {
+        console.log("\n[DRY-RUN] \u753B\u50CF\u751F\u6210");
+        console.log("  \u30C6\u30FC\u30DE:", theme);
+        if (options.preset) console.log("  \u30D7\u30EA\u30BB\u30C3\u30C8:", options.preset);
+        console.log("  \u30B5\u30A4\u30BA:", effectiveSize);
+        console.log("  \u54C1\u8CEA:", effectiveQuality);
+        console.log("  \u30D5\u30A9\u30FC\u30DE\u30C3\u30C8:", effectiveFormat);
+        if (options.context) console.log("  \u30B3\u30F3\u30C6\u30AD\u30B9\u30C8:", options.context);
+        console.log("  \u51FA\u529B\u5148:", options.output || `(\u81EA\u52D5\u751F\u6210).${effectiveFormat}`);
+        console.log("\nAPI\u306F\u547C\u3073\u51FA\u3055\u308C\u307E\u305B\u3093\u3002\u5B9F\u884C\u3059\u308B\u306B\u306F --dry-run \u3092\u5916\u3057\u3066\u304F\u3060\u3055\u3044\u3002");
+      }
+      return;
+    }
+    try {
+      const azureConfig = await getAzureConfig();
+      const chatClient = new AzureChatClient(azureConfig);
+      const imageClient = new AzureImageClient(azureConfig);
+      const context = await loadContextFile(options.context);
+      const prompt = await chatClient.generatePrompt(theme, context);
+      if (options.debug) {
+        await logger.debug("\u751F\u6210\u3055\u308C\u305F\u30D7\u30ED\u30F3\u30D7\u30C8", { prompt, theme });
+      }
+      const imageData = await imageClient.generateImage(prompt, {
+        size: effectiveSize,
+        quality: effectiveQuality
+      });
+      const fileName = await chatClient.generateFileName(theme);
+      const { path: outputPath, format: format2 } = await resolveOutputPath(
+        options.output,
+        effectiveFormat,
+        fileName
+      );
+      const finalOutputPath = await saveFileWithUniqueNameIfExists(outputPath, imageData);
+      await logger.info("\u753B\u50CF\u3092\u751F\u6210\u3057\u307E\u3057\u305F", {
+        path: finalOutputPath,
+        format: format2,
+        size: effectiveSize,
+        quality: effectiveQuality,
+        ...options.preset ? { preset: options.preset } : {}
+      });
+      if (options.json) {
+        printJson(
+          createSuccessOutput("image gen", {
+            path: finalOutputPath,
+            format: format2,
+            size: effectiveSize,
+            quality: effectiveQuality,
+            ...options.preset ? { preset: options.preset } : {}
+          })
+        );
+      } else {
+        console.log(`\u753B\u50CF\u3092\u751F\u6210\u3057\u307E\u3057\u305F: ${finalOutputPath}`);
+      }
+    } catch (error) {
+      if (error instanceof Error) {
+        await logger.error("\u753B\u50CF\u751F\u6210\u306B\u5931\u6557\u3057\u307E\u3057\u305F", { error: error.message });
+        if (options.json) {
+          printJson(createErrorOutput("image gen", error.message));
+        } else {
+          console.error("\u30A8\u30E9\u30FC:", error.message);
+        }
+      } else {
+        await logger.error("\u4E0D\u660E\u306A\u30A8\u30E9\u30FC\u304C\u767A\u751F\u3057\u307E\u3057\u305F");
+        if (options.json) {
+          printJson(createErrorOutput("image gen", "\u4E0D\u660E\u306A\u30A8\u30E9\u30FC\u304C\u767A\u751F\u3057\u307E\u3057\u305F"));
+        } else {
+          console.error("\u4E0D\u660E\u306A\u30A8\u30E9\u30FC\u304C\u767A\u751F\u3057\u307E\u3057\u305F");
+        }
+      }
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/image/index.ts
+function imageCommand() {
+  const image = new Command5("image").description("\u753B\u50CF\u751F\u6210\u30FB\u7DE8\u96C6\u30FB\u8AAC\u660E (gpt-image-1.5 / gpt-5.1)");
+  image.addCommand(imageGenCommand());
+  image.addCommand(imageEditCommand());
+  image.addCommand(imageExplainCommand());
+  return image;
+}
+
+// src/commands/log.ts
+import chalk from "chalk";
+import { Command as Command6 } from "commander";
+function parseLogLevel(level) {
+  switch (level.toLowerCase()) {
+    case "debug":
+      return "DEBUG" /* DEBUG */;
+    case "info":
+      return "INFO" /* INFO */;
+    case "warn":
+      return "WARN" /* WARN */;
+    case "error":
+      return "ERROR" /* ERROR */;
+    default:
+      return "INFO" /* INFO */;
+  }
+}
+function displayLogs(entries) {
+  for (const entry of entries) {
+    const timestamp = entry.timestamp.replace("T", " ").replace(/\.\d+Z$/, "");
+    let levelColor;
+    switch (entry.level) {
+      case "DEBUG" /* DEBUG */:
+        levelColor = chalk.gray;
+        break;
+      case "INFO" /* INFO */:
+        levelColor = chalk.blue;
+        break;
+      case "WARN" /* WARN */:
+        levelColor = chalk.yellow;
+        break;
+      case "ERROR" /* ERROR */:
+        levelColor = chalk.red;
+        break;
+      default:
+        levelColor = chalk.white;
+    }
+    const levelText = levelColor(entry.level);
+    const dataText = entry.data ? ` ${JSON.stringify(entry.data)}` : "";
+    console.log(`[${timestamp}] ${levelText} ${entry.message}${dataText}`);
+  }
+}
+function logCommand() {
+  return new Command6("log").description("\u30ED\u30B0\u3092\u8868\u793A\u3057\u307E\u3059").option("-n, --lines <lines>", "\u8868\u793A\u3059\u308B\u884C\u6570", "20").option("-l, --level <level>", "\u8868\u793A\u3059\u308B\u30ED\u30B0\u30EC\u30D9\u30EB (debug, info, warn, error)", "info").action(async (options) => {
+    const lines = parseInt(options.lines, 10) || 20;
+    const logLevel = parseLogLevel(options.level);
+    const logger = Logger.getInstance({
+      name: "imgen",
+      config: { destination: "CONSOLE" /* CONSOLE */ }
+    });
+    try {
+      const entries = await logger.getLogEntries(logLevel, lines);
+      if (entries.length === 0) {
+        console.log("\u30ED\u30B0\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3067\u3057\u305F");
+        return;
+      }
+      displayLogs(entries);
+    } catch (error) {
+      console.error(
+        `\u30ED\u30B0\u306E\u53D6\u5F97\u306B\u5931\u6557\u3057\u307E\u3057\u305F: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  });
+}
+
+// src/commands/preset.ts
+import { Command as Command7 } from "commander";
+function presetCommand() {
+  const preset = new Command7("preset").description("\u753B\u50CF\u751F\u6210\u30D7\u30EA\u30BB\u30C3\u30C8\u3092\u7BA1\u7406\u3057\u307E\u3059");
+  preset.command("list").description("\u30D7\u30EA\u30BB\u30C3\u30C8\u4E00\u89A7\u3092\u8868\u793A").option("--json", "JSON\u5F62\u5F0F\u3067\u51FA\u529B").action(async (options) => {
+    try {
+      const presets = await listAllPresets();
+      if (options.json) {
+        console.log(JSON.stringify(presets, null, 2));
+        return;
+      }
+      console.log(`
+\u30D7\u30EA\u30BB\u30C3\u30C8\u4E00\u89A7 (${getPresetsPath()})
+`);
+      if (presets.length === 0) {
+        console.log("\u30D7\u30EA\u30BB\u30C3\u30C8\u304C\u3042\u308A\u307E\u305B\u3093\u3002");
+        return;
+      }
+      const builtins = presets.filter((p) => p.builtin);
+      if (builtins.length > 0) {
+        console.log("\u30D3\u30EB\u30C8\u30A4\u30F3\u30D7\u30EA\u30BB\u30C3\u30C8:");
+        for (const { name, preset: preset2 } of builtins) {
+          console.log(`  ${name}`);
+          formatPreset(preset2, "    ");
+        }
+        console.log();
+      }
+      const userDefined = presets.filter((p) => !p.builtin);
+      if (userDefined.length > 0) {
+        console.log("\u30E6\u30FC\u30B6\u30FC\u5B9A\u7FA9\u30D7\u30EA\u30BB\u30C3\u30C8:");
+        for (const { name, preset: preset2 } of userDefined) {
+          console.log(`  ${name}`);
+          formatPreset(preset2, "    ");
+        }
+      }
+    } catch (error) {
+      if (error instanceof Error) {
+        console.error("\u30A8\u30E9\u30FC:", error.message);
+      } else {
+        console.error("\u4E0D\u660E\u306A\u30A8\u30E9\u30FC\u304C\u767A\u751F\u3057\u307E\u3057\u305F");
+      }
+      process.exit(1);
+    }
+  });
+  preset.command("save <name>").description("\u65B0\u3057\u3044\u30D7\u30EA\u30BB\u30C3\u30C8\u3092\u4FDD\u5B58").option("-s, --size <size>", "\u753B\u50CF\u30B5\u30A4\u30BA (1024x1024, 1536x1024, 1024x1536)").option("-q, --quality <quality>", "\u753B\u50CF\u54C1\u8CEA (low, medium, high)").option("-f, --format <format>", "\u753B\u50CF\u30D5\u30A9\u30FC\u30DE\u30C3\u30C8 (png, jpg, webp)").action(
+    async (name, options) => {
+      try {
+        const preset2 = {};
+        if (options.size) preset2.size = options.size;
+        if (options.quality) preset2.quality = options.quality;
+        if (options.format) preset2.format = options.format;
+        if (Object.keys(preset2).length === 0) {
+          console.error("\u30A8\u30E9\u30FC: \u5C11\u306A\u304F\u3068\u30821\u3064\u306E\u30AA\u30D7\u30B7\u30E7\u30F3\u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044");
+          process.exit(1);
+        }
+        await savePreset(name, preset2);
+        console.log(`\u30D7\u30EA\u30BB\u30C3\u30C8 '${name}' \u3092\u4FDD\u5B58\u3057\u307E\u3057\u305F\u3002`);
+      } catch (error) {
+        if (error instanceof Error) {
+          console.error("\u30A8\u30E9\u30FC:", error.message);
+        } else {
+          console.error("\u4E0D\u660E\u306A\u30A8\u30E9\u30FC\u304C\u767A\u751F\u3057\u307E\u3057\u305F");
+        }
+        process.exit(1);
+      }
+    }
+  );
+  preset.command("delete <name>").description("\u30D7\u30EA\u30BB\u30C3\u30C8\u3092\u524A\u9664").action(async (name) => {
+    try {
+      const deleted = await deletePreset(name);
+      if (deleted) {
+        console.log(`\u30D7\u30EA\u30BB\u30C3\u30C8 '${name}' \u3092\u524A\u9664\u3057\u307E\u3057\u305F\u3002`);
+      } else {
+        console.error(`\u30D7\u30EA\u30BB\u30C3\u30C8 '${name}' \u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3002`);
+        process.exit(1);
+      }
+    } catch (error) {
+      if (error instanceof Error) {
+        console.error("\u30A8\u30E9\u30FC:", error.message);
+      } else {
+        console.error("\u4E0D\u660E\u306A\u30A8\u30E9\u30FC\u304C\u767A\u751F\u3057\u307E\u3057\u305F");
+      }
+      process.exit(1);
+    }
+  });
+  return preset;
+}
+function formatPreset(preset, indent) {
+  if (preset.size) console.log(`${indent}\u30B5\u30A4\u30BA: ${preset.size}`);
+  if (preset.quality) console.log(`${indent}\u54C1\u8CEA: ${preset.quality}`);
+  if (preset.format) console.log(`${indent}\u30D5\u30A9\u30FC\u30DE\u30C3\u30C8: ${preset.format}`);
+}
+
+// src/commands/index.ts
+function createMainCommand() {
+  const program = new Command8().name("imgen").version("0.1.0").description("Azure OpenAI \u753B\u50CF\u751F\u6210\u30FB\u7DE8\u96C6\u30FB\u8AAC\u660E\u30C4\u30FC\u30EB - gpt-image-1.5 / gpt-5.1").addHelpText(
+    "before",
+    `
+\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
+\u2551                                                               \u2551
+\u2551   imgen - Azure OpenAI Image Generation CLI                   \u2551
+\u2551                                                               \u2551
+\u2551   gpt-image-1.5    \u753B\u50CF\u751F\u6210\u30FB\u7DE8\u96C6                              \u2551
+\u2551   gpt-5.1          \u30D7\u30ED\u30F3\u30D7\u30C8\u62E1\u5F35\u30FB\u753B\u50CF\u8AAC\u660E                     \u2551
+\u2551                                                               \u2551
+\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
+`
+  ).addHelpText(
+    "after",
+    `
+\u4F7F\u7528\u4F8B:
+  $ imgen image gen "\u5915\u65E5\u306E\u6D77\u8FBA" -q high -t vivid
+  $ imgen image gen "\u53EF\u611B\u3044\u732B" -s 1024x1024 -p builtin:square
+  $ imgen image edit photo.png "\u80CC\u666F\u3092\u9752\u7A7A\u306B"
+  $ imgen image explain screenshot.png -l en
+
+\u30AF\u30A4\u30C3\u30AF\u30B9\u30BF\u30FC\u30C8:
+  1. \u8A2D\u5B9A: imgen configure
+  2. \u753B\u50CF\u751F\u6210: imgen image gen "\u30C6\u30FC\u30DE"
+`
+  ).action(() => {
+    program.help();
+  });
+  program.addCommand(imageCommand());
+  program.addCommand(presetCommand());
+  program.addCommand(configureCommand());
+  program.addCommand(logCommand());
+  return program;
+}
+
+// src/index.ts
+async function runCli() {
+  try {
+    const program = createMainCommand();
+    await program.parseAsync(process.argv);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+runCli();