@mrgoonie/multix 0.0.2

package/dist/cli.js

@@ -0,0 +1,2234 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/core/errors.ts
+var MultixError, ConfigError, ProviderError, ValidationError, HttpError;
+var init_errors = __esm({
+  "src/core/errors.ts"() {
+    "use strict";
+    MultixError = class extends Error {
+      constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = "MultixError";
+        if (Error.captureStackTrace) {
+          Error.captureStackTrace(this, this.constructor);
+        }
+      }
+      code;
+    };
+    ConfigError = class extends MultixError {
+      constructor(message) {
+        super(message, "CONFIG_ERROR");
+        this.name = "ConfigError";
+      }
+    };
+    ProviderError = class extends MultixError {
+      constructor(message, provider) {
+        super(message, "PROVIDER_ERROR");
+        this.provider = provider;
+        this.name = "ProviderError";
+      }
+      provider;
+    };
+    ValidationError = class extends MultixError {
+      constructor(message) {
+        super(message, "VALIDATION_ERROR");
+        this.name = "ValidationError";
+      }
+    };
+    HttpError = class extends MultixError {
+      constructor(status, snippet, url) {
+        super(`HTTP ${status} from ${url}: ${snippet}`, "HTTP_ERROR");
+        this.status = status;
+        this.snippet = snippet;
+        this.url = url;
+        this.name = "HttpError";
+      }
+      status;
+      snippet;
+      url;
+    };
+  }
+});
+
+// src/core/http-client.ts
+var http_client_exports = {};
+__export(http_client_exports, {
+  downloadFile: () => downloadFile,
+  fetchBytes: () => fetchBytes,
+  httpJson: () => httpJson
+});
+import fs2 from "fs";
+import path2 from "path";
+import { pipeline } from "stream/promises";
+async function httpJson(opts) {
+  const { url, method = "GET", headers = {}, body, timeoutMs = DEFAULT_TIMEOUT_MS } = opts;
+  const init = {
+    method,
+    headers: {
+      "Content-Type": "application/json",
+      ...headers
+    },
+    signal: AbortSignal.timeout(timeoutMs)
+  };
+  if (body !== void 0) {
+    init.body = JSON.stringify(body);
+  }
+  let response;
+  try {
+    response = await globalThis.fetch(url, init);
+  } catch (cause) {
+    const msg = cause instanceof Error ? cause.message : String(cause);
+    throw new HttpError(0, msg, url);
+  }
+  if (!response.ok) {
+    let snippet = "";
+    try {
+      const text = await response.text();
+      snippet = text.slice(0, SNIPPET_MAX);
+    } catch {
+      snippet = "(could not read body)";
+    }
+    throw new HttpError(response.status, snippet, url);
+  }
+  return response.json();
+}
+async function downloadFile(url, dest, timeoutMs = DEFAULT_TIMEOUT_MS) {
+  fs2.mkdirSync(path2.dirname(dest), { recursive: true });
+  let response;
+  try {
+    response = await globalThis.fetch(url, { signal: AbortSignal.timeout(timeoutMs) });
+  } catch (cause) {
+    const msg = cause instanceof Error ? cause.message : String(cause);
+    throw new HttpError(0, msg, url);
+  }
+  if (!response.ok) {
+    throw new HttpError(response.status, "(download failed)", url);
+  }
+  if (!response.body) {
+    throw new HttpError(0, "Response body is null", url);
+  }
+  const fileStream = fs2.createWriteStream(dest);
+  await pipeline(response.body, fileStream);
+}
+async function fetchBytes(urlOrDataUri) {
+  if (urlOrDataUri.startsWith("data:")) {
+    const commaIdx = urlOrDataUri.indexOf(",");
+    if (commaIdx === -1) throw new Error("Malformed data URI: missing comma");
+    const encoded = urlOrDataUri.slice(commaIdx + 1);
+    return Buffer.from(encoded, "base64");
+  }
+  let response;
+  try {
+    response = await globalThis.fetch(urlOrDataUri, {
+      signal: AbortSignal.timeout(DEFAULT_TIMEOUT_MS)
+    });
+  } catch (cause) {
+    const msg = cause instanceof Error ? cause.message : String(cause);
+    throw new HttpError(0, msg, urlOrDataUri);
+  }
+  if (!response.ok) {
+    throw new HttpError(response.status, "(bytes fetch failed)", urlOrDataUri);
+  }
+  return Buffer.from(await response.arrayBuffer());
+}
+var DEFAULT_TIMEOUT_MS, SNIPPET_MAX;
+var init_http_client = __esm({
+  "src/core/http-client.ts"() {
+    "use strict";
+    init_errors();
+    DEFAULT_TIMEOUT_MS = 12e4;
+    SNIPPET_MAX = 500;
+  }
+});
+
+// src/cli.ts
+import { createRequire } from "module";
+import { Command } from "commander";
+
+// src/providers/gemini/commands/analyze.ts
+init_errors();
+import fs5 from "fs";
+
+// src/core/logger.ts
+var ANSI = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  red: "\x1B[31m",
+  blue: "\x1B[34m",
+  cyan: "\x1B[36m",
+  dim: "\x1B[2m"
+};
+function c(color, text) {
+  if (process.env.NO_COLOR || !process.stdout.isTTY) return text;
+  return `${color}${text}${ANSI.reset}`;
+}
+function createLogger(opts) {
+  const { verbose } = opts;
+  return {
+    info(msg) {
+      console.log(c(ANSI.blue, `  ${msg}`));
+    },
+    success(msg) {
+      console.log(c(ANSI.green, `\u2713 ${msg}`));
+    },
+    warn(msg) {
+      console.warn(c(ANSI.yellow, `\u26A0 ${msg}`));
+    },
+    error(msg) {
+      console.error(c(ANSI.red, `\u2717 ${msg}`));
+    },
+    debug(msg) {
+      if (verbose) console.log(c(ANSI.dim, `  [debug] ${msg}`));
+    },
+    header(msg) {
+      const line = "=".repeat(60);
+      console.log(c(ANSI.bold + ANSI.cyan, `
+${line}
+${msg}
+${line}
+`));
+    }
+  };
+}
+var defaultLogger = createLogger({ verbose: false });
+
+// src/providers/gemini/client.ts
+import fs3 from "fs";
+import path4 from "path";
+
+// src/core/env-loader.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { config as dotenvConfig } from "dotenv";
+var loaded = false;
+function loadEnv() {
+  if (loaded) return;
+  loaded = true;
+  const cwdEnv = path.resolve(process.cwd(), ".env");
+  if (fs.existsSync(cwdEnv)) {
+    dotenvConfig({ path: cwdEnv, override: false });
+  }
+  if (!process.env.MULTIX_DISABLE_HOME_ENV) {
+    const homeEnv = path.join(os.homedir(), ".multix", ".env");
+    if (fs.existsSync(homeEnv)) {
+      dotenvConfig({ path: homeEnv, override: false });
+    }
+  }
+}
+function resolveKey(name) {
+  return process.env[name] || void 0;
+}
+function redact(key) {
+  if (key.length <= 10) return "***";
+  return `${key.slice(0, 6)}...${key.slice(-4)}`;
+}
+
+// src/providers/gemini/client.ts
+init_errors();
+init_http_client();
+
+// src/providers/gemini/task-resolver.ts
+import path3 from "path";
+var MIME_MAP = {
+  // Audio
+  ".mp3": "audio/mp3",
+  ".wav": "audio/wav",
+  ".aac": "audio/aac",
+  ".flac": "audio/flac",
+  ".ogg": "audio/ogg",
+  ".aiff": "audio/aiff",
+  ".m4a": "audio/mp4",
+  // Image
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".webp": "image/webp",
+  ".heic": "image/heic",
+  ".heif": "image/heif",
+  ".gif": "image/gif",
+  ".bmp": "image/bmp",
+  // Video
+  ".mp4": "video/mp4",
+  ".mpeg": "video/mpeg",
+  ".mov": "video/quicktime",
+  ".avi": "video/x-msvideo",
+  ".flv": "video/x-flv",
+  ".mpg": "video/mpeg",
+  ".webm": "video/webm",
+  ".wmv": "video/x-ms-wmv",
+  ".3gpp": "video/3gpp",
+  // Document
+  ".pdf": "application/pdf",
+  ".txt": "text/plain",
+  ".html": "text/html",
+  ".htm": "text/html",
+  ".md": "text/markdown",
+  ".csv": "text/csv",
+  ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation"
+};
+function getMimeType(filePath) {
+  const ext = path3.extname(filePath).toLowerCase();
+  return MIME_MAP[ext] ?? "application/octet-stream";
+}
+function requiresProcessingWait(mimeType) {
+  return mimeType.startsWith("audio/") || mimeType.startsWith("video/");
+}
+
+// src/providers/gemini/client.ts
+var BASE = "https://generativelanguage.googleapis.com";
+var FILES_BASE = `${BASE}/upload/v1beta/files`;
+var GENERATE_BASE = `${BASE}/v1beta/models`;
+function requireApiKey() {
+  const key = resolveKey("GEMINI_API_KEY");
+  if (!key)
+    throw new ConfigError(
+      "GEMINI_API_KEY is not set. Get one at https://aistudio.google.com/apikey"
+    );
+  return key;
+}
+function authHeaders(apiKey) {
+  return { "x-goog-api-key": apiKey };
+}
+async function uploadFile(filePath, opts = {}) {
+  const apiKey = requireApiKey();
+  const { timeoutMs = 3e5, logger } = opts;
+  const mimeType = getMimeType(filePath);
+  const fileBytes = fs3.readFileSync(filePath);
+  const displayName = path4.basename(filePath);
+  const boundary = `multix_${Date.now()}`;
+  const metaJson = JSON.stringify({ file: { displayName, mimeType } });
+  const body = Buffer.concat([
+    Buffer.from(
+      `--${boundary}\r
+Content-Type: application/json; charset=UTF-8\r
+\r
+${metaJson}\r
+--${boundary}\r
+Content-Type: ${mimeType}\r
+\r
+`
+    ),
+    fileBytes,
+    Buffer.from(`\r
+--${boundary}--`)
+  ]);
+  logger?.debug(`Uploading ${displayName} (${(fileBytes.length / 1024 / 1024).toFixed(2)} MB)`);
+  const resp = await globalThis.fetch(FILES_BASE, {
+    method: "POST",
+    headers: {
+      "x-goog-api-key": apiKey,
+      "Content-Type": `multipart/related; boundary=${boundary}`,
+      "Content-Length": String(body.length),
+      "X-Goog-Upload-Protocol": "multipart"
+    },
+    body,
+    signal: AbortSignal.timeout(timeoutMs)
+  });
+  if (!resp.ok) {
+    const txt = await resp.text();
+    throw new ProviderError(
+      `File upload failed (HTTP ${resp.status}): ${txt.slice(0, 500)}`,
+      "gemini"
+    );
+  }
+  const data = await resp.json();
+  let fileRef = data.file;
+  if (requiresProcessingWait(mimeType)) {
+    const deadline = Date.now() + timeoutMs;
+    while (fileRef.state === "PROCESSING" && Date.now() < deadline) {
+      await sleep(2e3);
+      fileRef = await httpJson({
+        url: `${BASE}/v1beta/${fileRef.name}`,
+        headers: authHeaders(apiKey)
+      }).then((r) => r.file);
+      logger?.debug(`Processing... state=${fileRef.state}`);
+    }
+    if (fileRef.state === "FAILED")
+      throw new ProviderError(`File processing failed: ${filePath}`, "gemini");
+    if (fileRef.state === "PROCESSING")
+      throw new ProviderError(`Processing timeout: ${filePath}`, "gemini");
+  }
+  logger?.debug(`Uploaded: ${fileRef.name} (${fileRef.uri})`);
+  return fileRef;
+}
+async function generateContent(req) {
+  const apiKey = requireApiKey();
+  return httpJson({
+    url: `${GENERATE_BASE}/${req.model}:generateContent`,
+    method: "POST",
+    headers: authHeaders(apiKey),
+    body: {
+      contents: req.contents,
+      ...req.generationConfig ? { generationConfig: req.generationConfig } : {}
+    }
+  });
+}
+function extractText(resp) {
+  const parts = resp.candidates?.[0]?.content?.parts ?? [];
+  return parts.filter((p) => p.text !== void 0).map((p) => p.text ?? "").join("");
+}
+function extractImages(resp) {
+  const parts = resp.candidates?.[0]?.content?.parts ?? [];
+  return parts.filter(
+    (p) => p.inlineData !== void 0
+  ).map((p) => ({ mimeType: p.inlineData.mimeType, data: p.inlineData.data }));
+}
+function inlinePart(filePath) {
+  const data = fs3.readFileSync(filePath).toString("base64");
+  const mimeType = getMimeType(filePath);
+  return { inlineData: { mimeType, data } };
+}
+function shouldUseFileApi(filePath) {
+  const stat = fs3.statSync(filePath);
+  return stat.size > 20 * 1024 * 1024;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/providers/gemini/models.ts
+var IMAGE_MODEL_DEFAULT = "gemini-3.1-flash-image-preview";
+var VIDEO_MODEL_DEFAULT = "veo-3.1-generate-preview";
+var ANALYSIS_MODEL_DEFAULT = "gemini-2.5-flash";
+var DOC_MODEL_DEFAULT = "gemini-2.5-flash";
+var IMAGEN_MODELS = /* @__PURE__ */ new Set([
+  "imagen-4.0-generate-001",
+  "imagen-4.0-ultra-generate-001",
+  "imagen-4.0-fast-generate-001"
+]);
+var GEMINI_IMAGE_MODELS = /* @__PURE__ */ new Set([
+  "gemini-3.1-flash-image-preview",
+  "gemini-3-pro-image-preview",
+  "gemini-2.5-flash-image",
+  "gemini-2.5-flash-image-preview",
+  ...IMAGEN_MODELS
+]);
+var ASPECT_RATIOS = [
+  "1:1",
+  "2:3",
+  "3:2",
+  "3:4",
+  "4:3",
+  "4:5",
+  "5:4",
+  "9:16",
+  "16:9",
+  "21:9"
+];
+var IMAGE_SIZES = ["1K", "2K", "4K"];
+function getDefaultModel(task) {
+  if (task === "generate") {
+    return process.env.IMAGE_GEN_MODEL ?? process.env.GEMINI_IMAGE_GEN_MODEL ?? IMAGE_MODEL_DEFAULT;
+  }
+  if (task === "generate-video") {
+    return process.env.VIDEO_GEN_MODEL ?? VIDEO_MODEL_DEFAULT;
+  }
+  return process.env.MULTIMODAL_MODEL ?? process.env.GEMINI_MODEL ?? ANALYSIS_MODEL_DEFAULT;
+}
+
+// src/providers/gemini/result-formatter.ts
+import fs4 from "fs";
+import path5 from "path";
+function formatResults(results, format, outputPath) {
+  const content = renderFormat(results, format);
+  if (outputPath) {
+    fs4.mkdirSync(path5.dirname(path5.resolve(outputPath)), { recursive: true });
+    fs4.writeFileSync(outputPath, content, "utf8");
+  } else {
+    process.stdout.write(content);
+  }
+}
+function renderFormat(results, format) {
+  switch (format) {
+    case "json":
+      return `${JSON.stringify(results, null, 2)}
+`;
+    case "csv":
+      return renderCsv(results);
+    case "markdown":
+      return renderMarkdown(results);
+    default:
+      return renderText(results);
+  }
+}
+function renderText(results) {
+  return results.map((r) => {
+    const header = `[${r.file}]
+Status: ${r.status}`;
+    if (r.status === "success" && r.response) return `${header}
+Result:
+${r.response}
+`;
+    if (r.status === "error") return `${header}
+Error: ${r.error}
+`;
+    return `${header}
+`;
+  }).join("\n");
+}
+function renderCsv(results) {
+  const header = "file,status,response,error\n";
+  const rows = results.map((r) => {
+    const csvCell = (v) => `"${(v ?? "").replace(/"/g, '""')}"`;
+    return [csvCell(r.file), csvCell(r.status), csvCell(r.response), csvCell(r.error)].join(",");
+  });
+  return `${header + rows.join("\n")}
+`;
+}
+function renderMarkdown(results) {
+  const lines = ["# Results\n"];
+  for (const r of results) {
+    lines.push(`## ${r.file}
+`);
+    lines.push(`**Status**: ${r.status}
+`);
+    if (r.status === "success" && r.response) lines.push(`**Response**:
+
+${r.response}
+`);
+    if (r.status === "error") lines.push(`**Error**: ${r.error}
+`);
+    lines.push("---\n");
+  }
+  return lines.join("\n");
+}
+
+// src/providers/gemini/commands/analyze.ts
+function registerAnalyzeCommand(parent) {
+  parent.command("analyze").description("Analyze files with Gemini (images, video, audio, documents)").requiredOption("--files <paths...>", "Input file paths to analyze").option("--prompt <text>", "Analysis prompt", "Analyze this content").option("--model <id>", "Gemini model to use").option("--format <fmt>", "Output format: text|json|csv|markdown", "text").option("--output <path>", "Write results to file instead of stdout").option("-v, --verbose", "Verbose logging").action(
+    async (opts) => {
+      const logger = createLogger({ verbose: opts.verbose ?? false });
+      const model = opts.model ?? getDefaultModel("analyze");
+      for (const f of opts.files) {
+        if (!fs5.existsSync(f)) throw new ValidationError(`File not found: ${f}`);
+      }
+      const results = [];
+      for (let i = 0; i < opts.files.length; i++) {
+        const filePath = opts.files[i];
+        logger.debug(`[${i + 1}/${opts.files.length}] Processing: ${filePath}`);
+        try {
+          const useApi = shouldUseFileApi(filePath);
+          let contentParts;
+          if (useApi) {
+            logger.debug("File >20MB \u2014 using Files API");
+            const ref = await uploadFile(filePath, { logger });
+            contentParts = [
+              { text: opts.prompt },
+              { fileData: { mimeType: ref.mimeType, fileUri: ref.uri } }
+            ];
+          } else {
+            contentParts = [{ text: opts.prompt }, inlinePart(filePath)];
+          }
+          const resp = await generateContent({
+            model,
+            contents: [{ parts: contentParts }]
+          });
+          results.push({
+            file: filePath,
+            status: "success",
+            response: extractText(resp)
+          });
+        } catch (e) {
+          const msg = e instanceof Error ? e.message : String(e);
+          logger.error(`Failed: ${filePath} \u2014 ${msg}`);
+          results.push({ file: filePath, status: "error", error: msg });
+        }
+      }
+      formatResults(results, opts.format, opts.output);
+      logger.debug(
+        `Done: ${results.filter((r) => r.status === "success").length}/${results.length} succeeded`
+      );
+      const failed = results.filter((r) => r.status === "error").length;
+      if (failed > 0) process.exit(1);
+    }
+  );
+}
+
+// src/providers/gemini/commands/extract.ts
+init_errors();
+import fs6 from "fs";
+function registerExtractCommand(parent) {
+  parent.command("extract").description("Extract structured information from files with Gemini").requiredOption("--files <paths...>", "Input file paths").requiredOption("--prompt <text>", "Extraction prompt (required)").option("--model <id>", "Gemini model to use").option("--format <fmt>", "Output format: text|json|csv|markdown", "text").option("--output <path>", "Write results to file").option("-v, --verbose", "Verbose logging").action(
+    async (opts) => {
+      const logger = createLogger({ verbose: opts.verbose ?? false });
+      const model = opts.model ?? getDefaultModel("extract");
+      for (const f of opts.files) {
+        if (!fs6.existsSync(f)) throw new ValidationError(`File not found: ${f}`);
+      }
+      const generationConfig = opts.format === "json" ? { responseMimeType: "application/json" } : void 0;
+      const results = [];
+      for (let i = 0; i < opts.files.length; i++) {
+        const filePath = opts.files[i];
+        logger.debug(`[${i + 1}/${opts.files.length}] Extracting: ${filePath}`);
+        try {
+          const useApi = shouldUseFileApi(filePath);
+          let contentParts;
+          if (useApi) {
+            const ref = await uploadFile(filePath, { logger });
+            contentParts = [
+              { text: opts.prompt },
+              { fileData: { mimeType: ref.mimeType, fileUri: ref.uri } }
+            ];
+          } else {
+            contentParts = [{ text: opts.prompt }, inlinePart(filePath)];
+          }
+          const resp = await generateContent({
+            model,
+            contents: [{ parts: contentParts }],
+            generationConfig
+          });
+          results.push({ file: filePath, status: "success", response: extractText(resp) });
+        } catch (e) {
+          const msg = e instanceof Error ? e.message : String(e);
+          logger.error(`Failed: ${filePath} \u2014 ${msg}`);
+          results.push({ file: filePath, status: "error", error: msg });
+        }
+      }
+      formatResults(results, opts.format, opts.output);
+      const failed = results.filter((r) => r.status === "error").length;
+      if (failed > 0) process.exit(1);
+    }
+  );
+}
+
+// src/providers/gemini/commands/generate-video.ts
+import fs8 from "fs";
+import path7 from "path";
+init_errors();
+init_http_client();
+
+// src/core/output-dir.ts
+import fs7 from "fs";
+import path6 from "path";
+var cachedOutputDir;
+function getOutputDir() {
+  if (cachedOutputDir) return cachedOutputDir;
+  const dir = process.env.MULTIX_OUTPUT_DIR ? path6.resolve(process.env.MULTIX_OUTPUT_DIR) : path6.resolve(process.cwd(), "multix-output");
+  fs7.mkdirSync(dir, { recursive: true });
+  cachedOutputDir = dir;
+  return dir;
+}
+
+// src/providers/gemini/commands/generate-video.ts
+var BASE2 = "https://generativelanguage.googleapis.com";
+function registerGenerateVideoCommand(parent) {
+  parent.command("generate-video").description("Generate video with Veo via Gemini API [EXPERIMENTAL]").requiredOption("--prompt <text>", "Video generation prompt").option("--model <id>", "Veo model to use").option("--resolution <res>", "Video resolution: 720p|1080p", "1080p").option("--aspect-ratio <ratio>", "Aspect ratio", "16:9").option(
+    "--reference-images <paths...>",
+    "Reference images (first=opening frame, second=closing)"
+  ).option("--upload-timeout <ms>", "Upload timeout in ms", "120000").option("--output <path>", "Copy generated video to this path").option("-v, --verbose", "Verbose logging").action(
+    async (opts) => {
+      const logger = createLogger({ verbose: opts.verbose ?? false });
+      const apiKey = resolveKey("GEMINI_API_KEY");
+      if (!apiKey) throw new ValidationError("GEMINI_API_KEY is not set");
+      const model = opts.model ?? getDefaultModel("generate-video");
+      if (!model.startsWith("veo-")) {
+        throw new ValidationError(
+          `Video generation requires a Veo model (got '${model}'). Use: veo-3.1-generate-preview, veo-3.0-generate-001, etc.`
+        );
+      }
+      if (!["720p", "1080p"].includes(opts.resolution)) {
+        throw new ValidationError("--resolution must be 720p or 1080p");
+      }
+      if (!ASPECT_RATIOS.includes(opts.aspectRatio)) {
+        throw new ValidationError(`Invalid aspect ratio: ${opts.aspectRatio}`);
+      }
+      logger.debug(`Submitting video generation with ${model}...`);
+      logger.info("This may take 30s\u20136 minutes. Veo requires billing.");
+      const config = {
+        aspectRatio: opts.aspectRatio,
+        resolution: opts.resolution
+      };
+      const contentParts = [{ text: opts.prompt }];
+      if (opts.referenceImages?.length) {
+        for (const imgPath of opts.referenceImages.slice(0, 2)) {
+          if (!fs8.existsSync(imgPath))
+            throw new ValidationError(`Reference image not found: ${imgPath}`);
+          const data = fs8.readFileSync(imgPath).toString("base64");
+          const ext = path7.extname(imgPath).toLowerCase();
+          const mimeType = ext === ".png" ? "image/png" : "image/jpeg";
+          contentParts.push({ inlineData: { mimeType, data } });
+        }
+      }
+      const headers = { "x-goog-api-key": apiKey, "Content-Type": "application/json" };
+      let operation;
+      try {
+        operation = await httpJson({
+          url: `${BASE2}/v1beta/models/${model}:generateVideos`,
+          method: "POST",
+          headers,
+          body: {
+            contents: [{ parts: contentParts }],
+            generationConfig: config
+          }
+        });
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        throw new ProviderError(`Video generation submit failed: ${msg}`, "gemini");
+      }
+      const operationName = operation.name;
+      logger.debug(`Operation: ${operationName}`);
+      const deadline = Date.now() + 10 * 60 * 1e3;
+      let done = false;
+      let finalOp = operation;
+      while (!done && Date.now() < deadline) {
+        await sleep2(1e4);
+        finalOp = await httpJson({
+          url: `${BASE2}/v1beta/${operationName}`,
+          headers
+        });
+        done = finalOp.done === true;
+        if (!done)
+          logger.debug(
+            `Still generating... (${Math.round((deadline - Date.now()) / 1e3)}s left)`
+          );
+      }
+      if (!done) throw new ProviderError("Video generation timed out after 10 minutes", "gemini");
+      if (finalOp.error)
+        throw new ProviderError(`Veo error: ${JSON.stringify(finalOp.error)}`, "gemini");
+      const videoUri = finalOp.response?.generatedSamples?.[0]?.video?.uri ?? finalOp.response?.generatedVideos?.[0]?.video?.uri;
+      if (!videoUri) {
+        throw new ProviderError(
+          `Unexpected Veo response structure: ${JSON.stringify(finalOp.response)}`,
+          "gemini"
+        );
+      }
+      const outDir = getOutputDir();
+      const dest = path7.join(outDir, `veo_generated_${Date.now()}.mp4`);
+      const { downloadFile: downloadFile2 } = await Promise.resolve().then(() => (init_http_client(), http_client_exports));
+      await downloadFile2(videoUri, dest);
+      logger.success(`Saved video: ${dest}`);
+      if (opts.output) {
+        fs8.mkdirSync(path7.dirname(path7.resolve(opts.output)), { recursive: true });
+        fs8.copyFileSync(dest, opts.output);
+        logger.success(`Copied to: ${opts.output}`);
+      }
+      console.log(`
+Generated video: ${dest}`);
+    }
+  );
+}
+function sleep2(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+// src/providers/gemini/commands/generate.ts
+init_errors();
+import fs9 from "fs";
+import path8 from "path";
+function registerGenerateCommand(parent) {
+  parent.command("generate").description("Generate images with Gemini (Nano Banana / Imagen 4)").requiredOption("--prompt <text>", "Image generation prompt").option("--model <id>", "Gemini image model to use").option("--aspect-ratio <ratio>", `Aspect ratio (${ASPECT_RATIOS.join("|")})`, "1:1").option("--num-images <n>", "Number of images to generate (1-4)", "1").option("--size <sz>", `Image size (${IMAGE_SIZES.join("|")})`).option("--output <path>", "Copy first generated image to this path").option("-v, --verbose", "Verbose logging").action(
+    async (opts) => {
+      const logger = createLogger({ verbose: opts.verbose ?? false });
+      const model = opts.model ?? getDefaultModel("generate");
+      const numImages = Math.min(Math.max(Number.parseInt(opts.numImages, 10) || 1, 1), 4);
+      if (!ASPECT_RATIOS.includes(opts.aspectRatio)) {
+        throw new ValidationError(
+          `Invalid aspect ratio: ${opts.aspectRatio}. Valid: ${ASPECT_RATIOS.join(", ")}`
+        );
+      }
+      if (opts.size && !IMAGE_SIZES.includes(opts.size)) {
+        throw new ValidationError(`Invalid size: ${opts.size}. Valid: ${IMAGE_SIZES.join(", ")}`);
+      }
+      logger.debug(`Generating ${numImages} image(s) with model: ${model}`);
+      logger.debug(`Aspect ratio: ${opts.aspectRatio}${opts.size ? `, size: ${opts.size}` : ""}`);
+      const imageConfig = { aspectRatio: opts.aspectRatio };
+      if (opts.size) imageConfig.imageSize = opts.size;
+      const generationConfig = {
+        responseModalities: ["IMAGE"],
+        imageConfig
+      };
+      const savedFiles = [];
+      for (let i = 0; i < numImages; i++) {
+        try {
+          const resp = await generateContent({
+            model,
+            contents: [{ parts: [{ text: opts.prompt }] }],
+            generationConfig
+          });
+          const images = extractImages(resp);
+          if (images.length === 0) {
+            logger.warn(
+              `Request ${i + 1}: no images in response \u2014 model may not support image generation`
+            );
+            continue;
+          }
+          for (const img of images) {
+            const outDir = getOutputDir();
+            const ext = img.mimeType.includes("png") ? "png" : "jpg";
+            const fname = `gemini_generated_${Date.now()}_${i}.${ext}`;
+            const dest = path8.join(outDir, fname);
+            fs9.writeFileSync(dest, Buffer.from(img.data, "base64"));
+            savedFiles.push(dest);
+            logger.success(`Saved: ${dest}`);
+          }
+        } catch (e) {
+          const msg = e instanceof Error ? e.message : String(e);
+          logger.error(`Generation failed: ${msg}`);
+          process.exit(1);
+        }
+      }
+      if (savedFiles.length === 0) {
+        logger.error("No images were generated");
+        process.exit(1);
+      }
+      if (opts.output && savedFiles[0]) {
+        fs9.mkdirSync(path8.dirname(path8.resolve(opts.output)), { recursive: true });
+        fs9.copyFileSync(savedFiles[0], opts.output);
+        logger.success(`Copied to: ${opts.output}`);
+      }
+      console.log(`
+Generated ${savedFiles.length} image(s):`);
+      for (const f of savedFiles) console.log(`  ${f}`);
+    }
+  );
+}
+
+// src/providers/gemini/commands/transcribe.ts
+init_errors();
+import fs10 from "fs";
+function registerTranscribeCommand(parent) {
+  parent.command("transcribe").description("Transcribe audio or video files with Gemini").requiredOption("--files <paths...>", "Audio/video file paths to transcribe").option("--prompt <text>", "Transcription prompt", "Generate a transcript with timestamps").option("--model <id>", "Gemini model to use").option("--format <fmt>", "Output format: text|json|csv|markdown", "text").option("--output <path>", "Write results to file").option("-v, --verbose", "Verbose logging").action(
+    async (opts) => {
+      const logger = createLogger({ verbose: opts.verbose ?? false });
+      const model = opts.model ?? getDefaultModel("transcribe");
+      for (const f of opts.files) {
+        if (!fs10.existsSync(f)) throw new ValidationError(`File not found: ${f}`);
+      }
+      const results = [];
+      for (let i = 0; i < opts.files.length; i++) {
+        const filePath = opts.files[i];
+        logger.debug(`[${i + 1}/${opts.files.length}] Transcribing: ${filePath}`);
+        try {
+          const useApi = shouldUseFileApi(filePath);
+          let contentParts;
+          if (useApi) {
+            logger.debug("File >20MB \u2014 using Files API");
+            const ref = await uploadFile(filePath, { logger });
+            contentParts = [
+              { text: opts.prompt },
+              { fileData: { mimeType: ref.mimeType, fileUri: ref.uri } }
+            ];
+          } else {
+            contentParts = [{ text: opts.prompt }, inlinePart(filePath)];
+          }
+          const resp = await generateContent({
+            model,
+            contents: [{ parts: contentParts }]
+          });
+          results.push({
+            file: filePath,
+            status: "success",
+            response: extractText(resp)
+          });
+        } catch (e) {
+          const msg = e instanceof Error ? e.message : String(e);
+          logger.error(`Failed: ${filePath} \u2014 ${msg}`);
+          results.push({ file: filePath, status: "error", error: msg });
+        }
+      }
+      formatResults(results, opts.format, opts.output);
+      const failed = results.filter((r) => r.status === "error").length;
+      if (failed > 0) process.exit(1);
+    }
+  );
+}
+
+// src/providers/gemini/commands/index.ts
+function registerGeminiCommands(program2) {
+  const gemini = program2.command("gemini").description("Gemini AI operations: analyze, transcribe, extract, generate images/video");
+  registerAnalyzeCommand(gemini);
+  registerTranscribeCommand(gemini);
+  registerExtractCommand(gemini);
+  registerGenerateCommand(gemini);
+  registerGenerateVideoCommand(gemini);
+}
+
+// src/providers/minimax/commands/generate-music.ts
+init_errors();
+
+// src/providers/minimax/client.ts
+init_errors();
+init_http_client();
+var MINIMAX_BASE_URL = "https://api.minimax.io/v1";
+function requireMinimaxKey() {
+  const key = resolveKey("MINIMAX_API_KEY");
+  if (!key) {
+    throw new ConfigError(
+      "MINIMAX_API_KEY is not set. Get one at https://platform.minimax.io/user-center/basic-information/interface-key"
+    );
+  }
+  return key;
+}
+function authHeaders2(apiKey) {
+  return {
+    Authorization: `Bearer ${apiKey}`,
+    "Content-Type": "application/json"
+  };
+}
+async function apiPost(endpoint, payload, apiKey, opts = {}) {
+  const url = `${MINIMAX_BASE_URL}/${endpoint}`;
+  opts.logger?.debug(`POST ${url}`);
+  const data = await httpJson({
+    url,
+    method: "POST",
+    headers: authHeaders2(apiKey),
+    body: payload,
+    timeoutMs: opts.timeoutMs ?? 12e4
+  });
+  const baseResp = data.base_resp;
+  if (baseResp && baseResp.status_code !== 0) {
+    throw new ProviderError(
+      `MiniMax API error (code ${baseResp.status_code}): ${baseResp.status_msg ?? "unknown"}`,
+      "minimax"
+    );
+  }
+  return data;
+}
+async function apiGet(endpoint, params, apiKey) {
+  const url = new URL(`${MINIMAX_BASE_URL}/${endpoint}`);
+  for (const [k, v] of Object.entries(params)) url.searchParams.set(k, v);
+  return httpJson({ url: url.toString(), headers: authHeaders2(apiKey) });
+}
+async function pollAsyncTask(taskId, taskType, apiKey, opts = {}) {
+  const { intervalMs = 1e4, timeoutMs = 6e5, logger } = opts;
+  const deadline = Date.now() + timeoutMs;
+  let elapsed = 0;
+  while (Date.now() < deadline) {
+    const result = await apiGet(`query/${taskType}`, { task_id: taskId }, apiKey);
+    const status = result.status ?? "Unknown";
+    if (elapsed > 0 && elapsed % 3e4 < intervalMs) {
+      logger?.debug(`Polling... ${Math.round(elapsed / 1e3)}s elapsed, status: ${status}`);
+    }
+    if (status === "Success") return result;
+    if (status === "Failed" || status === "Error") {
+      throw new ProviderError(`Task ${taskId} failed: ${JSON.stringify(result)}`, "minimax");
+    }
+    await sleep3(intervalMs);
+    elapsed += intervalMs;
+  }
+  throw new ProviderError(`Task ${taskId} timed out after ${timeoutMs / 1e3}s`, "minimax");
+}
+async function downloadMinimaxFile(fileId, apiKey, dest, logger) {
+  const result = await apiGet(
+    "files/retrieve",
+    { file_id: fileId },
+    apiKey
+  );
+  const downloadUrl = result.file?.download_url;
+  if (!downloadUrl) {
+    throw new ProviderError(`No download URL for file ${fileId}`, "minimax");
+  }
+  logger?.debug(`Downloading to: ${dest}`);
+  await downloadFile(downloadUrl, dest);
+  return dest;
+}
+function sleep3(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+// src/providers/minimax/generators/music.ts
+init_http_client();
+import fs11 from "fs";
+import path9 from "path";
+async function generateMinimaxMusic(opts) {
+  const {
+    apiKey,
+    lyrics = "",
+    prompt = "",
+    model = "music-2.5",
+    outputFormat = "mp3",
+    output,
+    logger
+  } = opts;
+  if (!lyrics && !prompt) {
+    return {
+      status: "error",
+      error: "Either --lyrics or --prompt is required for music generation"
+    };
+  }
+  const payload = {
+    model,
+    output_format: "url",
+    audio_setting: {
+      sample_rate: 44100,
+      bitrate: 128e3,
+      format: outputFormat,
+      channel: 1
+    }
+  };
+  if (lyrics) payload.lyrics = lyrics.slice(0, 3500);
+  if (prompt) payload.prompt = prompt.slice(0, 2e3);
+  logger?.debug(`Generating music with ${model}...`);
+  let resp;
+  try {
+    resp = await apiPost("music_generation", payload, apiKey, {
+      logger,
+      timeoutMs: 3e5
+    });
+  } catch (e) {
+    return { status: "error", error: e instanceof Error ? e.message : String(e) };
+  }
+  const audioData = resp.data?.audio;
+  if (!audioData) {
+    return { status: "error", error: "No audio in response" };
+  }
+  const durationMs = resp.extra_info?.music_duration ?? 0;
+  const outDir = getOutputDir();
+  const dest = path9.join(outDir, `minimax_music_${Date.now()}.${outputFormat}`);
+  try {
+    if (audioData.startsWith("http")) {
+      const bytes = await fetchBytes(audioData);
+      fs11.writeFileSync(dest, bytes);
+    } else {
+      const audioBytes = Buffer.from(audioData, "hex");
+      fs11.writeFileSync(dest, audioBytes);
+    }
+  } catch (e) {
+    return {
+      status: "error",
+      error: `Failed to save audio: ${e instanceof Error ? e.message : String(e)}`
+    };
+  }
+  const durSec = durationMs / 1e3;
+  logger?.success(`Saved: ${dest} (${durSec.toFixed(1)}s)`);
+  if (output) {
+    fs11.mkdirSync(path9.dirname(path9.resolve(output)), { recursive: true });
+    fs11.copyFileSync(dest, output);
+  }
+  return { status: "success", generatedAudio: dest, durationMs, model };
+}
+
+// src/providers/minimax/models.ts
+var MINIMAX_IMAGE_MODELS = /* @__PURE__ */ new Set(["image-01", "image-01-live"]);
+var MINIMAX_VIDEO_MODELS = /* @__PURE__ */ new Set([
+  "MiniMax-Hailuo-2.3",
+  "MiniMax-Hailuo-2.3-Fast",
+  "MiniMax-Hailuo-02",
+  "S2V-01"
+]);
+var MINIMAX_SPEECH_MODELS = /* @__PURE__ */ new Set([
+  "speech-2.8-hd",
+  "speech-2.8-turbo",
+  "speech-2.6-hd",
+  "speech-2.6-turbo",
+  "speech-02-hd",
+  "speech-02-turbo"
+]);
+var MINIMAX_MUSIC_MODELS = /* @__PURE__ */ new Set(["music-2.5", "music-2.0"]);
+var ALL_MINIMAX_MODELS = /* @__PURE__ */ new Set([
+  ...MINIMAX_IMAGE_MODELS,
+  ...MINIMAX_VIDEO_MODELS,
+  ...MINIMAX_SPEECH_MODELS,
+  ...MINIMAX_MUSIC_MODELS
+]);
+var TASK_DEFAULTS = {
+  image: process.env.MINIMAX_IMAGE_MODEL ?? "image-01",
+  video: process.env.MINIMAX_VIDEO_MODEL ?? "MiniMax-Hailuo-2.3",
+  speech: process.env.MINIMAX_SPEECH_MODEL ?? "speech-2.8-hd",
+  music: process.env.MINIMAX_MUSIC_MODEL ?? "music-2.5"
+};
+var VIDEO_DURATIONS = [6, 10];
+var VIDEO_RESOLUTIONS = ["720P", "1080P"];
+var SPEECH_FORMATS = ["mp3", "wav", "flac", "pcm"];
+
+// src/providers/minimax/commands/generate-music.ts
+function registerMinimaxGenerateMusicCommand(parent) {
+  parent.command("generate-music").description("Generate music with MiniMax").option("--lyrics <str>", "Song lyrics (use --lyrics or --prompt)").option("--prompt <str>", "Music style/description prompt").option("--model <id>", `Music model (${[...MINIMAX_MUSIC_MODELS].join("|")})`).option("--output-format <fmt>", "Audio format: mp3|wav|flac", "mp3").option("--output <path>", "Copy output audio to this path").option("-v, --verbose", "Verbose logging").action(
+    async (opts) => {
+      const logger = createLogger({ verbose: opts.verbose ?? false });
+      const apiKey = requireMinimaxKey();
+      if (!opts.lyrics && !opts.prompt) {
+        throw new ValidationError("Either --lyrics or --prompt is required");
+      }
+      const model = opts.model ?? TASK_DEFAULTS.music;
+      const result = await generateMinimaxMusic({
+        apiKey,
+        lyrics: opts.lyrics,
+        prompt: opts.prompt,
+        model,
+        outputFormat: opts.outputFormat,
+        output: opts.output,
+        logger
+      });
+      if (result.status === "error") {
+        logger.error(result.error ?? "Unknown error");
+        process.exit(1);
+      }
+      console.log(`
+Generated music: ${result.generatedAudio}`);
+      if (result.durationMs) {
+        console.log(`Duration: ${(result.durationMs / 1e3).toFixed(1)}s`);
+      }
+    }
+  );
+}
+
+// src/providers/minimax/commands/generate-speech.ts
+init_errors();
+
+// src/providers/minimax/generators/speech.ts
+import fs12 from "fs";
+import path10 from "path";
+async function generateMinimaxSpeech(opts) {
+  const {
+    apiKey,
+    text,
+    model = "speech-2.8-hd",
+    voice = "English_expressive_narrator",
+    emotion = "neutral",
+    outputFormat = "mp3",
+    rate = 1,
+    output,
+    logger
+  } = opts;
+  const payload = {
+    model,
+    text: text.slice(0, 1e4),
+    stream: false,
+    language_boost: "auto",
+    output_format: "hex",
+    voice_setting: {
+      voice_id: voice,
+      speed: rate,
+      vol: 1,
+      pitch: 0,
+      emotion
+    },
+    audio_setting: {
+      sample_rate: 32e3,
+      bitrate: 128e3,
+      format: outputFormat,
+      channel: 1
+    }
+  };
+  logger?.debug(`Generating speech with ${model}, voice: ${voice}`);
+  let resp;
+  try {
+    resp = await apiPost("t2a_v2", payload, apiKey, { logger });
+  } catch (e) {
+    return { status: "error", error: e instanceof Error ? e.message : String(e) };
+  }
+  const audioHex = resp.data?.audio;
+  if (!audioHex) {
+    return { status: "error", error: "No audio in response" };
+  }
+  const audioBytes = Buffer.from(audioHex, "hex");
+  const ext = ["mp3", "wav", "flac"].includes(outputFormat) ? outputFormat : "mp3";
+  const outDir = getOutputDir();
+  const dest = path10.join(outDir, `minimax_speech_${Date.now()}.${ext}`);
+  fs12.writeFileSync(dest, audioBytes);
+  logger?.success(`Saved: ${dest} (${(audioBytes.length / 1024).toFixed(1)} KB)`);
+  if (output) {
+    fs12.mkdirSync(path10.dirname(path10.resolve(output)), { recursive: true });
+    fs12.copyFileSync(dest, output);
+  }
+  return { status: "success", generatedAudio: dest, model };
+}
+
+// src/providers/minimax/commands/generate-speech.ts
+function registerMinimaxGenerateSpeechCommand(parent) {
+  parent.command("generate-speech").description("Generate speech (TTS) with MiniMax").option("--text <str>", "Text to speak (use --text or --prompt)").option("--prompt <str>", "Alias for --text").option("--model <id>", `Speech model (${[...MINIMAX_SPEECH_MODELS].join("|")})`).option("--voice <id>", "Voice ID", "English_expressive_narrator").option(
+    "--emotion <e>",
+    "Emotion (neutral|happy|sad|angry|fearful|disgusted|surprised)",
+    "neutral"
+  ).option("--output-format <fmt>", `Audio format (${SPEECH_FORMATS.join("|")})`, "mp3").option("--rate <n>", "Speech rate (0.5\u20132.0)", "1.0").option("--output <path>", "Copy output audio to this path").option("-v, --verbose", "Verbose logging").action(
+    async (opts) => {
+      const logger = createLogger({ verbose: opts.verbose ?? false });
+      const apiKey = requireMinimaxKey();
+      const text = opts.text ?? opts.prompt;
+      if (!text) throw new ValidationError("Either --text or --prompt is required");
+      if (!SPEECH_FORMATS.includes(opts.outputFormat)) {
+        throw new ValidationError(`--output-format must be one of: ${SPEECH_FORMATS.join(", ")}`);
+      }
+      const model = opts.model ?? TASK_DEFAULTS.speech;
+      const rate = Number.parseFloat(opts.rate);
+      const result = await generateMinimaxSpeech({
+        apiKey,
+        text,
+        model,
+        voice: opts.voice,
+        emotion: opts.emotion,
+        outputFormat: opts.outputFormat,
+        rate,
+        output: opts.output,
+        logger
+      });
+      if (result.status === "error") {
+        logger.error(result.error ?? "Unknown error");
+        process.exit(1);
+      }
+      console.log(`
+Generated audio: ${result.generatedAudio}`);
+    }
+  );
+}
+
+// src/providers/minimax/commands/generate-video.ts
+init_errors();
+
+// src/providers/minimax/generators/video.ts
+import fs13 from "fs";
+import path11 from "path";
+async function generateMinimaxVideo(opts) {
+  const {
+    apiKey,
+    prompt,
+    model = "MiniMax-Hailuo-2.3",
+    duration = 6,
+    resolution = "1080P",
+    firstFrame,
+    output,
+    logger
+  } = opts;
+  const payload = { prompt, model, duration, resolution };
+  if (firstFrame) payload.first_frame_image = firstFrame;
+  logger?.debug(`Submitting video generation with ${model}...`);
+  let taskResp;
+  try {
+    taskResp = await apiPost("video_generation", payload, apiKey, {
+      logger,
+      timeoutMs: 6e4
+    });
+  } catch (e) {
+    return { status: "error", error: e instanceof Error ? e.message : String(e) };
+  }
+  const taskId = taskResp.task_id;
+  if (!taskId) {
+    return { status: "error", error: `No task_id in response: ${JSON.stringify(taskResp)}` };
+  }
+  logger?.debug(`Task ID: ${taskId}, polling...`);
+  const start = Date.now();
+  let pollResult;
+  try {
+    pollResult = await pollAsyncTask(taskId, "video_generation", apiKey, {
+      intervalMs: 1e4,
+      timeoutMs: 6e5,
+      logger
+    });
+  } catch (e) {
+    return { status: "error", error: e instanceof Error ? e.message : String(e) };
+  }
+  const fileId = pollResult.file_id;
+  if (!fileId) {
+    return { status: "error", error: `No file_id in poll result: ${JSON.stringify(pollResult)}` };
+  }
+  const outDir = getOutputDir();
+  const dest = path11.join(outDir, `minimax_video_${Date.now()}.mp4`);
+  try {
+    await downloadMinimaxFile(fileId, apiKey, dest, logger);
+  } catch (e) {
+    return { status: "error", error: e instanceof Error ? e.message : String(e) };
+  }
+  const elapsed = (Date.now() - start) / 1e3;
+  const stat = fs13.statSync(dest);
+  const fileSizeMb = stat.size / (1024 * 1024);
+  if (output) {
+    fs13.mkdirSync(path11.dirname(path11.resolve(output)), { recursive: true });
+    fs13.copyFileSync(dest, output);
+  }
+  logger?.debug(`Generated in ${elapsed.toFixed(1)}s, size: ${fileSizeMb.toFixed(2)} MB`);
+  return {
+    status: "success",
+    generatedVideo: dest,
+    generationTime: elapsed,
+    fileSizeMb,
+    model
+  };
+}
+
+// src/providers/minimax/commands/generate-video.ts
+function registerMinimaxGenerateVideoCommand(parent) {
+  parent.command("generate-video").description("Generate video with MiniMax Hailuo models (async)").requiredOption("--prompt <text>", "Video generation prompt").option("--model <id>", `Model (${[...MINIMAX_VIDEO_MODELS].join("|")})`).option("--duration <n>", `Duration in seconds (${VIDEO_DURATIONS.join("|")})`, "6").option("--resolution <res>", `Resolution (${VIDEO_RESOLUTIONS.join("|")})`, "1080P").option("--first-frame <url>", "First frame image URL").option("--output <path>", "Copy generated video to this path").option("-v, --verbose", "Verbose logging").action(
+    async (opts) => {
+      const logger = createLogger({ verbose: opts.verbose ?? false });
+      const apiKey = requireMinimaxKey();
+      const model = opts.model ?? TASK_DEFAULTS.video;
+      const duration = Number.parseInt(opts.duration, 10);
+      if (!VIDEO_DURATIONS.includes(duration)) {
+        throw new ValidationError(`--duration must be one of: ${VIDEO_DURATIONS.join(", ")}`);
+      }
+      const resolution = opts.resolution.toUpperCase();
+      if (!VIDEO_RESOLUTIONS.includes(resolution)) {
+        throw new ValidationError(`--resolution must be one of: ${VIDEO_RESOLUTIONS.join(", ")}`);
+      }
+      if (opts.firstFrame && !opts.firstFrame.startsWith("http")) {
+        throw new ValidationError("--first-frame must be an http(s) URL");
+      }
+      logger.info("Video generation is async and may take several minutes...");
+      const result = await generateMinimaxVideo({
+        apiKey,
+        prompt: opts.prompt,
+        model,
+        duration,
+        resolution,
+        firstFrame: opts.firstFrame,
+        output: opts.output,
+        logger
+      });
+      if (result.status === "error") {
+        logger.error(result.error ?? "Unknown error");
+        process.exit(1);
+      }
+      console.log(`
+Generated video: ${result.generatedVideo}`);
+      if (result.generationTime)
+        console.log(`Generation time: ${result.generationTime.toFixed(1)}s`);
+      if (result.fileSizeMb) console.log(`File size: ${result.fileSizeMb.toFixed(2)} MB`);
+    }
+  );
+}
+
+// src/providers/minimax/generators/image.ts
+init_errors();
+init_http_client();
+import fs14 from "fs";
+import path12 from "path";
+async function generateMinimaxImage(opts) {
+  const {
+    apiKey,
+    prompt,
+    model = "image-01",
+    aspectRatio = "1:1",
+    numImages = 1,
+    output,
+    logger
+  } = opts;
+  const payload = {
+    model,
+    prompt,
+    aspect_ratio: aspectRatio,
+    n: Math.min(numImages, 9),
+    response_format: "url",
+    prompt_optimizer: true
+  };
+  logger?.debug(`Generating ${numImages} image(s) with ${model}`);
+  let resp;
+  try {
+    resp = await apiPost("image_generation", payload, apiKey, { logger });
+  } catch (e) {
+    return { status: "error", error: e instanceof Error ? e.message : String(e) };
+  }
+  const imageUrls = resp.data?.image_urls ?? [];
+  if (imageUrls.length === 0) {
+    return { status: "error", error: "No images in response" };
+  }
+  const outDir = getOutputDir();
+  const savedFiles = [];
+  for (let i = 0; i < imageUrls.length; i++) {
+    const url = imageUrls[i];
+    if (!url) continue;
+    try {
+      const bytes = await fetchBytes(url);
+      const fname = `minimax_image_${Date.now()}_${i}.png`;
+      const dest = path12.join(outDir, fname);
+      fs14.writeFileSync(dest, bytes);
+      savedFiles.push(dest);
+      logger?.success(`Saved: ${dest}`);
+    } catch (e) {
+      throw new ProviderError(
+        `Failed to download image: ${e instanceof Error ? e.message : String(e)}`,
+        "minimax"
+      );
+    }
+  }
+  if (output && savedFiles[0]) {
+    fs14.mkdirSync(path12.dirname(path12.resolve(output)), { recursive: true });
+    fs14.copyFileSync(savedFiles[0], output);
+  }
+  return { status: "success", generatedImages: savedFiles, model };
+}
+
+// src/providers/minimax/commands/generate.ts
+function registerMinimaxGenerateCommand(parent) {
+  parent.command("generate").description("Generate images with MiniMax").requiredOption("--prompt <text>", "Image generation prompt").option("--model <id>", `Model (${[...MINIMAX_IMAGE_MODELS].join("|")})`).option("--aspect-ratio <ratio>", "Aspect ratio (e.g. 1:1, 16:9)", "1:1").option("--num-images <n>", "Number of images (1-9)", "1").option("--output <path>", "Copy first image to this path").option("-v, --verbose", "Verbose logging").action(
+    async (opts) => {
+      const logger = createLogger({ verbose: opts.verbose ?? false });
+      const apiKey = requireMinimaxKey();
+      const model = opts.model ?? TASK_DEFAULTS.image;
+      const numImages = Math.min(Math.max(Number.parseInt(opts.numImages, 10) || 1, 1), 9);
+      const result = await generateMinimaxImage({
+        apiKey,
+        prompt: opts.prompt,
+        model,
+        aspectRatio: opts.aspectRatio,
+        numImages,
+        output: opts.output,
+        logger
+      });
+      if (result.status === "error") {
+        logger.error(result.error ?? "Unknown error");
+        process.exit(1);
+      }
+      console.log(`
+Generated ${result.generatedImages?.length ?? 0} image(s):`);
+      for (const f of result.generatedImages ?? []) console.log(`  ${f}`);
+    }
+  );
+}
+
+// src/providers/minimax/commands/index.ts
+function registerMinimaxCommands(program2) {
+  const minimax = program2.command("minimax").description("MiniMax generation: images, video, speech, and music");
+  registerMinimaxGenerateCommand(minimax);
+  registerMinimaxGenerateVideoCommand(minimax);
+  registerMinimaxGenerateSpeechCommand(minimax);
+  registerMinimaxGenerateMusicCommand(minimax);
+}
+
+// src/providers/openrouter/client.ts
+import fs15 from "fs";
+import path13 from "path";
+init_errors();
+init_http_client();
+var OPENROUTER_API_URL = "https://openrouter.ai/api/v1/chat/completions";
+var DEFAULT_OPENROUTER_MODEL = "google/gemini-3.1-flash-image-preview";
+function requireOpenRouterKey() {
+  const key = resolveKey("OPENROUTER_API_KEY");
+  if (!key) {
+    throw new ConfigError(
+      "OPENROUTER_API_KEY is not set. Get one at https://openrouter.ai/settings/keys"
+    );
+  }
+  return key;
+}
+function buildHeaders(apiKey) {
+  const headers = {
+    Authorization: `Bearer ${apiKey}`,
+    "Content-Type": "application/json"
+  };
+  const referer = resolveKey("OPENROUTER_SITE_URL");
+  const title = resolveKey("OPENROUTER_APP_NAME") ?? "multix";
+  if (referer) headers["HTTP-Referer"] = referer;
+  if (title) headers["X-Title"] = title;
+  return headers;
+}
+function buildPayload(opts) {
+  const payload = {
+    messages: [{ role: "user", content: opts.prompt }],
+    modalities: opts.model.includes("gemini") ? ["image", "text"] : ["image"],
+    image_config: { aspect_ratio: opts.aspectRatio }
+  };
+  if (opts.imageSize) {
+    payload.image_config.image_size = opts.imageSize;
+  }
+  if (opts.fallbackModels.length > 0) {
+    payload.models = [opts.model, ...opts.fallbackModels];
+  } else {
+    payload.model = opts.model;
+  }
+  return payload;
+}
+async function generateOpenRouterImage(opts) {
+  const { prompt, model, aspectRatio = "1:1", imageSize, numImages = 1, output, logger } = opts;
+  const apiKey = requireOpenRouterKey();
+  const fallbackModels = (resolveKey("OPENROUTER_FALLBACK_MODELS") ?? "").split(",").map((m) => m.trim()).filter(Boolean);
+  const imageUrls = [];
+  let usedModel = model;
+  for (let i = 0; i < Math.max(1, numImages); i++) {
+    const payload = buildPayload({ prompt, model, aspectRatio, imageSize, fallbackModels });
+    logger?.debug(
+      `OpenRouter model: ${model}${fallbackModels.length ? ` (fallbacks: ${fallbackModels.join(", ")})` : ""}`
+    );
+    let data;
+    try {
+      data = await httpJson({
+        url: OPENROUTER_API_URL,
+        method: "POST",
+        headers: buildHeaders(apiKey),
+        body: payload,
+        timeoutMs: 24e4
+      });
+    } catch (e) {
+      return { status: "error", error: e instanceof Error ? e.message : String(e) };
+    }
+    const choices = data.choices ?? [];
+    if (choices.length === 0) {
+      return { status: "error", error: `No choices in response: ${JSON.stringify(data)}` };
+    }
+    const messageImages = choices[0]?.message?.images ?? [];
+    if (messageImages.length === 0) {
+      return {
+        status: "error",
+        error: `No images in response \u2014 model '${model}' may not support image generation`
+      };
+    }
+    for (const img of messageImages) {
+      const url = img.image_url?.url;
+      if (url) imageUrls.push(url);
+    }
+    usedModel = data.model ?? usedModel;
+    if (imageUrls.length >= numImages) break;
+  }
+  const outDir = getOutputDir();
+  const savedFiles = [];
+  for (let i = 0; i < Math.min(imageUrls.length, Math.max(1, numImages)); i++) {
+    const url = imageUrls[i];
+    if (!url) continue;
+    try {
+      const bytes = await fetchBytes(url);
+      const dest = path13.join(outDir, `openrouter_image_${Date.now()}_${i}.png`);
+      fs15.writeFileSync(dest, bytes);
+      savedFiles.push(dest);
+      logger?.success(`Saved: ${dest}`);
+    } catch (e) {
+      throw new ProviderError(
+        `Failed to save image: ${e instanceof Error ? e.message : String(e)}`,
+        "openrouter"
+      );
+    }
+  }
+  if (output && savedFiles[0]) {
+    fs15.mkdirSync(path13.dirname(path13.resolve(output)), { recursive: true });
+    fs15.writeFileSync(output, fs15.readFileSync(savedFiles[0]));
+  }
+  return { status: "success", generatedImages: savedFiles, model: usedModel };
+}
+
+// src/providers/openrouter/commands/generate.ts
+function registerOpenRouterGenerateCommand(parent) {
+  parent.command("generate").description("Generate images via OpenRouter (uses chat completions API)").requiredOption("--prompt <text>", "Image generation prompt").option("--model <id>", "OpenRouter model id (e.g. google/gemini-3.1-flash-image-preview)").option("--aspect-ratio <ratio>", "Aspect ratio (e.g. 1:1, 16:9)", "1:1").option("--image-size <size>", "Image size hint (e.g. 1K, 2K)").option("--num-images <n>", "Number of images to generate", "1").option("--output <path>", "Copy first image to this path").option("-v, --verbose", "Verbose logging").action(
+    async (opts) => {
+      const logger = createLogger({ verbose: opts.verbose ?? false });
+      const model = opts.model ?? resolveKey("OPENROUTER_IMAGE_MODEL") ?? DEFAULT_OPENROUTER_MODEL;
+      const numImages = Math.max(1, Number.parseInt(opts.numImages, 10) || 1);
+      logger.debug(`Generating ${numImages} image(s) via OpenRouter: ${model}`);
+      const result = await generateOpenRouterImage({
+        prompt: opts.prompt,
+        model,
+        aspectRatio: opts.aspectRatio,
+        imageSize: opts.imageSize,
+        numImages,
+        output: opts.output,
+        logger
+      });
+      if (result.status === "error") {
+        logger.error(result.error ?? "Unknown error");
+        process.exit(1);
+      }
+      console.log(`
+Generated ${result.generatedImages?.length ?? 0} image(s):`);
+      for (const f of result.generatedImages ?? []) console.log(`  ${f}`);
+      if (result.model) console.log(`Model used: ${result.model}`);
+    }
+  );
+}
+
+// src/providers/openrouter/commands/index.ts
+function registerOpenRouterCommands(program2) {
+  const openrouter = program2.command("openrouter").description("OpenRouter image generation via chat completions API");
+  registerOpenRouterGenerateCommand(openrouter);
+}
+
+// src/commands/check-helpers/binary-check.ts
+import { execa } from "execa";
+async function checkBinary(binary) {
+  try {
+    const result = await execa(binary, ["--version"], { reject: true, all: true });
+    const version = (result.stdout || result.stderr || "").split("\n")[0]?.trim();
+    return { available: true, version, binary };
+  } catch (e) {
+    const err2 = e;
+    if (err2.code === "ENOENT") return { available: false, binary };
+    const output = (err2.stderr ?? err2.all ?? "").toLowerCase();
+    if (output.includes("not recognized") || output.includes("not found") || output.includes("no such file")) {
+      return { available: false, binary };
+    }
+    if (err2.exitCode !== void 0) return { available: true, binary };
+    return { available: false, binary };
+  }
+}
+
+// src/commands/check-helpers/gemini-ping.ts
+init_errors();
+init_http_client();
+var MODELS_URL = "https://generativelanguage.googleapis.com/v1beta/models";
+async function pingGemini(apiKey) {
+  try {
+    const resp = await httpJson({
+      url: `${MODELS_URL}?key=${encodeURIComponent(apiKey)}`,
+      timeoutMs: 1e4
+    });
+    const modelCount = Array.isArray(resp.models) ? resp.models.length : 0;
+    return { status: "success", modelCount };
+  } catch (e) {
+    if (e instanceof HttpError) {
+      if (e.status === 400 || e.status === 401 || e.status === 403) {
+        return { status: "auth_error", error: `HTTP ${e.status}: ${e.snippet}` };
+      }
+      return { status: "network_error", error: `HTTP ${e.status}: ${e.snippet}` };
+    }
+    const msg = e instanceof Error ? e.message : String(e);
+    return { status: "network_error", error: msg };
+  }
+}
+
+// src/commands/check-helpers/setup-hints.ts
+var SETUP_HINTS = `
+To configure multix, set at least one provider API key:
+
+  Provider URLs:
+    Gemini / AI Studio : https://aistudio.google.com/apikey
+    OpenRouter         : https://openrouter.ai/settings/keys
+    MiniMax            : https://platform.minimax.io/user-center/basic-information/interface-key
+
+  Option A \u2014 user global config (recommended):
+    echo 'GEMINI_API_KEY=your-key' >> ~/.multix/.env
+
+  Option B \u2014 project .env:
+    echo 'GEMINI_API_KEY=your-key' >> .env
+
+  Option C \u2014 shell environment:
+    export GEMINI_API_KEY=your-key
+    export OPENROUTER_API_KEY=your-openrouter-key   # optional
+    export MINIMAX_API_KEY=your-minimax-key          # optional
+
+  After configuring, verify with:
+    multix check
+`.trim();
+var FFMPEG_HINT = "ffmpeg not found \u2014 media optimize/split/batch commands unavailable.\n  Linux: sudo apt-get install ffmpeg\n  macOS: brew install ffmpeg\n  Windows: https://ffmpeg.org/download.html";
+var MAGICK_HINT = "ImageMagick (magick) not found \u2014 image optimization unavailable.\n  Linux: sudo apt-get install imagemagick\n  macOS: brew install imagemagick\n  Windows: https://imagemagick.org/script/download.php";
+
+// src/commands/check.ts
+function registerCheckCommand(program2) {
+  program2.command("check").description("Validate multix setup: tooling, API keys, and live Gemini connectivity").option("-v, --verbose", "Verbose output").action(async (opts) => {
+    const logger = createLogger({ verbose: opts.verbose ?? false });
+    let exitCode = 0;
+    logger.header("Tooling");
+    const ffmpegStatus = await checkBinary("ffmpeg");
+    const magickStatus = await checkBinary("magick");
+    if (ffmpegStatus.available) {
+      logger.success(`ffmpeg found${ffmpegStatus.version ? ` \u2014 ${ffmpegStatus.version}` : ""}`);
+    } else {
+      logger.warn("ffmpeg not found");
+      if (opts.verbose) console.log(`  ${FFMPEG_HINT}`);
+    }
+    if (magickStatus.available) {
+      logger.success(`magick found${magickStatus.version ? ` \u2014 ${magickStatus.version}` : ""}`);
+    } else {
+      logger.warn("magick (ImageMagick) not found");
+      if (opts.verbose) console.log(`  ${MAGICK_HINT}`);
+    }
+    logger.header("API Keys");
+    const geminiKey = resolveKey("GEMINI_API_KEY");
+    const openrouterKey = resolveKey("OPENROUTER_API_KEY");
+    const minimaxKey = resolveKey("MINIMAX_API_KEY");
+    if (geminiKey) {
+      logger.success(`GEMINI_API_KEY found \u2014 ${redact(geminiKey)}`);
+    } else {
+      logger.warn("GEMINI_API_KEY not set (Gemini analyze/transcribe/doc features unavailable)");
+    }
+    if (openrouterKey) {
+      logger.success(`OPENROUTER_API_KEY found \u2014 ${redact(openrouterKey)}`);
+    } else {
+      logger.info("OPENROUTER_API_KEY not set (optional)");
+    }
+    if (minimaxKey) {
+      logger.success(`MINIMAX_API_KEY found \u2014 ${redact(minimaxKey)}`);
+    } else {
+      logger.info("MINIMAX_API_KEY not set (optional)");
+    }
+    if (!geminiKey && !openrouterKey && !minimaxKey) {
+      logger.header("No Provider Keys Configured");
+      console.log(SETUP_HINTS);
+      process.exit(1);
+    }
+    if (geminiKey) {
+      logger.header("Gemini Connectivity");
+      logger.info("Pinging Gemini models endpoint...");
+      const ping = await pingGemini(geminiKey);
+      if (ping.status === "success") {
+        logger.success(`Gemini API reachable \u2014 ${ping.modelCount ?? 0} models available`);
+      } else if (ping.status === "auth_error") {
+        logger.error(`Gemini auth failed \u2014 check GEMINI_API_KEY: ${ping.error ?? ""}`);
+        exitCode = 1;
+      } else {
+        logger.warn(`Gemini network error (API may be down): ${ping.error ?? ""}`);
+      }
+    }
+    logger.header("Summary");
+    if (exitCode === 0) {
+      logger.success("multix is ready to use");
+      if (geminiKey) {
+        console.log(
+          "  Full Gemini multimodal setup (analyze, transcribe, generate, doc convert)"
+        );
+      } else {
+        console.log("  Image generation via OpenRouter/MiniMax available");
+        console.log("  Add GEMINI_API_KEY for analysis, transcription, and doc conversion");
+      }
+    } else {
+      logger.error("One or more checks failed \u2014 see above");
+    }
+    process.exit(exitCode);
+  });
+}
+
+// src/commands/doc/convert.ts
+init_errors();
+import fs16 from "fs";
+import path14 from "path";
+
+// src/commands/doc/default-prompt.ts
+var DEFAULT_CONVERT_PROMPT = `Convert this document to clean, well-formatted Markdown.
+
+Requirements:
+- Preserve all content, structure, and formatting
+- Convert tables to markdown table format
+- Maintain heading hierarchy (# ## ### etc)
+- Preserve lists, code blocks, and quotes
+- Extract text from images if present
+- Keep formatting consistent and readable
+
+Output only the markdown content without any preamble or explanation.`;
+
+// src/commands/doc/convert.ts
+async function convertDocuments(opts) {
+  const { inputs, output, autoName = false, verbose, logger } = opts;
+  const model = opts.model ?? DOC_MODEL_DEFAULT;
+  const prompt = opts.prompt ?? DEFAULT_CONVERT_PROMPT;
+  for (const f of inputs) {
+    if (!fs16.existsSync(f)) throw new ValidationError(`Input file not found: ${f}`);
+  }
+  let outputPath;
+  if (output) {
+    outputPath = path14.resolve(output);
+  } else if (autoName && inputs.length === 1 && inputs[0]) {
+    const base = path14.basename(inputs[0], path14.extname(inputs[0]));
+    outputPath = path14.join(getOutputDir(), `${base}-extraction.md`);
+  } else {
+    outputPath = path14.join(getOutputDir(), "document-extraction.md");
+  }
+  fs16.mkdirSync(path14.dirname(outputPath), { recursive: true });
+  const results = [];
+  for (let i = 0; i < inputs.length; i++) {
+    const filePath = inputs[i];
+    logger?.debug(`[${i + 1}/${inputs.length}] Converting: ${filePath}`);
+    let markdown;
+    let errorMsg;
+    for (let attempt = 0; attempt < 3; attempt++) {
+      try {
+        const useApi = shouldUseFileApi(filePath);
+        let contentParts;
+        if (useApi) {
+          logger?.debug("File >20MB \u2014 using Files API");
+          const ref = await uploadFile(filePath, { logger });
+          contentParts = [
+            { text: prompt },
+            { fileData: { mimeType: ref.mimeType, fileUri: ref.uri } }
+          ];
+        } else {
+          contentParts = [{ text: prompt }, inlinePart(filePath)];
+        }
+        const resp = await generateContent({
+          model,
+          contents: [{ parts: contentParts }]
+        });
+        markdown = extractText(resp);
+        break;
+      } catch (e) {
+        errorMsg = e instanceof Error ? e.message : String(e);
+        if (attempt < 2) {
+          const wait = 2 ** attempt * 1e3;
+          logger?.debug(`Retry ${attempt + 1} after ${wait / 1e3}s: ${errorMsg}`);
+          await sleep4(wait);
+        }
+      }
+    }
+    results.push({
+      file: filePath,
+      status: markdown !== void 0 ? "success" : "error",
+      markdown,
+      error: errorMsg
+    });
+    logger?.debug(`Status: ${results[results.length - 1]?.status}`);
+  }
+  const lines = ["# Document Extraction Results\n"];
+  lines.push(`Converted ${inputs.length} document(s) to markdown.
+
+---
+`);
+  for (const r of results) {
+    lines.push(`
+## ${path14.basename(r.file)}
+`);
+    if (r.status === "success" && r.markdown) {
+      lines.push(`${r.markdown}
+`);
+    } else if (r.status === "success") {
+      lines.push("**Note**: Conversion succeeded but no content was returned.\n");
+    } else {
+      lines.push(`**Error**: ${r.error ?? "Unknown error"}
+`);
+    }
+    lines.push("\n---\n");
+  }
+  fs16.writeFileSync(outputPath, lines.join("\n"), "utf8");
+  const succeeded = results.filter((r) => r.status === "success").length;
+  console.log(`
+${"=".repeat(50)}`);
+  console.log(`Converted: ${results.length} file(s)`);
+  console.log(`Success: ${succeeded}`);
+  console.log(`Failed: ${results.length - succeeded}`);
+  console.log(`Output saved to: ${outputPath}`);
+  if (verbose) {
+    for (const r of results) {
+      console.log(`  [${r.status}] ${r.file}`);
+    }
+  }
+  const failed = results.filter((r) => r.status === "error").length;
+  if (failed > 0) process.exit(1);
+}
+function sleep4(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+// src/commands/doc/index.ts
+function registerDocCommands(program2) {
+  const doc = program2.command("doc").description("Document operations: convert PDFs, images, Office docs to Markdown via Gemini");
+  doc.command("convert").description("Convert documents to Markdown using Gemini Files API").requiredOption(
+    "--input <files...>",
+    "Input file(s) to convert",
+    (val, prev) => [...prev, val],
+    []
+  ).alias("-i").option("--output <path>", "Output markdown file path").option("--auto-name", "Derive output filename from input basename (single file only)").option("--model <id>", `Gemini model to use (default: ${DOC_MODEL_DEFAULT})`).option("--prompt <text>", "Custom conversion prompt").option("-v, --verbose", "Verbose logging").action(
+    async (opts) => {
+      const logger = createLogger({ verbose: opts.verbose ?? false });
+      await convertDocuments({
+        inputs: opts.input,
+        output: opts.output,
+        autoName: opts.autoName,
+        model: opts.model,
+        prompt: opts.prompt,
+        verbose: opts.verbose,
+        logger
+      });
+    }
+  );
+}
+
+// src/commands/media/index.ts
+init_errors();
+import fs19 from "fs";
+import path17 from "path";
+
+// src/commands/media/batch.ts
+import fs17 from "fs";
+import path15 from "path";
+
+// src/commands/media/detect-type.ts
+var VIDEO_EXTS = /* @__PURE__ */ new Set([".mp4", ".mov", ".avi", ".mkv", ".webm", ".flv", ".mpg", ".mpeg"]);
+var AUDIO_EXTS = /* @__PURE__ */ new Set([".mp3", ".wav", ".m4a", ".flac", ".aac", ".ogg", ".aiff"]);
+var IMAGE_EXTS = /* @__PURE__ */ new Set([".jpg", ".jpeg", ".png", ".webp", ".heic", ".heif", ".gif", ".bmp"]);
+function extToKind(ext) {
+  const lower = ext.toLowerCase();
+  if (VIDEO_EXTS.has(lower)) return "video";
+  if (AUDIO_EXTS.has(lower)) return "audio";
+  if (IMAGE_EXTS.has(lower)) return "image";
+  return void 0;
+}
+
+// src/commands/media/optimize-audio.ts
+init_errors();
+
+// src/commands/media/ffmpeg-runner.ts
+init_errors();
+import { execa as execa2 } from "execa";
+async function assertFfmpeg() {
+  try {
+    await execa2("ffmpeg", ["-version"], { reject: true });
+  } catch (e) {
+    if (e.code === "ENOENT") {
+      throw new ValidationError(
+        "ffmpeg not found on PATH.\n  Linux: sudo apt-get install ffmpeg\n  macOS: brew install ffmpeg\n  Windows: https://ffmpeg.org/download.html"
+      );
+    }
+  }
+}
+async function runFfmpeg(args, opts = {}) {
+  const { verbose, logger } = opts;
+  logger?.debug(`ffmpeg ${args.join(" ")}`);
+  try {
+    const result = await execa2("ffmpeg", args, { reject: true, all: true });
+    if (verbose && result.stderr) logger?.debug(result.stderr);
+  } catch (e) {
+    const err2 = e;
+    const stderr = (err2.stderr ?? err2.all ?? "").toString().slice(0, 1e3);
+    throw new ProviderError(`ffmpeg failed: ${stderr}`, "ffmpeg");
+  }
+}
+async function getMediaInfo(filePath) {
+  try {
+    const result = await execa2(
+      "ffprobe",
+      ["-v", "quiet", "-print_format", "json", "-show_format", "-show_streams", filePath],
+      { reject: true }
+    );
+    const data = JSON.parse(result.stdout);
+    const fmt = data.format ?? {};
+    const info = {
+      sizeByes: Number.parseInt(fmt.size ?? "0", 10),
+      duration: Number.parseFloat(fmt.duration ?? "0"),
+      bitRate: Number.parseInt(fmt.bit_rate ?? "0", 10)
+    };
+    for (const stream of data.streams ?? []) {
+      if (stream.codec_type === "video") {
+        info.width = stream.width;
+        info.height = stream.height;
+        if (stream.r_frame_rate) {
+          const [num, den] = stream.r_frame_rate.split("/").map(Number);
+          info.fps = den ? (num ?? 0) / (den ?? 1) : num;
+        }
+      } else if (stream.codec_type === "audio") {
+        info.sampleRate = Number.parseInt(stream.sample_rate ?? "0", 10);
+        info.channels = stream.channels;
+      }
+    }
+    return info;
+  } catch {
+    return {};
+  }
+}
+
+// src/commands/media/optimize-audio.ts
+async function optimizeAudio(opts) {
+  await assertFfmpeg();
+  const { input, output, bitrate = "64k", sampleRate = 16e3, verbose, logger } = opts;
+  const info = await getMediaInfo(input);
+  if (!info.duration) throw new ValidationError(`Cannot read media info from: ${input}`);
+  if (verbose && logger) {
+    logger.info(`Input: ${input}`);
+    logger.info(`  Size: ${((info.sizeByes ?? 0) / 1024 / 1024).toFixed(2)} MB`);
+    logger.info(`  Duration: ${(info.duration ?? 0).toFixed(2)}s`);
+  }
+  const args = [
+    "-i",
+    input,
+    "-y",
+    "-c:a",
+    "aac",
+    "-b:a",
+    bitrate,
+    "-ar",
+    String(sampleRate),
+    "-ac",
+    "1",
+    // mono — Gemini uses mono
+    output
+  ];
+  await runFfmpeg(args, { verbose, logger });
+  logger?.success(`Optimized: ${output}`);
+}
+
+// src/commands/media/magick-runner.ts
+init_errors();
+import { execa as execa3 } from "execa";
+async function assertMagick() {
+  try {
+    await execa3("magick", ["-version"], { reject: true });
+  } catch (e) {
+    if (e.code === "ENOENT") {
+      throw new ValidationError(
+        "ImageMagick (magick) not found on PATH.\n  Linux: sudo apt-get install imagemagick\n  macOS: brew install imagemagick\n  Windows: https://imagemagick.org/script/download.php"
+      );
+    }
+  }
+}
+async function runMagick(args, opts = {}) {
+  const { verbose, logger } = opts;
+  logger?.debug(`magick ${args.join(" ")}`);
+  try {
+    const result = await execa3("magick", args, { reject: true, all: true });
+    if (verbose && result.stderr) logger?.debug(result.stderr);
+  } catch (e) {
+    const err2 = e;
+    const stderr = (err2.stderr ?? err2.all ?? "").toString().slice(0, 1e3);
+    throw new ProviderError(`magick failed: ${stderr}`, "imagemagick");
+  }
+}
+
+// src/commands/media/optimize-image.ts
+async function optimizeImage(opts) {
+  await assertMagick();
+  const { input, output, maxWidth = 1920, quality = 85, verbose, logger } = opts;
+  const args = [input, "-resize", `${maxWidth}x>`, "-quality", String(quality), output];
+  await runMagick(args, { verbose, logger });
+  logger?.success(`Optimized: ${output}`);
+}
+
+// src/commands/media/optimize-video.ts
+init_errors();
+async function optimizeVideo(opts) {
+  await assertFfmpeg();
+  const {
+    input,
+    output,
+    targetSizeMb,
+    quality = 23,
+    resolution,
+    maxWidth = 1920,
+    verbose,
+    logger
+  } = opts;
+  const info = await getMediaInfo(input);
+  if (!info.duration) throw new ValidationError(`Cannot read media info from: ${input}`);
+  if (verbose && logger) {
+    logger.info(`Input: ${input}`);
+    logger.info(`  Size: ${((info.sizeByes ?? 0) / 1024 / 1024).toFixed(2)} MB`);
+    logger.info(`  Duration: ${(info.duration ?? 0).toFixed(2)}s`);
+    if (info.width) logger.info(`  Resolution: ${info.width}x${info.height}`);
+    logger.info(`  Bitrate: ${((info.bitRate ?? 0) / 1e3).toFixed(0)} kbps`);
+  }
+  const args = ["-i", input, "-y"];
+  args.push("-c:v", "libx264", "-crf", String(quality));
+  if (resolution) {
+    args.push("-vf", `scale=${resolution}`);
+  } else if ((info.width ?? 0) > maxWidth) {
+    args.push("-vf", "scale=1920:-2");
+  }
+  args.push("-c:a", "aac", "-b:a", "128k", "-ac", "2");
+  if (targetSizeMb && info.duration) {
+    const targetBits = targetSizeMb * 8 * 1024 * 1024;
+    const targetBitrate = Math.floor(targetBits / info.duration);
+    const videoBitrate = Math.max(targetBitrate - 128e3, 5e5);
+    args.push("-b:v", String(videoBitrate));
+  }
+  args.push(output);
+  await runFfmpeg(args, { verbose, logger });
+  logger?.success(`Optimized: ${output}`);
+}
+
+// src/commands/media/batch.ts
+var ALL_EXTS = /* @__PURE__ */ new Set([...VIDEO_EXTS, ...AUDIO_EXTS, ...IMAGE_EXTS]);
+async function batchOptimize(opts) {
+  const {
+    inputDir,
+    outputDir,
+    quality = 85,
+    maxWidth = 1920,
+    bitrate = "64k",
+    verbose,
+    logger
+  } = opts;
+  fs17.mkdirSync(outputDir, { recursive: true });
+  const entries = fs17.readdirSync(inputDir);
+  const mediaFiles = entries.filter((f) => {
+    const ext = path15.extname(f).toLowerCase();
+    return ALL_EXTS.has(ext);
+  });
+  if (mediaFiles.length === 0) {
+    logger?.warn(`No supported media files found in ${inputDir}`);
+    return { total: 0, succeeded: 0, failed: 0, errors: [] };
+  }
+  logger?.info(`Found ${mediaFiles.length} files to process`);
+  let succeeded = 0;
+  const errors = [];
+  for (const file of mediaFiles) {
+    const inputPath = path15.join(inputDir, file);
+    const outputPath = path15.join(outputDir, file);
+    const ext = path15.extname(file).toLowerCase();
+    const kind = extToKind(ext);
+    logger?.debug(`Processing: ${file}`);
+    try {
+      if (kind === "video") {
+        await optimizeVideo({
+          input: inputPath,
+          output: outputPath,
+          quality,
+          maxWidth,
+          verbose,
+          logger
+        });
+      } else if (kind === "audio") {
+        await optimizeAudio({ input: inputPath, output: outputPath, bitrate, verbose, logger });
+      } else if (kind === "image") {
+        await optimizeImage({
+          input: inputPath,
+          output: outputPath,
+          maxWidth,
+          quality,
+          verbose,
+          logger
+        });
+      }
+      succeeded++;
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      logger?.error(`Failed: ${file} \u2014 ${msg}`);
+      errors.push({ file, error: msg });
+    }
+  }
+  return { total: mediaFiles.length, succeeded, failed: errors.length, errors };
+}
+
+// src/commands/media/split-video.ts
+init_errors();
+import fs18 from "fs";
+import path16 from "path";
+async function splitVideo(opts) {
+  await assertFfmpeg();
+  const { input, outputDir, chunkDuration = 3600, verbose, logger } = opts;
+  const info = await getMediaInfo(input);
+  if (!info.duration) throw new ValidationError(`Cannot read media info from: ${input}`);
+  const numChunks = Math.ceil(info.duration / chunkDuration);
+  if (numChunks <= 1) {
+    logger?.info("Video is short enough \u2014 no splitting needed");
+    return [input];
+  }
+  fs18.mkdirSync(outputDir, { recursive: true });
+  const ext = path16.extname(input) || ".mp4";
+  const baseName = path16.basename(input, ext);
+  const outputPattern = path16.join(outputDir, `${baseName}_chunk_%03d${ext}`);
+  logger?.debug(`Splitting into ~${numChunks} chunks of ${chunkDuration}s each`);
+  const args = [
+    "-i",
+    input,
+    "-y",
+    "-f",
+    "segment",
+    "-segment_time",
+    String(chunkDuration),
+    "-c",
+    "copy",
+    "-reset_timestamps",
+    "1",
+    outputPattern
+  ];
+  await runFfmpeg(args, { verbose, logger });
+  const files = [];
+  for (let i = 0; i < numChunks + 1; i++) {
+    const fname = path16.join(outputDir, `${baseName}_chunk_${String(i).padStart(3, "0")}${ext}`);
+    if (fs18.existsSync(fname)) files.push(fname);
+  }
+  logger?.success(`Created ${files.length} chunks in ${outputDir}`);
+  return files;
+}
+
+// src/commands/media/index.ts
+function registerMediaCommands(program2) {
+  const media = program2.command("media").description(
+    "Media optimization: compress video/audio/images, split long videos, batch process"
+  );
+  media.command("optimize").description("Optimize a single media file (video, audio, or image)").requiredOption("--input <file>", "Input media file").requiredOption("--output <file>", "Output file path").option("--target-size <MB>", "Target file size in MB").option("--quality <n>", "Quality: video CRF (0-51) or image (1-100)", "85").option("--max-width <px>", "Max image/video width in pixels", "1920").option("--bitrate <rate>", "Audio bitrate (e.g. 64k)", "64k").option("--resolution <WxH>", "Force video resolution (e.g. 1920x1080)").option("-v, --verbose", "Verbose logging").action(
+    async (opts) => {
+      const logger = createLogger({ verbose: opts.verbose ?? false });
+      if (!fs19.existsSync(opts.input)) throw new ValidationError(`Input not found: ${opts.input}`);
+      fs19.mkdirSync(path17.dirname(path17.resolve(opts.output)), { recursive: true });
+      const ext = path17.extname(opts.input).toLowerCase();
+      const kind = extToKind(ext);
+      if (!kind) throw new ValidationError(`Unsupported file type: ${ext}`);
+      const quality = Number.parseInt(opts.quality, 10);
+      const maxWidth = Number.parseInt(opts.maxWidth, 10);
+      const targetSizeMb = opts.targetSize ? Number.parseInt(opts.targetSize, 10) : void 0;
+      if (kind === "video") {
+        await optimizeVideo({
+          input: opts.input,
+          output: opts.output,
+          targetSizeMb,
+          quality,
+          maxWidth,
+          resolution: opts.resolution,
+          verbose: opts.verbose,
+          logger
+        });
+      } else if (kind === "audio") {
+        await optimizeAudio({
+          input: opts.input,
+          output: opts.output,
+          bitrate: opts.bitrate,
+          verbose: opts.verbose,
+          logger
+        });
+      } else {
+        await optimizeImage({
+          input: opts.input,
+          output: opts.output,
+          maxWidth,
+          quality,
+          verbose: opts.verbose,
+          logger
+        });
+      }
+    }
+  );
+  media.command("split").description("Split a long video into fixed-duration chunks").requiredOption("--input <file>", "Input video file").option("--output-dir <dir>", "Output directory for chunks", "./chunks").option("--chunk-duration <sec>", "Chunk duration in seconds", "3600").option("-v, --verbose", "Verbose logging").action(
+    async (opts) => {
+      const logger = createLogger({ verbose: opts.verbose ?? false });
+      if (!fs19.existsSync(opts.input)) throw new ValidationError(`Input not found: ${opts.input}`);
+      const chunks = await splitVideo({
+        input: opts.input,
+        outputDir: opts.outputDir,
+        chunkDuration: Number.parseInt(opts.chunkDuration, 10),
+        verbose: opts.verbose,
+        logger
+      });
+      console.log(`
+Created ${chunks.length} chunk(s) in ${opts.outputDir}`);
+      for (const c2 of chunks) console.log(`  ${c2}`);
+    }
+  );
+  media.command("batch").description("Batch optimize all media files in a directory").requiredOption("--input-dir <dir>", "Input directory").requiredOption("--output-dir <dir>", "Output directory").option("--quality <n>", "Quality setting", "85").option("--max-width <px>", "Max image/video width", "1920").option("--bitrate <rate>", "Audio bitrate", "64k").option("-v, --verbose", "Verbose logging").action(
+    async (opts) => {
+      const logger = createLogger({ verbose: opts.verbose ?? false });
+      if (!fs19.existsSync(opts.inputDir))
+        throw new ValidationError(`Input dir not found: ${opts.inputDir}`);
+      const result = await batchOptimize({
+        inputDir: opts.inputDir,
+        outputDir: opts.outputDir,
+        quality: Number.parseInt(opts.quality, 10),
+        maxWidth: Number.parseInt(opts.maxWidth, 10),
+        bitrate: opts.bitrate,
+        verbose: opts.verbose,
+        logger
+      });
+      console.log(`
+Processed: ${result.succeeded}/${result.total} files`);
+      if (result.failed > 0) {
+        console.log(`Failed: ${result.failed}`);
+        process.exit(1);
+      }
+    }
+  );
+}
+
+// src/commands/index.ts
+function registerCommands(program2) {
+  registerCheckCommand(program2);
+  registerGeminiCommands(program2);
+  registerMinimaxCommands(program2);
+  registerOpenRouterCommands(program2);
+  registerMediaCommands(program2);
+  registerDocCommands(program2);
+}
+
+// src/core/index.ts
+init_errors();
+init_http_client();
+
+// src/cli.ts
+loadEnv();
+var require2 = createRequire(import.meta.url);
+var pkg = require2("../package.json");
+var program = new Command().name("multix").description(
+  "AI multimodal CLI \u2014 Gemini \xB7 MiniMax \xB7 OpenRouter \xB7 ffmpeg \xB7 ImageMagick \xB7 doc-to-md"
+).version(pkg.version);
+registerCommands(program);
+program.parseAsync(process.argv).catch((err2) => {
+  const msg = err2 instanceof Error ? err2.message : String(err2);
+  console.error(`Error: ${msg}`);
+  process.exit(1);
+});