@genart-dev/cli 0.2.0

package/dist/index.js

@@ -0,0 +1,2012 @@
+#!/usr/bin/env node
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/index.ts
+import { Command as Command16 } from "commander";
+
+// src/commands/render.ts
+import { Command } from "commander";
+import { resolve, basename, extname } from "path";
+import { writeFile } from "fs/promises";
+import chalk from "chalk";
+import ora from "ora";
+import { createDefaultRegistry } from "@genart-dev/core";
+
+// src/util/load-sketch.ts
+import { readFile } from "fs/promises";
+import { parseGenart } from "@genart-dev/format";
+async function loadSketch(filePath) {
+  const raw = await readFile(filePath, "utf-8");
+  const json = JSON.parse(raw);
+  return parseGenart(json);
+}
+
+// src/util/apply-overrides.ts
+import {
+  resolvePreset
+} from "@genart-dev/format";
+function applyOverrides(sketch, overrides) {
+  let canvas = { ...sketch.canvas };
+  let state = { ...sketch.state, params: { ...sketch.state.params } };
+  if (overrides.preset) {
+    const dims = resolvePreset(overrides.preset);
+    canvas = { ...canvas, preset: overrides.preset, width: dims.width, height: dims.height };
+  }
+  if (overrides.width !== void 0) canvas = { ...canvas, width: overrides.width };
+  if (overrides.height !== void 0) canvas = { ...canvas, height: overrides.height };
+  if (overrides.seed !== void 0) {
+    state = { ...state, seed: overrides.seed };
+  }
+  if (overrides.params) {
+    state = { ...state, params: { ...state.params, ...overrides.params } };
+  }
+  if (overrides.colors) {
+    state = { ...state, colorPalette: overrides.colors };
+  }
+  return { ...sketch, canvas, state };
+}
+
+// src/util/parse-wait.ts
+function parseWait(value) {
+  const trimmed = value.trim().toLowerCase();
+  if (trimmed.endsWith("ms")) {
+    return Math.max(0, Number(trimmed.slice(0, -2)));
+  }
+  if (trimmed.endsWith("s")) {
+    return Math.max(0, Number(trimmed.slice(0, -1)) * 1e3);
+  }
+  const num = Number(trimmed);
+  if (Number.isNaN(num)) {
+    throw new Error(`Invalid wait value: "${value}". Use "500ms" or "2s".`);
+  }
+  return Math.max(0, num);
+}
+
+// src/capture/browser.ts
+import puppeteer from "puppeteer-core";
+import { existsSync } from "fs";
+var CHROME_PATHS = {
+  darwin: [
+    "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+    "/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary",
+    "/Applications/Chromium.app/Contents/MacOS/Chromium",
+    "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser",
+    "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge"
+  ],
+  linux: [
+    "/usr/bin/google-chrome",
+    "/usr/bin/google-chrome-stable",
+    "/usr/bin/chromium",
+    "/usr/bin/chromium-browser",
+    "/snap/bin/chromium"
+  ],
+  win32: [
+    "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe",
+    "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe"
+  ]
+};
+function findChromePath() {
+  const envPath = process.env["GENART_CHROME_PATH"];
+  if (envPath && existsSync(envPath)) return envPath;
+  const paths = CHROME_PATHS[process.platform];
+  if (!paths) return void 0;
+  for (const p of paths) {
+    if (existsSync(p)) return p;
+  }
+  return void 0;
+}
+var browserInstance = null;
+async function getBrowser() {
+  if (browserInstance?.connected) {
+    return browserInstance;
+  }
+  const executablePath = findChromePath();
+  if (!executablePath) {
+    throw new Error(
+      "No Chrome/Chromium found. Install Google Chrome or set GENART_CHROME_PATH.\n  macOS: brew install --cask google-chrome\n  Linux: sudo apt install google-chrome-stable\n  Or: GENART_CHROME_PATH=/path/to/chrome genart render ..."
+    );
+  }
+  browserInstance = await puppeteer.launch({
+    headless: true,
+    executablePath,
+    args: [
+      "--no-sandbox",
+      "--disable-setuid-sandbox",
+      "--disable-gpu",
+      "--disable-dev-shm-usage"
+    ]
+  });
+  return browserInstance;
+}
+async function captureHtml(options) {
+  const {
+    html,
+    width,
+    height,
+    waitMs = 500,
+    format = "png",
+    quality = 80,
+    scale = 1
+  } = options;
+  const browser = await getBrowser();
+  const page = await browser.newPage();
+  try {
+    await page.setViewport({ width, height, deviceScaleFactor: scale });
+    await page.setContent(html, { waitUntil: "domcontentloaded", timeout: 3e4 });
+    if (waitMs > 0) {
+      await new Promise((resolve10) => setTimeout(resolve10, waitMs));
+    }
+    const screenshotType = format === "webp" ? "webp" : format;
+    const buffer = await page.screenshot({
+      type: screenshotType,
+      clip: { x: 0, y: 0, width, height },
+      ...screenshotType !== "png" ? { quality } : {}
+    });
+    const bytes = new Uint8Array(buffer);
+    const mimeType = `image/${format}`;
+    return { bytes, mimeType, width, height };
+  } finally {
+    await page.close();
+  }
+}
+async function getPage(width, height, scale = 1) {
+  const browser = await getBrowser();
+  const page = await browser.newPage();
+  await page.setViewport({ width, height, deviceScaleFactor: scale });
+  return page;
+}
+async function closeBrowser() {
+  if (browserInstance) {
+    await browserInstance.close();
+    browserInstance = null;
+  }
+}
+
+// src/commands/render.ts
+var renderCommand = new Command("render").description("Render a .genart sketch to an image").argument("<file>", "Path to .genart file").option("--wait <duration>", "How long to let the sketch animate before capture", "500ms").option("--seed <n>", "Override seed", Number).option("--params <json>", "Override parameters (JSON object)").option("--colors <json>", "Override color palette (JSON array of hex strings)").option("--width <n>", "Override canvas width", Number).option("--height <n>", "Override canvas height", Number).option("--preset <name>", "Use a canvas preset").option("--format <fmt>", "Output format: png, jpeg, webp", "png").option("--quality <n>", "Lossy compression quality (0-100)", Number, 80).option("--scale <n>", "Pixel density multiplier", Number, 1).option("-o, --output <path>", "Output file path").action(async (file, opts) => {
+  const spinner = ora("Loading sketch...").start();
+  try {
+    const filePath = resolve(file);
+    const sketch = await loadSketch(filePath);
+    const overrides = {};
+    if (opts.seed !== void 0) overrides.seed = opts.seed;
+    if (opts.width !== void 0) overrides.width = opts.width;
+    if (opts.height !== void 0) overrides.height = opts.height;
+    if (opts.preset) overrides.preset = opts.preset;
+    if (opts.params) {
+      overrides.params = JSON.parse(opts.params);
+    }
+    if (opts.colors) {
+      overrides.colors = JSON.parse(opts.colors);
+    }
+    const modified = applyOverrides(sketch, overrides);
+    spinner.text = "Generating standalone HTML...";
+    const registry = createDefaultRegistry();
+    const adapter = registry.resolve(modified.renderer.type);
+    const html = adapter.generateStandaloneHTML(modified);
+    const waitMs = parseWait(opts.wait);
+    const format = opts.format;
+    spinner.text = `Rendering (${modified.canvas.width}\xD7${modified.canvas.height}, wait ${waitMs}ms)...`;
+    const result = await captureHtml({
+      html,
+      width: modified.canvas.width,
+      height: modified.canvas.height,
+      waitMs,
+      format,
+      quality: opts.quality,
+      scale: opts.scale
+    });
+    const outputPath = resolve(
+      opts.output ?? `${basename(filePath, extname(filePath))}.${format}`
+    );
+    await writeFile(outputPath, result.bytes);
+    spinner.succeed(
+      chalk.green(`Rendered ${modified.canvas.width}\xD7${modified.canvas.height} \u2192 ${outputPath}`)
+    );
+  } catch (err) {
+    spinner.fail(chalk.red(`Render failed: ${err.message}`));
+    process.exitCode = 1;
+  } finally {
+    await closeBrowser();
+  }
+});
+
+// src/commands/info.ts
+import { Command as Command2 } from "commander";
+import { resolve as resolve2 } from "path";
+import chalk2 from "chalk";
+function formatDate(iso) {
+  return iso.slice(0, 10);
+}
+function formatHumanReadable(filePath, sketch) {
+  const lines = [];
+  lines.push(chalk2.bold(filePath));
+  const pad = (label) => `  ${chalk2.dim(label.padEnd(14))}`;
+  lines.push(`${pad("Title:")}${sketch.title}`);
+  if (sketch.subtitle) lines.push(`${pad("Subtitle:")}${sketch.subtitle}`);
+  lines.push(`${pad("Renderer:")}${sketch.renderer.type}${sketch.renderer.version ? ` ${sketch.renderer.version}` : ""}`);
+  lines.push(`${pad("Canvas:")}${sketch.canvas.width}\xD7${sketch.canvas.height}${sketch.canvas.preset ? ` (${sketch.canvas.preset})` : ""}`);
+  lines.push(`${pad("Seed:")}${sketch.state.seed}`);
+  if (sketch.parameters.length > 0) {
+    const paramStr = sketch.parameters.map((p) => {
+      const val = sketch.state.params[p.key];
+      return `${p.key} (${val ?? p.default})`;
+    }).join(", ");
+    lines.push(`${pad("Parameters:")}${paramStr}`);
+  }
+  if (sketch.colors.length > 0) {
+    const palette = sketch.state.colorPalette;
+    const colorStr = Array.isArray(palette) && palette.length > 0 ? palette.join(", ") : sketch.colors.map((c) => c.default).join(", ");
+    lines.push(`${pad("Colors:")}${colorStr}`);
+  }
+  if (sketch.skills && sketch.skills.length > 0) {
+    lines.push(`${pad("Skills:")}${sketch.skills.join(", ")}`);
+  }
+  lines.push(`${pad("Created:")}${formatDate(sketch.created)}`);
+  lines.push(`${pad("Modified:")}${formatDate(sketch.modified)}`);
+  if (sketch.agent) lines.push(`${pad("Agent:")}${sketch.agent}`);
+  return lines.join("\n");
+}
+function formatTable(entries) {
+  const header = ["File", "Title", "Renderer", "Canvas", "Seed", "Params", "Colors"].join("	");
+  const rows = entries.map(({ path: p, sketch }) => {
+    return [
+      p,
+      sketch.title,
+      sketch.renderer.type,
+      `${sketch.canvas.width}\xD7${sketch.canvas.height}`,
+      String(sketch.state.seed),
+      String(sketch.parameters.length),
+      String(sketch.colors.length)
+    ].join("	");
+  });
+  return [header, ...rows].join("\n");
+}
+var infoCommand = new Command2("info").description("Inspect .genart sketch metadata").argument("<files...>", "Path(s) to .genart file(s)").option("--json", "Machine-readable JSON output").option("--table", "Tabular output for multiple files").action(async (files, opts) => {
+  try {
+    const entries = [];
+    for (const file of files) {
+      const filePath = resolve2(file);
+      const sketch = await loadSketch(filePath);
+      entries.push({ path: filePath, sketch });
+    }
+    if (opts.json) {
+      const data = entries.length === 1 ? entries[0].sketch : entries.map((e) => ({ file: e.path, ...e.sketch }));
+      console.log(JSON.stringify(data, null, 2));
+    } else if (opts.table) {
+      console.log(formatTable(entries));
+    } else {
+      for (const entry of entries) {
+        console.log(formatHumanReadable(entry.path, entry.sketch));
+        if (entries.length > 1) console.log();
+      }
+    }
+  } catch (err) {
+    console.error(chalk2.red(`Error: ${err.message}`));
+    process.exitCode = 1;
+  }
+});
+
+// src/commands/validate.ts
+import { Command as Command3 } from "commander";
+import { resolve as resolve3 } from "path";
+import { stat, readdir } from "fs/promises";
+import chalk3 from "chalk";
+import { createDefaultRegistry as createDefaultRegistry2 } from "@genart-dev/core";
+async function resolveFiles(inputs) {
+  const files = [];
+  for (const input of inputs) {
+    const p = resolve3(input);
+    const info = await stat(p);
+    if (info.isDirectory()) {
+      const entries = await readdir(p);
+      for (const entry of entries) {
+        if (entry.endsWith(".genart")) {
+          files.push(resolve3(p, entry));
+        }
+      }
+    } else {
+      files.push(p);
+    }
+  }
+  return files;
+}
+var validateCommand = new Command3("validate").description("Validate .genart files").argument("<paths...>", "Path(s) to .genart file(s) or directories").option("--strict", "Also run adapter.validate() on algorithm source").action(async (paths, opts) => {
+  let hasErrors = false;
+  try {
+    const files = await resolveFiles(paths);
+    if (files.length === 0) {
+      console.error(chalk3.yellow("No .genart files found."));
+      process.exitCode = 1;
+      return;
+    }
+    const registry = opts.strict ? createDefaultRegistry2() : null;
+    for (const filePath of files) {
+      try {
+        const sketch = await loadSketch(filePath);
+        if (opts.strict && registry) {
+          const adapter = registry.resolve(sketch.renderer.type);
+          const result = adapter.validate(sketch.algorithm);
+          if (!result.valid) {
+            console.error(chalk3.red(`\u2717 ${filePath}`));
+            for (const err of result.errors) {
+              console.error(chalk3.red(`    ${err}`));
+            }
+            hasErrors = true;
+            continue;
+          }
+        }
+        console.log(chalk3.green(`\u2713 ${filePath}`));
+      } catch (err) {
+        console.error(chalk3.red(`\u2717 ${filePath}`));
+        console.error(chalk3.red(`    ${err.message}`));
+        hasErrors = true;
+      }
+    }
+  } catch (err) {
+    console.error(chalk3.red(`Error: ${err.message}`));
+    hasErrors = true;
+  }
+  if (hasErrors) {
+    process.exitCode = 1;
+  }
+});
+
+// src/commands/init.ts
+import { Command as Command4 } from "commander";
+import { resolve as resolve4 } from "path";
+import { writeFile as writeFile2 } from "fs/promises";
+import chalk4 from "chalk";
+import ora2 from "ora";
+import { createDefaultRegistry as createDefaultRegistry3 } from "@genart-dev/core";
+import {
+  serializeGenart,
+  CANVAS_PRESETS,
+  resolvePreset as resolvePreset2
+} from "@genart-dev/format";
+var RENDERER_TYPES = ["p5", "canvas2d", "three", "glsl", "svg"];
+function slugify(title) {
+  return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+var initCommand = new Command4("init").description("Scaffold a new .genart sketch file").argument("[name]", "Sketch name / title").option("--renderer <type>", `Renderer type: ${RENDERER_TYPES.join(", ")}`).option("--preset <name>", "Canvas preset", "square-600").option("--title <string>", "Sketch title").action(async (name, opts) => {
+  const spinner = ora2("").start();
+  spinner.stop();
+  try {
+    let rendererType;
+    let preset;
+    let title;
+    if (opts.renderer) {
+      rendererType = opts.renderer;
+      if (!RENDERER_TYPES.includes(rendererType)) {
+        throw new Error(
+          `Invalid renderer "${rendererType}". Choose from: ${RENDERER_TYPES.join(", ")}`
+        );
+      }
+    } else {
+      const { default: inquirer } = await import("inquirer");
+      const answers = await inquirer.prompt([
+        {
+          type: "list",
+          name: "renderer",
+          message: "Renderer type:",
+          choices: RENDERER_TYPES.map((t) => ({ name: t, value: t }))
+        }
+      ]);
+      rendererType = answers.renderer;
+    }
+    if (opts.title) {
+      title = opts.title;
+    } else if (name) {
+      title = name;
+    } else {
+      const { default: inquirer } = await import("inquirer");
+      const answers = await inquirer.prompt([
+        {
+          type: "input",
+          name: "title",
+          message: "Sketch title:",
+          default: "Untitled Sketch"
+        }
+      ]);
+      title = answers.title;
+    }
+    if (opts.preset) {
+      preset = opts.preset;
+    } else {
+      const { default: inquirer } = await import("inquirer");
+      const choices = CANVAS_PRESETS.map((p) => ({
+        name: `${p.id} (${p.width}\xD7${p.height})`,
+        value: p.id
+      }));
+      const answers = await inquirer.prompt([
+        {
+          type: "list",
+          name: "preset",
+          message: "Canvas preset:",
+          choices,
+          default: "square-600"
+        }
+      ]);
+      preset = answers.preset;
+    }
+    const dims = resolvePreset2(preset);
+    const registry = createDefaultRegistry3();
+    const adapter = registry.resolve(rendererType);
+    const algorithm = adapter.getAlgorithmTemplate();
+    const id = slugify(title);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const sketch = {
+      genart: "1.0",
+      id,
+      title,
+      created: now,
+      modified: now,
+      renderer: { type: rendererType },
+      canvas: { preset, width: dims.width, height: dims.height },
+      parameters: [],
+      colors: [],
+      state: {
+        seed: Math.floor(Math.random() * 1e4),
+        params: {},
+        colorPalette: []
+      },
+      algorithm
+    };
+    const outputPath = resolve4(`${id}.genart`);
+    const json = serializeGenart(sketch);
+    await writeFile2(outputPath, json, "utf-8");
+    console.log(chalk4.green(`\u2713 Created ${outputPath}`));
+    console.log(chalk4.dim(`  Renderer: ${rendererType}`));
+    console.log(chalk4.dim(`  Canvas:   ${dims.width}\xD7${dims.height} (${preset})`));
+  } catch (err) {
+    console.error(chalk4.red(`Error: ${err.message}`));
+    process.exitCode = 1;
+  }
+});
+
+// src/commands/export.ts
+import { Command as Command5 } from "commander";
+import { resolve as resolve5, basename as basename2, extname as extname2 } from "path";
+import { writeFile as writeFile3 } from "fs/promises";
+import chalk5 from "chalk";
+import ora3 from "ora";
+import { createDefaultRegistry as createDefaultRegistry4 } from "@genart-dev/core";
+var exportCommand = new Command5("export").description("Export sketch as HTML, image, or algorithm source").argument("<file>", "Path to .genart file").option("--format <fmt>", "Export format: html, png, jpeg, webp, algorithm", "html").option("--wait <duration>", "Render wait time (for image formats)", "500ms").option("--seed <n>", "Override seed", Number).option("--params <json>", "Override parameters (JSON object)").option("--colors <json>", "Override color palette (JSON array)").option("--width <n>", "Override canvas width", Number).option("--height <n>", "Override canvas height", Number).option("--preset <name>", "Use a canvas preset").option("--quality <n>", "Lossy compression quality (0-100)", Number, 80).option("--scale <n>", "Pixel density multiplier", Number, 1).option("-o, --output <path>", "Output file path").action(async (file, opts) => {
+  const spinner = ora3("Loading sketch...").start();
+  try {
+    const filePath = resolve5(file);
+    const sketch = await loadSketch(filePath);
+    const overrides = {};
+    if (opts.seed !== void 0) overrides.seed = opts.seed;
+    if (opts.width !== void 0) overrides.width = opts.width;
+    if (opts.height !== void 0) overrides.height = opts.height;
+    if (opts.preset) overrides.preset = opts.preset;
+    if (opts.params) {
+      overrides.params = JSON.parse(opts.params);
+    }
+    if (opts.colors) {
+      overrides.colors = JSON.parse(opts.colors);
+    }
+    const modified = applyOverrides(sketch, overrides);
+    const registry = createDefaultRegistry4();
+    const adapter = registry.resolve(modified.renderer.type);
+    const format = opts.format;
+    const baseName = basename2(filePath, extname2(filePath));
+    let outputPath;
+    let content;
+    if (format === "html") {
+      spinner.text = "Generating standalone HTML...";
+      content = adapter.generateStandaloneHTML(modified);
+      outputPath = resolve5(opts.output ?? `${baseName}.html`);
+    } else if (format === "algorithm") {
+      spinner.text = "Extracting algorithm...";
+      content = modified.algorithm;
+      const ext = modified.renderer.type === "glsl" ? "glsl" : "js";
+      outputPath = resolve5(opts.output ?? `${baseName}.${ext}`);
+    } else if (format === "png" || format === "jpeg" || format === "webp") {
+      spinner.text = `Rendering ${format}...`;
+      const html = adapter.generateStandaloneHTML(modified);
+      const waitMs = parseWait(opts.wait);
+      const result = await captureHtml({
+        html,
+        width: modified.canvas.width,
+        height: modified.canvas.height,
+        waitMs,
+        format,
+        quality: opts.quality,
+        scale: opts.scale
+      });
+      content = result.bytes;
+      outputPath = resolve5(opts.output ?? `${baseName}.${format}`);
+    } else {
+      throw new Error(`Unsupported export format: "${format}". Use: html, png, jpeg, webp, algorithm`);
+    }
+    await writeFile3(outputPath, content, typeof content === "string" ? "utf-8" : void 0);
+    spinner.succeed(chalk5.green(`Exported \u2192 ${outputPath}`));
+  } catch (err) {
+    spinner.fail(chalk5.red(`Export failed: ${err.message}`));
+    process.exitCode = 1;
+  } finally {
+    await closeBrowser();
+  }
+});
+
+// src/commands/batch.ts
+import { Command as Command6 } from "commander";
+import { resolve as resolve6, basename as basename3, extname as extname3 } from "path";
+import { writeFile as writeFile4, mkdir } from "fs/promises";
+import chalk6 from "chalk";
+import ora4 from "ora";
+import { createDefaultRegistry as createDefaultRegistry5 } from "@genart-dev/core";
+
+// src/util/parse-seeds.ts
+function parseSeeds(value) {
+  const seeds = [];
+  for (const part of value.split(",")) {
+    const trimmed = part.trim();
+    if (trimmed.includes("-")) {
+      const [startStr, endStr] = trimmed.split("-");
+      const start = Number(startStr);
+      const end = Number(endStr);
+      if (Number.isNaN(start) || Number.isNaN(end) || start > end) {
+        throw new Error(`Invalid seed range: "${trimmed}". Use "1-100".`);
+      }
+      for (let i = start; i <= end; i++) {
+        seeds.push(i);
+      }
+    } else {
+      const n = Number(trimmed);
+      if (Number.isNaN(n) || !Number.isInteger(n)) {
+        throw new Error(`Invalid seed value: "${trimmed}". Must be an integer.`);
+      }
+      seeds.push(n);
+    }
+  }
+  if (seeds.length === 0) {
+    throw new Error(`No seeds parsed from: "${value}"`);
+  }
+  return seeds;
+}
+
+// src/util/parse-sweep.ts
+function parseSweep(value) {
+  const match = value.match(/^([^=]+)=([^:]+):([^:]+):(.+)$/);
+  if (!match) {
+    throw new Error(
+      `Invalid sweep format: "${value}". Use "param=min:max:step" (e.g. "amplitude=0:1:0.1").`
+    );
+  }
+  const [, key, minStr, maxStr, stepStr] = match;
+  const min = Number(minStr);
+  const max = Number(maxStr);
+  const step = Number(stepStr);
+  if (Number.isNaN(min) || Number.isNaN(max) || Number.isNaN(step)) {
+    throw new Error(`Invalid numeric values in sweep: "${value}".`);
+  }
+  if (step <= 0) {
+    throw new Error(`Sweep step must be positive: "${value}".`);
+  }
+  if (min > max) {
+    throw new Error(`Sweep min must be \u2264 max: "${value}".`);
+  }
+  const values = [];
+  for (let v = min; v <= max + step * 1e-3; v += step) {
+    values.push(Math.round(v * 1e10) / 1e10);
+  }
+  if (values.length > 0 && values[values.length - 1] > max) {
+    values.pop();
+  }
+  return { key, min, max, step, values };
+}
+function cartesianProduct(seeds, sweeps) {
+  if (sweeps.length === 0) {
+    return seeds.map((seed) => ({ seed, params: {} }));
+  }
+  const paramCombos = sweepProduct(sweeps);
+  const results = [];
+  for (const seed of seeds) {
+    for (const params of paramCombos) {
+      results.push({ seed, params });
+    }
+  }
+  return results;
+}
+function sweepProduct(sweeps) {
+  if (sweeps.length === 0) return [{}];
+  const [first, ...rest] = sweeps;
+  const restCombos = sweepProduct(rest);
+  const results = [];
+  for (const value of first.values) {
+    for (const combo of restCombos) {
+      results.push({ [first.key]: value, ...combo });
+    }
+  }
+  return results;
+}
+
+// src/util/naming.ts
+function formatOutputName(pattern, ctx) {
+  let result = pattern;
+  result = result.replace(/\{id\}/g, ctx.id);
+  result = result.replace(/\{seed\}/g, String(ctx.seed));
+  result = result.replace(/\{index\}/g, String(ctx.index).padStart(4, "0"));
+  if (result.includes("{params}")) {
+    const paramStr = Object.entries(ctx.params).map(([k, v]) => `${k}=${v}`).join("_");
+    result = result.replace(/\{params\}/g, paramStr || "default");
+  }
+  return `${result}.${ctx.format}`;
+}
+
+// src/commands/batch.ts
+function collectSweeps(value, prev) {
+  return [...prev, value];
+}
+var batchCommand = new Command6("batch").description("Generate many renders from one sketch \u2014 seed ranges, parameter sweeps").argument("<files...>", "Path(s) to .genart file(s)").option("--seeds <range>", "Seed range or list (e.g. 1-100, 1,5,42)").option("--sweep <spec>", "Parameter sweep (repeatable, e.g. amplitude=0:1:0.1)", collectSweeps, []).option("--random <n>", "Generate N random seed + param combinations", Number).option("--matrix", "Cartesian product of seeds \xD7 sweeps").option("--concurrency <n>", "Parallel captures", Number, 4).option("--naming <pattern>", "Output naming pattern: {id}, {seed}, {index}, {params}", "{id}-{seed}").option("--manifest", "Write manifest.json with per-render metadata").option("--wait <duration>", "Render wait time", "500ms").option("--width <n>", "Override canvas width", Number).option("--height <n>", "Override canvas height", Number).option("--preset <name>", "Use a canvas preset").option("--format <fmt>", "Output format: png, jpeg, webp", "png").option("--quality <n>", "Lossy compression quality (0-100)", Number, 80).option("--scale <n>", "Pixel density multiplier", Number, 1).option("--colors <json>", "Override color palette (JSON array)").option("-o, --output-dir <dir>", "Output directory", ".").action(async (files, opts) => {
+  const spinner = ora4("Preparing batch...").start();
+  try {
+    const outputDir = resolve6(opts.outputDir);
+    await mkdir(outputDir, { recursive: true });
+    const waitMs = parseWait(opts.wait);
+    const format = opts.format;
+    const concurrency = opts.concurrency;
+    const namingPattern = opts.naming;
+    const registry = createDefaultRegistry5();
+    const manifest = [];
+    let totalRendered = 0;
+    for (const file of files) {
+      const filePath = resolve6(file);
+      const sketch = await loadSketch(filePath);
+      const sketchId = sketch.id ?? basename3(filePath, extname3(filePath));
+      const baseOverrides = {};
+      if (opts.width !== void 0) baseOverrides.width = opts.width;
+      if (opts.height !== void 0) baseOverrides.height = opts.height;
+      if (opts.preset) baseOverrides.preset = opts.preset;
+      if (opts.colors) {
+        baseOverrides.colors = JSON.parse(opts.colors);
+      }
+      const jobs = generateJobs(opts, sketch.state.seed);
+      spinner.text = `Batch: ${jobs.length} render${jobs.length === 1 ? "" : "s"} for ${basename3(filePath)}`;
+      for (let i = 0; i < jobs.length; i += concurrency) {
+        const chunk = jobs.slice(i, i + concurrency);
+        const promises = chunk.map(async (job, chunkIdx) => {
+          const idx = i + chunkIdx;
+          const overrides = {
+            ...baseOverrides,
+            seed: job.seed,
+            ...Object.keys(job.params).length > 0 ? { params: job.params } : {}
+          };
+          const modified = applyOverrides(sketch, overrides);
+          const adapter = registry.resolve(modified.renderer.type);
+          const html = adapter.generateStandaloneHTML(modified);
+          const result = await captureHtml({
+            html,
+            width: modified.canvas.width,
+            height: modified.canvas.height,
+            waitMs,
+            format,
+            quality: opts.quality,
+            scale: opts.scale
+          });
+          const fileName = formatOutputName(namingPattern, {
+            id: sketchId,
+            seed: job.seed,
+            index: idx,
+            params: job.params,
+            format
+          });
+          const outputPath = resolve6(outputDir, fileName);
+          await writeFile4(outputPath, result.bytes);
+          manifest.push({
+            file: basename3(filePath),
+            seed: job.seed,
+            params: job.params,
+            path: outputPath,
+            width: modified.canvas.width,
+            height: modified.canvas.height,
+            format
+          });
+          return outputPath;
+        });
+        await Promise.all(promises);
+        totalRendered += chunk.length;
+        spinner.text = `Batch: ${totalRendered}/${jobs.length} rendered`;
+      }
+    }
+    if (opts.manifest) {
+      const manifestPath = resolve6(outputDir, "manifest.json");
+      await writeFile4(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
+      console.log(JSON.stringify(manifest));
+    }
+    spinner.succeed(
+      chalk6.green(`Batch complete: ${totalRendered} render${totalRendered === 1 ? "" : "s"}`)
+    );
+  } catch (err) {
+    spinner.fail(chalk6.red(`Batch failed: ${err.message}`));
+    process.exitCode = 1;
+  } finally {
+    await closeBrowser();
+  }
+});
+function generateJobs(opts, defaultSeed) {
+  const seeds = opts.seeds ? parseSeeds(opts.seeds) : [defaultSeed];
+  const sweeps = opts.sweep.map(parseSweep);
+  if (opts.random) {
+    const n = opts.random;
+    const jobs = [];
+    for (let i = 0; i < n; i++) {
+      const seed = Math.floor(Math.random() * 1e5);
+      const params = {};
+      for (const sweep of sweeps) {
+        params[sweep.key] = sweep.min + Math.random() * (sweep.max - sweep.min);
+        params[sweep.key] = Math.round(params[sweep.key] / sweep.step) * sweep.step;
+        params[sweep.key] = Math.round(params[sweep.key] * 1e10) / 1e10;
+      }
+      jobs.push({ seed, params });
+    }
+    return jobs;
+  }
+  if (opts.matrix || sweeps.length > 0) {
+    return cartesianProduct(seeds, sweeps);
+  }
+  return seeds.map((seed) => ({ seed, params: {} }));
+}
+
+// src/commands/montage.ts
+import { Command as Command7 } from "commander";
+import { resolve as resolve7, basename as basename4 } from "path";
+import { readFile as readFile2, readdir as readdir2, writeFile as writeFile5, stat as stat2 } from "fs/promises";
+import chalk7 from "chalk";
+import ora5 from "ora";
+var montageCommand = new Command7("montage").description("Compose a grid of images into a single montage").argument("<source>", "Directory of images, or - for manifest JSON on stdin").option("--columns <n>", "Grid columns", Number).option("--rows <n>", "Grid rows", Number).option("--tile-size <WxH>", "Force tile dimensions (e.g. 200x200)").option("--gap <px>", "Gap between tiles", Number, 2).option("--padding <px>", "Outer padding", Number, 0).option("--background <hex>", "Background color", "#0A0A0A").option("--label <mode>", "Label tiles: seed, params, filename, index, none", "none").option("--label-color <hex>", "Label text color", "#999999").option("--label-font-size <px>", "Label font size", Number, 11).option("--sort <key>", "Sort: seed, name, param:<key>").option("-o, --output <path>", "Output file", "montage.png").action(async (source, opts) => {
+  const spinner = ora5("Preparing montage...").start();
+  try {
+    let sharp;
+    try {
+      sharp = (await import("sharp")).default;
+    } catch {
+      throw new Error(
+        `sharp is required for montage composition but is not installed.
+  Install it: npm install sharp
+  Or: pnpm add sharp`
+      );
+    }
+    let entries;
+    if (source === "-") {
+      const input = await readStdin();
+      const manifest = JSON.parse(input);
+      entries = manifest.map((m, i) => ({
+        path: m.path,
+        seed: m.seed,
+        params: m.params,
+        index: i
+      }));
+    } else {
+      const dir = resolve7(source);
+      const dirStat = await stat2(dir);
+      if (!dirStat.isDirectory()) {
+        throw new Error(`Not a directory: ${dir}`);
+      }
+      const files = await readdir2(dir);
+      const imageFiles = files.filter((f) => /\.(png|jpe?g|webp)$/i.test(f)).sort();
+      entries = imageFiles.map((f, i) => ({
+        path: resolve7(dir, f),
+        index: i
+      }));
+    }
+    if (entries.length === 0) {
+      throw new Error("No images found for montage.");
+    }
+    sortEntries(entries, opts.sort);
+    spinner.text = `Loading ${entries.length} image${entries.length === 1 ? "" : "s"}...`;
+    const images = await Promise.all(
+      entries.map(async (entry) => {
+        const buffer = await readFile2(entry.path);
+        const metadata = await sharp(buffer).metadata();
+        return {
+          entry,
+          buffer,
+          width: metadata.width,
+          height: metadata.height
+        };
+      })
+    );
+    let tileWidth;
+    let tileHeight;
+    if (opts.tileSize) {
+      const [w, h] = opts.tileSize.split("x").map(Number);
+      tileWidth = w;
+      tileHeight = h;
+    } else {
+      tileWidth = images[0].width;
+      tileHeight = images[0].height;
+    }
+    const count = images.length;
+    let columns;
+    let rows;
+    if (opts.columns) {
+      columns = opts.columns;
+      rows = Math.ceil(count / columns);
+    } else if (opts.rows) {
+      rows = opts.rows;
+      columns = Math.ceil(count / rows);
+    } else {
+      columns = Math.ceil(Math.sqrt(count));
+      rows = Math.ceil(count / columns);
+    }
+    const gap = opts.gap;
+    const padding = opts.padding;
+    const background = opts.background;
+    const totalWidth = padding * 2 + columns * tileWidth + (columns - 1) * gap;
+    const totalHeight = padding * 2 + rows * tileHeight + (rows - 1) * gap;
+    spinner.text = `Composing ${columns}\xD7${rows} grid (${totalWidth}\xD7${totalHeight})...`;
+    const composites = [];
+    for (let i = 0; i < images.length; i++) {
+      const col = i % columns;
+      const row = Math.floor(i / columns);
+      const left = padding + col * (tileWidth + gap);
+      const top = padding + row * (tileHeight + gap);
+      let tileBuffer;
+      if (images[i].width !== tileWidth || images[i].height !== tileHeight) {
+        tileBuffer = await sharp(images[i].buffer).resize(tileWidth, tileHeight, { fit: "cover" }).toBuffer();
+      } else {
+        tileBuffer = Buffer.from(images[i].buffer);
+      }
+      composites.push({ input: tileBuffer, left, top });
+    }
+    const montageBuffer = await sharp({
+      create: {
+        width: totalWidth,
+        height: totalHeight,
+        channels: 4,
+        background: hexToRgba(background)
+      }
+    }).composite(composites).png().toBuffer();
+    const outputPath = resolve7(opts.output);
+    await writeFile5(outputPath, montageBuffer);
+    spinner.succeed(
+      chalk7.green(
+        `Montage: ${count} tile${count === 1 ? "" : "s"} \u2192 ${columns}\xD7${rows} grid (${totalWidth}\xD7${totalHeight}) \u2192 ${outputPath}`
+      )
+    );
+  } catch (err) {
+    spinner.fail(chalk7.red(`Montage failed: ${err.message}`));
+    process.exitCode = 1;
+  }
+});
+function readStdin() {
+  return new Promise((resolve10, reject) => {
+    let data = "";
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (chunk) => data += chunk);
+    process.stdin.on("end", () => resolve10(data));
+    process.stdin.on("error", reject);
+  });
+}
+function sortEntries(entries, sortKey) {
+  if (!sortKey) return;
+  if (sortKey === "seed") {
+    entries.sort((a, b) => (a.seed ?? 0) - (b.seed ?? 0));
+  } else if (sortKey === "name") {
+    entries.sort((a, b) => basename4(a.path).localeCompare(basename4(b.path)));
+  } else if (sortKey.startsWith("param:")) {
+    const paramKey = sortKey.slice(6);
+    entries.sort((a, b) => {
+      const va = a.params?.[paramKey] ?? 0;
+      const vb = b.params?.[paramKey] ?? 0;
+      return va - vb;
+    });
+  }
+}
+function hexToRgba(hex) {
+  const h = hex.replace("#", "");
+  return {
+    r: parseInt(h.slice(0, 2), 16),
+    g: parseInt(h.slice(2, 4), 16),
+    b: parseInt(h.slice(4, 6), 16),
+    alpha: 1
+  };
+}
+
+// src/commands/import.ts
+import { Command as Command8 } from "commander";
+import { resolve as resolve8, basename as basename5, extname as extname4 } from "path";
+import { readFile as readFile3, writeFile as writeFile6 } from "fs/promises";
+import chalk8 from "chalk";
+import ora6 from "ora";
+import { createDefaultRegistry as createDefaultRegistry6 } from "@genart-dev/core";
+import {
+  serializeGenart as serializeGenart2,
+  resolvePreset as resolvePreset3
+} from "@genart-dev/format";
+
+// src/detect/renderer.ts
+function detectRenderer(source) {
+  const results = [];
+  const glslSignals = [];
+  if (/^\s*#version\s+/m.test(source)) glslSignals.push("#version directive");
+  if (/void\s+main\s*\(\s*\)/.test(source)) glslSignals.push("void main()");
+  if (/gl_Frag(Color|Coord)/i.test(source)) glslSignals.push("gl_Frag* builtins");
+  if (/\b(uniform|varying|attribute)\s+/m.test(source)) glslSignals.push("GLSL qualifiers");
+  if (/\b(vec[234]|mat[234]|sampler2D)\b/.test(source)) glslSignals.push("GLSL types");
+  if (glslSignals.length >= 2) {
+    results.push({
+      type: "glsl",
+      confidence: glslSignals.length >= 3 ? "high" : "medium",
+      signals: glslSignals,
+      score: glslSignals.length * 10
+    });
+  }
+  const p5Signals = [];
+  if (/function\s+sketch\s*\(\s*p\s*[,)]/.test(source)) p5Signals.push("sketch(p, ...) signature");
+  if (/p\.(setup|draw|createCanvas)\b/.test(source)) p5Signals.push("p5 instance methods");
+  if (/p\.(background|fill|stroke|ellipse|rect|line|vertex|bezier)\b/.test(source)) p5Signals.push("p5 drawing API");
+  if (/p\.(random|noise|map|lerp|constrain)\b/.test(source)) p5Signals.push("p5 math utilities");
+  if (/p\.(push|pop|translate|rotate|scale)\b/.test(source)) p5Signals.push("p5 transforms");
+  if (/p\.randomSeed\b/.test(source)) p5Signals.push("p5 randomSeed");
+  if (p5Signals.length >= 2) {
+    results.push({
+      type: "p5",
+      confidence: p5Signals.length >= 3 ? "high" : "medium",
+      signals: p5Signals,
+      score: p5Signals.length * 10
+    });
+  }
+  const canvas2dSignals = [];
+  if (/function\s+sketch\s*\(\s*ctx\s*[,)]/.test(source)) canvas2dSignals.push("sketch(ctx, ...) signature");
+  if (/ctx\.(fillRect|strokeRect|clearRect)\b/.test(source)) canvas2dSignals.push("Canvas2D rect methods");
+  if (/ctx\.(beginPath|moveTo|lineTo|arc|closePath)\b/.test(source)) canvas2dSignals.push("Canvas2D path API");
+  if (/ctx\.(fillStyle|strokeStyle|lineWidth|globalAlpha)\b/.test(source)) canvas2dSignals.push("Canvas2D style props");
+  if (/ctx\.(save|restore|translate|rotate|scale)\b/.test(source)) canvas2dSignals.push("Canvas2D transforms");
+  if (canvas2dSignals.length >= 2) {
+    results.push({
+      type: "canvas2d",
+      confidence: canvas2dSignals.length >= 3 ? "high" : "medium",
+      signals: canvas2dSignals,
+      score: canvas2dSignals.length * 10
+    });
+  }
+  const threeSignals = [];
+  if (/\bTHREE\b/.test(source)) threeSignals.push("THREE namespace");
+  if (/new\s+THREE\.\w+/.test(source)) threeSignals.push("THREE constructor calls");
+  if (/THREE\.(Scene|PerspectiveCamera|WebGLRenderer|Mesh|BoxGeometry|SphereGeometry)\b/.test(source)) threeSignals.push("THREE core classes");
+  if (/THREE\.(MeshBasicMaterial|MeshStandardMaterial|ShaderMaterial)\b/.test(source)) threeSignals.push("THREE materials");
+  if (/THREE\.(Vector[23]|Color|Euler)\b/.test(source)) threeSignals.push("THREE math types");
+  if (threeSignals.length >= 2) {
+    results.push({
+      type: "three",
+      confidence: threeSignals.length >= 3 ? "high" : "medium",
+      signals: threeSignals,
+      score: threeSignals.length * 10
+    });
+  }
+  const svgSignals = [];
+  if (/document\.createElementNS\s*\(\s*["']http:\/\/www\.w3\.org\/2000\/svg["']/.test(source)) svgSignals.push("SVG namespace createElement");
+  if (/\.(setAttribute|getAttribute)\s*\(\s*["'](d|viewBox|fill|stroke|transform)["']/.test(source)) svgSignals.push("SVG attribute methods");
+  if (/\b(path|circle|rect|line|polygon|polyline|ellipse|g|svg)\b/.test(source) && /createElementNS|innerHTML/.test(source)) svgSignals.push("SVG element names");
+  if (/\bM\s*[\d.-]+[\s,]+[\d.-]+.*[LQCZ]/i.test(source)) svgSignals.push("SVG path data");
+  if (svgSignals.length >= 1) {
+    results.push({
+      type: "svg",
+      confidence: svgSignals.length >= 2 ? "high" : svgSignals.length >= 1 ? "medium" : "low",
+      signals: svgSignals,
+      score: svgSignals.length * 10
+    });
+  }
+  if (results.length === 0) return null;
+  results.sort((a, b) => b.score - a.score);
+  const best = results[0];
+  return { type: best.type, confidence: best.confidence, signals: best.signals };
+}
+function detectParams(source) {
+  const keys = /* @__PURE__ */ new Set();
+  const regex = /(?:state\.PARAMS|PARAMS)\.(\w+)/g;
+  let match;
+  while ((match = regex.exec(source)) !== null) {
+    keys.add(match[1]);
+  }
+  return [...keys];
+}
+function detectColorCount(source) {
+  const indexRefs = /* @__PURE__ */ new Set();
+  const keyRefs = /* @__PURE__ */ new Set();
+  const indexRegex = /(?:state\.COLORS|COLORS)\[(\d+)\]/g;
+  let match;
+  while ((match = indexRegex.exec(source)) !== null) {
+    indexRefs.add(Number(match[1]));
+  }
+  const keyRegex = /(?:state\.COLORS|COLORS)\.(\w+)/g;
+  while ((match = keyRegex.exec(source)) !== null) {
+    keyRefs.add(match[1]);
+  }
+  return Math.max(indexRefs.size, keyRefs.size);
+}
+function detectCanvasSize(source) {
+  const match = source.match(/createCanvas\s*\(\s*(\d+)\s*,\s*(\d+)\s*\)/);
+  if (match) {
+    return { width: Number(match[1]), height: Number(match[2]) };
+  }
+  return null;
+}
+
+// src/commands/import.ts
+var RENDERER_TYPES2 = ["p5", "canvas2d", "three", "glsl", "svg"];
+function slugify2(title) {
+  return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+var importCommand = new Command8("import").description("Convert a source file (.js, .glsl) into a .genart sketch").argument("<files...>", "Source file(s) to import").option("--renderer <type>", "Force renderer type (skip auto-detection)").option("--preset <name>", "Canvas preset", "square-600").option("--title <string>", "Sketch title (skip prompt)").option("--seed <n>", "Initial seed", Number).option("-y, --non-interactive", "Accept all defaults, skip prompts").option("--batch", "Process multiple files non-interactively").option("--dry-run", "Show what would be generated without writing").option("-o, --output <path>", "Output path (single file only)").action(async (files, opts) => {
+  const nonInteractive = !!(opts.nonInteractive || opts.batch);
+  try {
+    for (const file of files) {
+      await importFile(file, opts, nonInteractive);
+    }
+  } catch (err) {
+    console.error(chalk8.red(`Import failed: ${err.message}`));
+    process.exitCode = 1;
+  }
+});
+async function importFile(file, opts, nonInteractive) {
+  const spinner = ora6(`Importing ${basename5(file)}...`).start();
+  const filePath = resolve8(file);
+  const source = await readFile3(filePath, "utf-8");
+  const ext = extname4(filePath).toLowerCase();
+  let rendererType;
+  if (opts.renderer) {
+    rendererType = opts.renderer;
+    if (!RENDERER_TYPES2.includes(rendererType)) {
+      spinner.fail(chalk8.red(`Invalid renderer: ${rendererType}`));
+      throw new Error(`Invalid renderer "${rendererType}". Choose from: ${RENDERER_TYPES2.join(", ")}`);
+    }
+    spinner.text = `Renderer: ${rendererType} (specified)`;
+  } else {
+    const detection = detectRenderer(source);
+    if (detection) {
+      spinner.text = `Detected renderer: ${detection.type} (${detection.confidence})`;
+      if (detection.confidence === "low" && !nonInteractive) {
+        spinner.stop();
+        const { default: inquirer } = await import("inquirer");
+        const answers = await inquirer.prompt([
+          {
+            type: "list",
+            name: "renderer",
+            message: `Low-confidence detection: ${detection.type}. Confirm or choose:`,
+            choices: RENDERER_TYPES2.map((t) => ({ name: t, value: t })),
+            default: detection.type
+          }
+        ]);
+        rendererType = answers.renderer;
+        spinner.start();
+      } else {
+        rendererType = detection.type;
+      }
+    } else {
+      if (ext === ".glsl" || ext === ".frag" || ext === ".vert") {
+        rendererType = "glsl";
+      } else if (nonInteractive) {
+        rendererType = "p5";
+      } else {
+        spinner.stop();
+        const { default: inquirer } = await import("inquirer");
+        const answers = await inquirer.prompt([
+          {
+            type: "list",
+            name: "renderer",
+            message: "Could not detect renderer type. Please choose:",
+            choices: RENDERER_TYPES2.map((t) => ({ name: t, value: t }))
+          }
+        ]);
+        rendererType = answers.renderer;
+        spinner.start();
+      }
+    }
+  }
+  spinner.text = "Validating algorithm...";
+  const registry = createDefaultRegistry6();
+  const adapter = registry.resolve(rendererType);
+  const validation = adapter.validate(source);
+  if (!validation.valid) {
+    spinner.warn(chalk8.yellow(`Validation warnings for ${rendererType}:`));
+    for (const error of validation.errors) {
+      console.error(chalk8.yellow(`  - ${error}`));
+    }
+  }
+  const detectedParams = detectParams(source);
+  const detectedColorCount = detectColorCount(source);
+  const detectedSize = detectCanvasSize(source);
+  let title;
+  if (opts.title) {
+    title = opts.title;
+  } else if (nonInteractive) {
+    title = basename5(filePath, extname4(filePath)).replace(/[-_]+/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+  } else {
+    spinner.stop();
+    const { default: inquirer } = await import("inquirer");
+    const answers = await inquirer.prompt([
+      {
+        type: "input",
+        name: "title",
+        message: "Sketch title:",
+        default: basename5(filePath, extname4(filePath)).replace(/[-_]+/g, " ").replace(/\b\w/g, (c) => c.toUpperCase())
+      }
+    ]);
+    title = answers.title;
+    spinner.start();
+  }
+  const preset = opts.preset;
+  let canvasWidth;
+  let canvasHeight;
+  if (detectedSize && !opts.preset) {
+    canvasWidth = detectedSize.width;
+    canvasHeight = detectedSize.height;
+  } else {
+    const dims = resolvePreset3(preset);
+    canvasWidth = dims.width;
+    canvasHeight = dims.height;
+  }
+  const parameters = detectedParams.map((key) => ({
+    key,
+    label: key.charAt(0).toUpperCase() + key.slice(1),
+    min: 0,
+    max: 1,
+    step: 0.01,
+    default: 0.5
+  }));
+  const colors = [];
+  const defaultColors = ["#FF6B35", "#004E89", "#F7C59F", "#1A936F", "#C6DABF"];
+  for (let i = 0; i < detectedColorCount; i++) {
+    colors.push({
+      key: `color${i}`,
+      label: `Color ${i + 1}`,
+      default: defaultColors[i % defaultColors.length]
+    });
+  }
+  const seed = opts.seed ?? Math.floor(Math.random() * 1e4);
+  const id = slugify2(title);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const sketch = {
+    genart: "1.0",
+    id,
+    title,
+    created: now,
+    modified: now,
+    renderer: { type: rendererType },
+    canvas: {
+      preset: detectedSize ? void 0 : preset,
+      width: canvasWidth,
+      height: canvasHeight
+    },
+    parameters,
+    colors,
+    state: {
+      seed,
+      params: Object.fromEntries(parameters.map((p) => [p.key, p.default])),
+      colorPalette: colors.map((c) => c.default)
+    },
+    algorithm: source
+  };
+  if (opts.dryRun) {
+    spinner.stop();
+    console.log(chalk8.dim("--- Dry run (would write): ---"));
+    console.log(serializeGenart2(sketch));
+    return;
+  }
+  const outputPath = opts.output ? resolve8(opts.output) : resolve8(`${id}.genart`);
+  const json = serializeGenart2(sketch);
+  await writeFile6(outputPath, json, "utf-8");
+  spinner.succeed(chalk8.green(`\u2713 Imported \u2192 ${outputPath}`));
+  console.log(chalk8.dim(`  Renderer:   ${rendererType}`));
+  console.log(chalk8.dim(`  Canvas:     ${canvasWidth}\xD7${canvasHeight}`));
+  if (detectedParams.length > 0) {
+    console.log(chalk8.dim(`  Parameters: ${detectedParams.join(", ")}`));
+  }
+  if (detectedColorCount > 0) {
+    console.log(chalk8.dim(`  Colors:     ${detectedColorCount} slot${detectedColorCount > 1 ? "s" : ""}`));
+  }
+}
+
+// src/commands/video.ts
+import { Command as Command9 } from "commander";
+import { resolve as resolve9, basename as basename6, extname as extname5 } from "path";
+import { stat as stat3 } from "fs/promises";
+import chalk9 from "chalk";
+import ora7 from "ora";
+import { createDefaultRegistry as createDefaultRegistry7 } from "@genart-dev/core";
+
+// src/video/interpolate.ts
+var EASINGS = {
+  linear: (t) => t,
+  "ease-in": (t) => t * t,
+  "ease-out": (t) => t * (2 - t),
+  "ease-in-out": (t) => t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t
+};
+function parseAnimate(value) {
+  const eqIdx = value.indexOf("=");
+  if (eqIdx < 1) {
+    throw new Error(
+      `Invalid --animate format: "${value}". Expected "param=start:end"`
+    );
+  }
+  const key = value.slice(0, eqIdx);
+  const range = value.slice(eqIdx + 1);
+  const parts = range.split(":");
+  if (parts.length !== 2) {
+    throw new Error(
+      `Invalid --animate range: "${value}". Expected "param=start:end"`
+    );
+  }
+  const start = Number(parts[0]);
+  const end = Number(parts[1]);
+  if (Number.isNaN(start) || Number.isNaN(end)) {
+    throw new Error(
+      `Invalid --animate values: "${value}". Start and end must be numbers`
+    );
+  }
+  return { key, start, end };
+}
+function interpolateParams(specs, t, easing) {
+  const easedT = easing(Math.max(0, Math.min(1, t)));
+  const result = {};
+  for (const spec of specs) {
+    result[spec.key] = spec.start + (spec.end - spec.start) * easedT;
+  }
+  return result;
+}
+function collectAnimates(value, prev) {
+  return [...prev, value];
+}
+
+// src/video/ffmpeg.ts
+import { execSync, spawn } from "child_process";
+function findFfmpeg() {
+  const envPath = process.env["GENART_FFMPEG_PATH"];
+  if (envPath) return envPath;
+  try {
+    return execSync("which ffmpeg", { encoding: "utf-8" }).trim();
+  } catch {
+    throw new Error(
+      "ffmpeg not found. Install ffmpeg or set GENART_FFMPEG_PATH.\n  macOS: brew install ffmpeg\n  Linux: sudo apt install ffmpeg\n  Or: GENART_FFMPEG_PATH=/path/to/ffmpeg genart video ..."
+    );
+  }
+}
+function qualityToCrf(quality, codec) {
+  const maxCrf = codec === "libvpx-vp9" ? 63 : 51;
+  return Math.round((100 - quality) * maxCrf / 100);
+}
+function resolveCodec(codec) {
+  const map = {
+    h264: "libx264",
+    h265: "libx265",
+    vp9: "libvpx-vp9"
+  };
+  return map[codec] ?? codec;
+}
+function buildFfmpegArgs(opts) {
+  const args = [
+    // Input: piped PNG frames
+    "-f",
+    "image2pipe",
+    "-framerate",
+    String(opts.fps),
+    "-i",
+    "pipe:0",
+    // Overwrite output
+    "-y"
+  ];
+  if (opts.format === "gif") {
+    args.push("-vf", `fps=${opts.fps}`);
+    if (opts.loop !== void 0) {
+      args.push("-loop", String(opts.loop));
+    }
+  } else {
+    const ffCodec = resolveCodec(opts.codec);
+    const crf = qualityToCrf(opts.quality, ffCodec);
+    args.push("-c:v", ffCodec, "-crf", String(crf));
+    if (ffCodec === "libx264" || ffCodec === "libx265") {
+      args.push("-pix_fmt", "yuv420p");
+    }
+    if (ffCodec === "libx264") {
+      args.push("-movflags", "+faststart");
+    }
+  }
+  args.push(opts.output);
+  return args;
+}
+function spawnFfmpeg(ffmpegPath, args) {
+  return spawn(ffmpegPath, args, {
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+}
+
+// src/video/time-inject.ts
+function buildTimeOffsetScript(offsetMs) {
+  return `
+    (() => {
+      const __OFFSET = ${offsetMs};
+      const __origPerfNow = performance.now.bind(performance);
+      const __origDateNow = Date.now.bind(Date);
+      const __origRAF = window.requestAnimationFrame.bind(window);
+      performance.now = () => __origPerfNow() + __OFFSET;
+      Date.now = () => __origDateNow() + __OFFSET;
+      window.requestAnimationFrame = (cb) => __origRAF((ts) => cb(ts + __OFFSET));
+    })();
+  `;
+}
+async function injectTimeOffset(page, offsetMs) {
+  await page.evaluate(buildTimeOffsetScript(offsetMs));
+}
+
+// src/commands/video.ts
+var videoCommand = new Command9("video").description("Render a video from an animated sketch").argument("<file>", "Path to .genart file").requiredOption("--duration <seconds>", "Video duration in seconds", Number).option("--fps <n>", "Frames per second", Number, 30).option("--format <fmt>", "Output format: mp4, webm, gif", "mp4").option("--codec <name>", "Video codec: h264, h265, vp9", "h264").option("--quality <n>", "Encoding quality (0-100)", Number, 75).option(
+  "--animate <spec>",
+  "Interpolate parameter: param=start:end (repeatable)",
+  collectAnimates,
+  []
+).option("--easing <fn>", "Easing function: linear, ease-in, ease-out, ease-in-out", "linear").option("--loop <n>", "GIF loop count (0=infinite)", Number, 0).option("--concurrency <n>", "Parallel frame captures", Number, 4).option("--wait <duration>", "Init wait before time injection", "200ms").option("--seed <n>", "Override seed", Number).option("--params <json>", "Override parameters (JSON object)").option("--colors <json>", "Override color palette (JSON array)").option("--width <n>", "Override canvas width", Number).option("--height <n>", "Override canvas height", Number).option("--preset <name>", "Use a canvas preset").option("-o, --output <path>", "Output file path").action(async (file, opts) => {
+  const spinner = ora7("Loading sketch...").start();
+  try {
+    const filePath = resolve9(file);
+    const sketch = await loadSketch(filePath);
+    if (sketch.renderer.type === "svg") {
+      throw new Error(
+        "SVG sketches are static and cannot be animated. The video command requires an animated renderer (p5, canvas2d, three, glsl)."
+      );
+    }
+    const overrides = {};
+    if (opts.seed !== void 0) overrides.seed = opts.seed;
+    if (opts.width !== void 0) overrides.width = opts.width;
+    if (opts.height !== void 0) overrides.height = opts.height;
+    if (opts.preset) overrides.preset = opts.preset;
+    if (opts.params) {
+      overrides.params = JSON.parse(opts.params);
+    }
+    if (opts.colors) {
+      overrides.colors = JSON.parse(opts.colors);
+    }
+    const modified = applyOverrides(sketch, overrides);
+    const registry = createDefaultRegistry7();
+    const adapter = registry.resolve(modified.renderer.type);
+    spinner.text = "Detecting ffmpeg...";
+    const ffmpegPath = findFfmpeg();
+    const animateSpecs = opts.animate.map(parseAnimate);
+    const easingName = opts.easing;
+    const easing = EASINGS[easingName];
+    if (!easing) {
+      throw new Error(
+        `Unknown easing function: "${easingName}". Available: ${Object.keys(EASINGS).join(", ")}`
+      );
+    }
+    const duration = opts.duration;
+    const fps = opts.fps;
+    const totalFrames = Math.ceil(duration * fps);
+    const concurrency = opts.concurrency;
+    const initWaitMs = parseWait(opts.wait);
+    const format = opts.format;
+    const outputPath = resolve9(
+      opts.output ?? `${basename6(filePath, extname5(filePath))}.${format}`
+    );
+    spinner.text = `Video: starting ffmpeg (${totalFrames} frames, ${fps}fps)...`;
+    const ffmpegArgs = buildFfmpegArgs({
+      output: outputPath,
+      width: modified.canvas.width,
+      height: modified.canvas.height,
+      fps,
+      format,
+      codec: opts.codec,
+      quality: opts.quality,
+      loop: opts.loop
+    });
+    const ffmpegProc = spawnFfmpeg(ffmpegPath, ffmpegArgs);
+    let ffmpegStderr = "";
+    ffmpegProc.stderr?.on("data", (chunk) => {
+      ffmpegStderr += chunk.toString();
+    });
+    const hasAnimatedParams = animateSpecs.length > 0;
+    let framesRendered = 0;
+    for (let i = 0; i < totalFrames; i += concurrency) {
+      const chunkSize = Math.min(concurrency, totalFrames - i);
+      const frameIndices = Array.from({ length: chunkSize }, (_, j) => i + j);
+      const frames = await Promise.all(
+        frameIndices.map(async (frameIdx) => {
+          const t = totalFrames <= 1 ? 0 : frameIdx / (totalFrames - 1);
+          const timeOffsetMs = frameIdx / fps * 1e3;
+          let frameSketch = modified;
+          if (hasAnimatedParams) {
+            const animatedParams = interpolateParams(animateSpecs, t, easing);
+            frameSketch = applyOverrides(modified, { params: animatedParams });
+          }
+          const html = adapter.generateStandaloneHTML(frameSketch);
+          const page = await getPage(
+            frameSketch.canvas.width,
+            frameSketch.canvas.height
+          );
+          try {
+            await page.setContent(html, {
+              waitUntil: "domcontentloaded",
+              timeout: 3e4
+            });
+            if (initWaitMs > 0) {
+              await new Promise((resolve10) => setTimeout(resolve10, initWaitMs));
+            }
+            if (timeOffsetMs > 0) {
+              await injectTimeOffset(page, timeOffsetMs);
+              await page.evaluate(
+                () => new Promise(
+                  (resolve10) => requestAnimationFrame(() => resolve10())
+                )
+              );
+            }
+            const buffer = await page.screenshot({
+              type: "png",
+              clip: {
+                x: 0,
+                y: 0,
+                width: frameSketch.canvas.width,
+                height: frameSketch.canvas.height
+              }
+            });
+            return new Uint8Array(buffer);
+          } finally {
+            await page.close();
+          }
+        })
+      );
+      for (const frame of frames) {
+        const canWrite = ffmpegProc.stdin.write(frame);
+        if (!canWrite) {
+          await new Promise(
+            (resolve10) => ffmpegProc.stdin.once("drain", resolve10)
+          );
+        }
+      }
+      framesRendered += chunkSize;
+      const pct = Math.round(framesRendered / totalFrames * 100);
+      spinner.text = `Video: ${framesRendered}/${totalFrames} frames (${pct}%)`;
+    }
+    ffmpegProc.stdin.end();
+    const exitCode = await new Promise((resolve10, reject) => {
+      ffmpegProc.on("close", (code) => resolve10(code ?? 0));
+      ffmpegProc.on("error", reject);
+    });
+    if (exitCode !== 0) {
+      throw new Error(
+        `ffmpeg exited with code ${exitCode}:
+${ffmpegStderr.slice(-500)}`
+      );
+    }
+    const fileSize = (await stat3(outputPath)).size;
+    const sizeMB = (fileSize / (1024 * 1024)).toFixed(1);
+    spinner.succeed(
+      chalk9.green(
+        `Video: ${modified.canvas.width}\xD7${modified.canvas.height}, ${totalFrames} frames, ${duration}s \u2192 ${outputPath} (${sizeMB} MB)`
+      )
+    );
+  } catch (err) {
+    spinner.fail(chalk9.red(`Video failed: ${err.message}`));
+    process.exitCode = 1;
+  } finally {
+    await closeBrowser();
+  }
+});
+
+// src/commands/agent/index.ts
+import { Command as Command15 } from "commander";
+
+// src/commands/agent/stdio.ts
+import { Command as Command10 } from "commander";
+var stdioCommand = new Command10("stdio").description("Start MCP server over stdio transport").option("--base-path <dir>", "Base directory for file operations", process.cwd()).action(async (opts) => {
+  const { EditorState, createServer } = await import("@genart-dev/mcp-server/lib");
+  const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js");
+  const state = new EditorState();
+  if (opts.basePath) {
+    state.basePath = opts.basePath;
+  }
+  const server = createServer(state);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("[genart] MCP server connected (stdio)");
+});
+
+// src/commands/agent/http.ts
+import { Command as Command11 } from "commander";
+import {
+  createServer as createHttpServer
+} from "http";
+import chalk10 from "chalk";
+var httpCommand = new Command11("http").description("Start MCP server over HTTP (StreamableHTTP transport)").option("--port <n>", "Port to listen on", Number, 3333).option("--host <addr>", "Host to bind to", "127.0.0.1").option("--base-path <dir>", "Base directory for file operations", process.cwd()).option("--cors", "Enable CORS headers for browser access").action(async (opts) => {
+  const { EditorState, createServer } = await import("@genart-dev/mcp-server/lib");
+  const { StreamableHTTPServerTransport } = await import("@modelcontextprotocol/sdk/server/streamableHttp.js");
+  const port = opts.port;
+  const host = opts.host;
+  const enableCors = opts.cors;
+  const state = new EditorState();
+  if (opts.basePath) {
+    state.basePath = opts.basePath;
+  }
+  const mcpServer = createServer(state);
+  const transport = new StreamableHTTPServerTransport({
+    sessionIdGenerator: () => "local"
+  });
+  await mcpServer.connect(transport);
+  const httpServer = createHttpServer(
+    async (req, res) => {
+      if (enableCors) {
+        res.setHeader("Access-Control-Allow-Origin", "*");
+        res.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
+        res.setHeader(
+          "Access-Control-Allow-Headers",
+          "Content-Type, Mcp-Session-Id"
+        );
+        res.setHeader("Access-Control-Expose-Headers", "Mcp-Session-Id");
+      }
+      if (req.method === "OPTIONS") {
+        res.writeHead(enableCors ? 204 : 405);
+        res.end();
+        return;
+      }
+      if (req.url === "/health") {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ status: "ok" }));
+        return;
+      }
+      if (req.url === "/mcp") {
+        const chunks = [];
+        req.on("data", (chunk) => chunks.push(chunk));
+        req.on("end", async () => {
+          const raw = Buffer.concat(chunks).toString();
+          const body = raw ? JSON.parse(raw) : void 0;
+          try {
+            await transport.handleRequest(req, res, body);
+          } catch (err) {
+            console.error("[genart] handleRequest error:", err);
+            if (!res.writableEnded) {
+              res.writeHead(500);
+              res.end(JSON.stringify({ error: "Internal server error" }));
+            }
+          }
+        });
+        return;
+      }
+      res.writeHead(404);
+      res.end();
+    }
+  );
+  httpServer.on("error", (err) => {
+    if (err.code === "EADDRINUSE") {
+      console.error(
+        chalk10.red(`Port ${port} is already in use.`) + "\n" + chalk10.dim(`Try: genart agent http --port ${port + 1}`)
+      );
+      process.exitCode = 1;
+    } else {
+      console.error(chalk10.red(`Server error: ${err.message}`));
+      process.exitCode = 1;
+    }
+  });
+  httpServer.listen(port, host, () => {
+    console.log(
+      chalk10.green(`MCP server listening on http://${host}:${port}/mcp`)
+    );
+    if (enableCors) {
+      console.log(chalk10.dim("CORS enabled"));
+    }
+  });
+  const shutdown = async () => {
+    console.log(chalk10.dim("\nShutting down..."));
+    httpServer.close();
+    try {
+      await mcpServer.close();
+    } catch {
+    }
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+});
+
+// src/commands/agent/sidecar.ts
+import { Command as Command12 } from "commander";
+var sidecarCommand = new Command12("sidecar").description("Start MCP server in sidecar mode (stdio + IPC mutations)").option("--base-path <dir>", "Base directory for file operations", process.cwd()).action(async (opts) => {
+  process.env["GENART_SIDECAR"] = "1";
+  const { EditorState, createServer } = await import("@genart-dev/mcp-server/lib");
+  const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js");
+  const state = new EditorState();
+  if (opts.basePath) {
+    state.basePath = opts.basePath;
+  }
+  const server = createServer(state);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("[genart] MCP server connected (sidecar)");
+});
+
+// src/commands/agent/install.ts
+import { Command as Command13 } from "commander";
+import chalk11 from "chalk";
+
+// src/commands/agent/clients.ts
+import { readFile as readFile4, writeFile as writeFile7, mkdir as mkdir2 } from "fs/promises";
+import { execSync as execSync2 } from "child_process";
+import { homedir } from "os";
+import { dirname, join } from "path";
+import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
+var CLIENTS = [
+  {
+    id: "claude",
+    name: "Claude Code",
+    configRelPath: ".claude.json",
+    format: "json",
+    serversKey: "mcpServers",
+    binaryName: "claude"
+  },
+  {
+    id: "codex",
+    name: "Codex CLI",
+    configRelPath: ".codex/config.toml",
+    format: "toml",
+    serversKey: "mcp_servers",
+    binaryName: "codex"
+  },
+  {
+    id: "cursor",
+    name: "Cursor",
+    configRelPath: ".cursor/mcp.json",
+    format: "json",
+    serversKey: "mcpServers",
+    binaryName: "cursor"
+  },
+  {
+    id: "vscode",
+    name: "VS Code",
+    configRelPath: process.platform === "darwin" ? "Library/Application Support/Code/User/settings.json" : process.platform === "win32" ? "AppData/Roaming/Code/User/settings.json" : ".config/Code/User/settings.json",
+    format: "json",
+    serversKey: "mcp.servers",
+    binaryName: "code"
+  },
+  {
+    id: "gemini",
+    name: "Gemini CLI",
+    configRelPath: ".gemini/settings.json",
+    format: "json",
+    serversKey: "mcpServers",
+    binaryName: "gemini"
+  },
+  {
+    id: "opencode",
+    name: "OpenCode",
+    configRelPath: ".config/opencode/opencode.json",
+    format: "json",
+    serversKey: "mcp",
+    binaryName: "opencode"
+  },
+  {
+    id: "kiro",
+    name: "Kiro",
+    configRelPath: ".kiro/settings/mcp.json",
+    format: "json",
+    serversKey: "mcpServers",
+    binaryName: "kiro"
+  },
+  {
+    id: "windsurf",
+    name: "Windsurf",
+    configRelPath: ".codeium/windsurf/mcp_config.json",
+    format: "json",
+    serversKey: "mcpServers",
+    binaryName: "windsurf"
+  }
+];
+function findClient(id) {
+  return CLIENTS.find((c) => c.id === id);
+}
+function getConfigPath(client) {
+  return join(homedir(), client.configRelPath);
+}
+function isInPath(binary) {
+  try {
+    const cmd = process.platform === "win32" ? `where.exe ${binary}` : `which ${binary}`;
+    execSync2(cmd, { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function detectGenartBin() {
+  if (isInPath("genart")) {
+    return { command: "genart", args: ["agent", "stdio"] };
+  }
+  return { command: "npx", args: ["-y", "@genart-dev/cli", "agent", "stdio"] };
+}
+function getNestedValue(obj, dotPath) {
+  const parts = dotPath.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === void 0 || typeof current !== "object") {
+      return void 0;
+    }
+    current = current[part];
+  }
+  return current;
+}
+function setNestedValue(obj, dotPath, value) {
+  const parts = dotPath.split(".");
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (!current[part] || typeof current[part] !== "object") {
+      current[part] = {};
+    }
+    current = current[part];
+  }
+  current[parts[parts.length - 1]] = value;
+}
+function deleteNestedValue(obj, dotPath, childKey) {
+  const servers = getNestedValue(obj, dotPath);
+  if (!servers || typeof servers !== "object") return;
+  delete servers[childKey];
+  if (Object.keys(servers).length === 0) {
+    const parts = dotPath.split(".");
+    if (parts.length === 1) {
+      delete obj[parts[0]];
+    } else {
+      const parentPath = parts.slice(0, -1).join(".");
+      const lastKey = parts[parts.length - 1];
+      const parent = getNestedValue(obj, parentPath);
+      if (parent) {
+        delete parent[lastKey];
+      }
+    }
+  }
+}
+async function readJsonConfig(path) {
+  try {
+    const raw = await readFile4(path, "utf-8");
+    return JSON.parse(raw);
+  } catch (err) {
+    if (err.code === "ENOENT") return {};
+    throw err;
+  }
+}
+async function writeJsonConfig(path, data) {
+  await mkdir2(dirname(path), { recursive: true });
+  await writeFile7(path, JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+async function readTomlConfig(path) {
+  try {
+    const raw = await readFile4(path, "utf-8");
+    return parseToml(raw);
+  } catch (err) {
+    if (err.code === "ENOENT") return {};
+    throw err;
+  }
+}
+async function writeTomlConfig(path, data) {
+  await mkdir2(dirname(path), { recursive: true });
+  await writeFile7(path, stringifyToml(data) + "\n", "utf-8");
+}
+async function readClientConfig(client) {
+  const path = getConfigPath(client);
+  return client.format === "toml" ? readTomlConfig(path) : readJsonConfig(path);
+}
+async function writeClientConfig(client, data) {
+  const path = getConfigPath(client);
+  return client.format === "toml" ? writeTomlConfig(path, data) : writeJsonConfig(path, data);
+}
+async function isConfigured(client) {
+  const config = await readClientConfig(client);
+  const servers = getNestedValue(config, client.serversKey);
+  if (!servers || typeof servers !== "object") return false;
+  return "genart" in servers;
+}
+
+// src/commands/agent/install.ts
+var installCommand = new Command13("install").description("Configure MCP for an AI client").argument("[client]", "Client to configure (claude, codex, cursor, vscode, gemini, opencode, kiro, windsurf)").option("--all", "Configure all detected clients").option("--remove", "Remove genart configuration").option("--dry-run", "Preview changes without writing").option("--npx", "Force npx invocation instead of global binary").action(async (clientArg, opts) => {
+  const isRemove = opts.remove;
+  const isDryRun = opts.dryRun;
+  const forceNpx = opts.npx;
+  const installAll = opts.all;
+  let targets;
+  if (installAll) {
+    targets = CLIENTS.filter((c) => isInPath(c.binaryName));
+    if (targets.length === 0) {
+      console.log(chalk11.yellow("No supported AI clients detected in PATH."));
+      console.log(
+        chalk11.dim(
+          "Supported: " + CLIENTS.map((c) => c.id).join(", ")
+        )
+      );
+      return;
+    }
+  } else if (clientArg) {
+    const client = findClient(clientArg);
+    if (!client) {
+      console.error(
+        chalk11.red(`Unknown client: ${clientArg}`) + "\n" + chalk11.dim(
+          "Available: " + CLIENTS.map((c) => c.id).join(", ")
+        )
+      );
+      process.exitCode = 1;
+      return;
+    }
+    targets = [client];
+  } else {
+    console.error(
+      chalk11.red("Specify a client or use --all") + "\n" + chalk11.dim("Usage: genart agent install <client>") + "\n" + chalk11.dim("       genart agent install --all") + "\n\n" + chalk11.dim("Available: " + CLIENTS.map((c) => c.id).join(", "))
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const bin = forceNpx ? { command: "npx", args: ["-y", "@genart-dev/cli", "agent", "stdio"] } : detectGenartBin();
+  const entry = { command: bin.command, args: bin.args };
+  for (const client of targets) {
+    const configPath = getConfigPath(client);
+    try {
+      if (isRemove) {
+        await removeClient(client, configPath, isDryRun);
+      } else {
+        await installClient(client, configPath, entry, isDryRun);
+      }
+    } catch (err) {
+      const code = err.code;
+      if (code === "EACCES") {
+        console.error(
+          chalk11.red(`Permission denied: ${configPath}`) + "\n" + chalk11.dim("Check file permissions and try again.")
+        );
+      } else {
+        console.error(
+          chalk11.red(`Failed to configure ${client.name}: ${err.message}`)
+        );
+      }
+      process.exitCode = 1;
+    }
+  }
+});
+async function installClient(client, configPath, entry, isDryRun) {
+  const config = await readClientConfig(client);
+  let servers = getNestedValue(config, client.serversKey);
+  if (!servers || typeof servers !== "object") {
+    servers = {};
+    setNestedValue(config, client.serversKey, servers);
+  }
+  servers["genart"] = entry;
+  if (isDryRun) {
+    console.log(chalk11.dim(`[dry-run] ${client.name} (${configPath}):`));
+    if (client.format === "toml") {
+      const { stringify } = await import("smol-toml");
+      console.log(chalk11.dim(stringify(config)));
+    } else {
+      console.log(chalk11.dim(JSON.stringify(config, null, 2)));
+    }
+    return;
+  }
+  await writeClientConfig(client, config);
+  console.log(
+    chalk11.green(`Configured ${client.name}`) + chalk11.dim(` (${configPath})`)
+  );
+}
+async function removeClient(client, configPath, isDryRun) {
+  const config = await readClientConfig(client);
+  const servers = getNestedValue(config, client.serversKey);
+  if (!servers || !("genart" in servers)) {
+    console.log(chalk11.dim(`${client.name}: not configured, nothing to remove`));
+    return;
+  }
+  deleteNestedValue(config, client.serversKey, "genart");
+  if (isDryRun) {
+    console.log(chalk11.dim(`[dry-run] Would remove genart from ${client.name} (${configPath})`));
+    return;
+  }
+  await writeClientConfig(client, config);
+  console.log(
+    chalk11.green(`Removed genart from ${client.name}`) + chalk11.dim(` (${configPath})`)
+  );
+}
+
+// src/commands/agent/doctor.ts
+import { Command as Command14 } from "commander";
+import { readFileSync } from "fs";
+import { join as join2 } from "path";
+import chalk12 from "chalk";
+var doctorCommand = new Command14("doctor").description("Diagnose genart MCP setup").action(async () => {
+  console.log("\n  Checking genart MCP setup...\n");
+  let warnings = 0;
+  const pkgPath = join2(import.meta.dirname, "../../../package.json");
+  let version = "unknown";
+  try {
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    version = pkg.version;
+  } catch {
+    version = "0.1.0";
+  }
+  printCheck(true, `@genart-dev/cli installed (v${version})`);
+  let mcpVersion = "";
+  try {
+    const mcpPkgPath = __require.resolve("@genart-dev/mcp-server/package.json", {
+      paths: [process.cwd(), import.meta.dirname]
+    });
+    const mcpPkg = JSON.parse(readFileSync(mcpPkgPath, "utf-8"));
+    mcpVersion = mcpPkg.version;
+    printCheck(true, `@genart-dev/mcp-server resolved (v${mcpVersion})`);
+  } catch {
+    try {
+      await import("@genart-dev/mcp-server/lib");
+      printCheck(true, "@genart-dev/mcp-server resolved");
+    } catch {
+      printCheck(false, "@genart-dev/mcp-server not found");
+      warnings++;
+    }
+  }
+  const chromePath = findChromePath();
+  if (chromePath) {
+    printCheck(true, `Chrome available (${chromePath})`);
+  } else {
+    printWarning("Chrome not found (render/capture commands unavailable)");
+    warnings++;
+  }
+  if (isInPath("ffmpeg")) {
+    printCheck(true, "ffmpeg available");
+  } else {
+    printWarning("ffmpeg not installed (video command unavailable)");
+    warnings++;
+  }
+  try {
+    await import("sharp");
+    printCheck(true, "sharp available");
+  } catch {
+    printWarning("sharp not installed (montage command unavailable)");
+    warnings++;
+  }
+  console.log("\n  Client configurations:\n");
+  for (const client of CLIENTS) {
+    const installed = isInPath(client.binaryName);
+    const configured = await isConfigured(client).catch(() => false);
+    if (configured) {
+      printCheck(true, `${client.name} \u2014 configured`);
+    } else if (installed) {
+      printWarning(
+        `${client.name} \u2014 installed but not configured (run: genart agent install ${client.id})`
+      );
+      warnings++;
+    } else {
+      printNotInstalled(`${client.name} \u2014 not installed`);
+    }
+  }
+  console.log("");
+  process.exitCode = warnings > 0 ? 1 : 0;
+});
+function printCheck(pass, message) {
+  const icon = pass ? chalk12.green("\u2713") : chalk12.red("\u2717");
+  console.log(`  ${icon} ${message}`);
+}
+function printWarning(message) {
+  console.log(`  ${chalk12.yellow("!")} ${message}`);
+}
+function printNotInstalled(message) {
+  console.log(`  ${chalk12.dim("\u25CB")} ${chalk12.dim(message)}`);
+}
+
+// src/commands/agent/index.ts
+var agentCommand = new Command15("agent").description("MCP server and agent configuration");
+agentCommand.addCommand(stdioCommand);
+agentCommand.addCommand(httpCommand);
+agentCommand.addCommand(sidecarCommand);
+agentCommand.addCommand(installCommand);
+agentCommand.addCommand(doctorCommand);
+
+// src/index.ts
+var program = new Command16();
+program.name("genart").description("CLI for genart.dev \u2014 render, batch, montage, import, validate, export, and scaffold generative art sketches").version("0.1.0");
+program.addCommand(renderCommand);
+program.addCommand(infoCommand);
+program.addCommand(validateCommand);
+program.addCommand(initCommand);
+program.addCommand(exportCommand);
+program.addCommand(batchCommand);
+program.addCommand(montageCommand);
+program.addCommand(importCommand);
+program.addCommand(videoCommand);
+program.addCommand(agentCommand);
+program.parse();
+//# sourceMappingURL=index.js.map