@emailens/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,736 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { defineCommand as defineCommand5, runMain } from "citty";
+
+// src/commands/analyze.ts
+import { defineCommand } from "citty";
+import ora from "ora";
+import {
+  analyzeEmail,
+  generateCompatibilityScore
+} from "@emailens/engine";
+
+// src/utils.ts
+import { readFileSync } from "fs";
+import { EMAIL_CLIENTS } from "@emailens/engine";
+
+// src/compile/detect.ts
+import { extname } from "path";
+function detectFormat(filePath) {
+  const ext = extname(filePath).toLowerCase();
+  switch (ext) {
+    case ".tsx":
+    case ".jsx":
+      return "jsx";
+    case ".mjml":
+      return "mjml";
+    case ".html":
+    case ".htm":
+      return "html";
+    default:
+      return "html";
+  }
+}
+
+// src/utils.ts
+var VALID_FORMATS = /* @__PURE__ */ new Set(["html", "jsx", "mjml", "maizzle"]);
+async function readInput(pathOrStdin) {
+  if (pathOrStdin === "-") {
+    try {
+      return readFileSync("/dev/stdin", "utf-8");
+    } catch {
+    }
+    return new Promise((resolve2, reject) => {
+      const chunks = [];
+      process.stdin.resume();
+      process.stdin.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
+      process.stdin.on("end", () => {
+        const data = Buffer.concat(chunks).toString("utf-8");
+        if (!data.trim()) {
+          reject(new Error("No input received from stdin. Pipe HTML or provide a file path."));
+        } else {
+          resolve2(data);
+        }
+      });
+      process.stdin.on("error", () => {
+        reject(new Error("No input received from stdin. Pipe HTML or provide a file path."));
+      });
+    });
+  }
+  try {
+    return readFileSync(pathOrStdin, "utf-8");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to read file "${pathOrStdin}": ${message}`);
+  }
+}
+function resolveClients(ids) {
+  const validIds = new Set(EMAIL_CLIENTS.map((c) => c.id));
+  if (!ids) {
+    return EMAIL_CLIENTS.map((c) => c.id);
+  }
+  const requested = ids.split(",").map((s) => s.trim()).filter(Boolean);
+  const invalid = requested.filter((id) => !validIds.has(id));
+  if (invalid.length > 0) {
+    throw new Error(
+      `Unknown client ID(s): ${invalid.join(", ")}.
+Valid IDs: ${Array.from(validIds).join(", ")}`
+    );
+  }
+  return requested;
+}
+function resolveFormat(formatFlag, filePath) {
+  if (formatFlag) {
+    if (!VALID_FORMATS.has(formatFlag)) {
+      throw new Error(
+        `Unknown format "${formatFlag}". Valid formats: ${Array.from(VALID_FORMATS).join(", ")}`
+      );
+    }
+    return formatFlag;
+  }
+  if (filePath && filePath !== "-") {
+    return detectFormat(filePath);
+  }
+  return "html";
+}
+function toFramework(format) {
+  if (format === "jsx" || format === "mjml" || format === "maizzle") return format;
+  return void 0;
+}
+
+// src/compile/index.ts
+async function compile(source, format, _filePath) {
+  switch (format) {
+    case "html":
+      return source;
+    case "jsx": {
+      const { compileReactEmail } = await import("./react-email-ZWLGXROP.js");
+      return compileReactEmail(source);
+    }
+    case "mjml": {
+      const { compileMjml } = await import("./mjml-KG66APFB.js");
+      return compileMjml(source);
+    }
+    case "maizzle": {
+      const { compileMaizzle } = await import("./maizzle-JGKTYDDO.js");
+      return compileMaizzle(source);
+    }
+    default:
+      throw new Error(`Unknown format: "${format}". Use html, jsx, mjml, or maizzle.`);
+  }
+}
+
+// src/output/terminal.ts
+import pc from "picocolors";
+import Table from "cli-table3";
+import {
+  EMAIL_CLIENTS as EMAIL_CLIENTS2
+} from "@emailens/engine";
+function colorScore(score) {
+  const str = String(score);
+  if (score >= 90) return pc.green(str);
+  if (score >= 70) return pc.yellow(str);
+  return pc.red(str);
+}
+function severityIcon(severity) {
+  switch (severity) {
+    case "error":
+      return pc.red("\u2717");
+    case "warning":
+      return pc.yellow("\u26A0");
+    case "info":
+      return pc.blue("\u2139");
+  }
+}
+function worstSeverity(warnings) {
+  if (warnings.some((w) => w.severity === "error")) return "error";
+  if (warnings.some((w) => w.severity === "warning")) return "warning";
+  return "info";
+}
+function formatIssueCount(warnings) {
+  const errors = warnings.filter((w) => w.severity === "error").length;
+  const warns = warnings.filter((w) => w.severity === "warning").length;
+  const infos = warnings.filter((w) => w.severity === "info").length;
+  const parts = [];
+  if (errors > 0) parts.push(pc.red(`${errors} err`));
+  if (warns > 0) parts.push(pc.yellow(`${warns} warn`));
+  if (infos > 0) parts.push(pc.blue(`${infos} info`));
+  return parts.join(", ") || pc.green("none");
+}
+function printScoreTable(scores, warnings, options) {
+  if (!options?.quiet) {
+    console.log();
+    console.log(pc.bold("  Emailens \u2014 Compatibility Report"));
+    console.log();
+  }
+  const clientMap = new Map(EMAIL_CLIENTS2.map((c) => [c.id, c.name]));
+  const warningsByClient = /* @__PURE__ */ new Map();
+  for (const w of warnings) {
+    const existing = warningsByClient.get(w.client) ?? [];
+    existing.push(w);
+    warningsByClient.set(w.client, existing);
+  }
+  const table = new Table({
+    head: [pc.bold("Client"), pc.bold("Score"), pc.bold("Issues")],
+    style: { head: [], border: [] }
+  });
+  const sortedClients = Object.entries(scores).sort(([, a], [, b]) => a.score - b.score);
+  for (const [clientId, { score }] of sortedClients) {
+    const clientWarnings = warningsByClient.get(clientId) ?? [];
+    table.push([
+      clientMap.get(clientId) ?? clientId,
+      colorScore(score),
+      formatIssueCount(clientWarnings)
+    ]);
+  }
+  console.log(table.toString());
+  const scoreValues = Object.values(scores);
+  const overall = scoreValues.length > 0 ? Math.round(scoreValues.reduce((a, b) => a + b.score, 0) / scoreValues.length) : 0;
+  console.log();
+  console.log(`  Overall: ${colorScore(overall)}/100`);
+  console.log();
+}
+function printWarnings(warnings, options) {
+  if (warnings.length === 0) {
+    if (!options?.quiet) {
+      console.log(pc.green("  No compatibility issues found."));
+      console.log();
+    }
+    return;
+  }
+  const byClient = /* @__PURE__ */ new Map();
+  for (const w of warnings) {
+    const existing = byClient.get(w.client) ?? [];
+    existing.push(w);
+    byClient.set(w.client, existing);
+  }
+  const clientMap = new Map(EMAIL_CLIENTS2.map((c) => [c.id, c.name]));
+  for (const [clientId, clientWarnings] of byClient) {
+    const clientName = clientMap.get(clientId) ?? clientId;
+    const worst = worstSeverity(clientWarnings);
+    console.log(`  ${severityIcon(worst)} ${pc.bold(clientName)} (${clientWarnings.length} issue${clientWarnings.length === 1 ? "" : "s"})`);
+    for (const w of clientWarnings) {
+      const prop = pc.dim(w.property);
+      console.log(`    ${severityIcon(w.severity)} ${prop} \u2014 ${w.message}`);
+      if (w.suggestion) {
+        console.log(`      ${pc.dim("\u2192")} ${w.suggestion}`);
+      }
+    }
+    console.log();
+  }
+}
+
+// src/output/json.ts
+function formatJsonOutput(opts) {
+  const scoreValues = Object.values(opts.scores);
+  const overallScore = scoreValues.length > 0 ? Math.round(scoreValues.reduce((a, b) => a + b.score, 0) / scoreValues.length) : 0;
+  const output = {
+    overallScore,
+    scores: opts.scores,
+    warnings: opts.warnings.map((w) => ({
+      client: w.client,
+      property: w.property,
+      severity: w.severity,
+      message: w.message,
+      suggestion: w.suggestion,
+      fix: w.fix ? {
+        before: w.fix.before,
+        after: w.fix.after,
+        language: w.fix.language,
+        description: w.fix.description
+      } : void 0
+    }))
+  };
+  if (opts.transforms) {
+    output.transforms = opts.transforms.map((t) => ({
+      clientId: t.clientId,
+      html: t.html
+    }));
+  }
+  if (opts.darkMode) {
+    output.darkMode = {};
+    for (const [clientId, dm] of Object.entries(opts.darkMode)) {
+      output.darkMode[clientId] = {
+        html: dm.html,
+        warningCount: dm.warnings.length
+      };
+    }
+  }
+  return output;
+}
+function printJson(opts) {
+  console.log(JSON.stringify(formatJsonOutput(opts), null, 2));
+}
+
+// src/commands/analyze.ts
+var analyze_default = defineCommand({
+  meta: {
+    name: "analyze",
+    description: "Analyze email CSS compatibility across clients"
+  },
+  args: {
+    input: {
+      type: "positional",
+      description: "HTML file path or - for stdin",
+      required: true
+    },
+    format: {
+      type: "string",
+      alias: "f",
+      description: "Input format: html, jsx, mjml, maizzle"
+    },
+    clients: {
+      type: "string",
+      alias: "c",
+      description: "Comma-separated client IDs to filter"
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    },
+    quiet: {
+      type: "boolean",
+      alias: "q",
+      description: "Suppress spinners and decorations"
+    }
+  },
+  async run({ args }) {
+    const spinner = args.quiet || args.json ? null : ora();
+    try {
+      const format = resolveFormat(args.format, args.input);
+      spinner?.start("Reading input...");
+      const source = await readInput(args.input);
+      spinner?.succeed("Input read");
+      const html = await compile(source, format, args.input !== "-" ? args.input : void 0);
+      const clientIds = resolveClients(args.clients);
+      spinner?.start("Analyzing compatibility...");
+      const framework = toFramework(format);
+      const warnings = analyzeEmail(html, framework);
+      const allScores = generateCompatibilityScore(warnings);
+      const clientSet = new Set(clientIds);
+      const scores = {};
+      for (const [id, data] of Object.entries(allScores)) {
+        if (clientSet.has(id)) {
+          scores[id] = data;
+        }
+      }
+      const filteredWarnings = warnings.filter((w) => clientSet.has(w.client));
+      spinner?.succeed("Analysis complete");
+      if (args.json) {
+        printJson({ scores, warnings: filteredWarnings });
+      } else {
+        printScoreTable(scores, filteredWarnings, { quiet: args.quiet });
+        printWarnings(filteredWarnings, { quiet: args.quiet });
+      }
+    } catch (err) {
+      spinner?.fail(err.message);
+      process.exit(1);
+    }
+  }
+});
+
+// src/commands/preview.ts
+import { defineCommand as defineCommand2 } from "citty";
+import ora2 from "ora";
+import {
+  transformForAllClients,
+  analyzeEmail as analyzeEmail2,
+  generateCompatibilityScore as generateCompatibilityScore2,
+  simulateDarkMode
+} from "@emailens/engine";
+var preview_default = defineCommand2({
+  meta: {
+    name: "preview",
+    description: "Full email preview: transforms, analysis, dark mode, screenshots"
+  },
+  args: {
+    input: {
+      type: "positional",
+      description: "HTML file path or - for stdin",
+      required: true
+    },
+    format: {
+      type: "string",
+      alias: "f",
+      description: "Input format: html, jsx, mjml, maizzle"
+    },
+    clients: {
+      type: "string",
+      alias: "c",
+      description: "Comma-separated client IDs to filter"
+    },
+    "dark-mode": {
+      type: "boolean",
+      alias: "d",
+      description: "Include dark mode simulation"
+    },
+    screenshots: {
+      type: "boolean",
+      description: "Capture screenshots (requires BROWSERLESS_URL)"
+    },
+    out: {
+      type: "string",
+      alias: "o",
+      description: "Output directory for screenshots"
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    },
+    quiet: {
+      type: "boolean",
+      alias: "q",
+      description: "Suppress spinners and decorations"
+    }
+  },
+  async run({ args }) {
+    const spinner = args.quiet || args.json ? null : ora2();
+    try {
+      const format = resolveFormat(args.format, args.input);
+      spinner?.start("Reading input...");
+      const source = await readInput(args.input);
+      spinner?.succeed("Input read");
+      const html = await compile(source, format, args.input !== "-" ? args.input : void 0);
+      const clientIds = resolveClients(args.clients);
+      const clientSet = new Set(clientIds);
+      spinner?.start("Transforming for all clients...");
+      const allTransforms = transformForAllClients(html);
+      const transforms = allTransforms.filter((t) => clientSet.has(t.clientId));
+      spinner?.succeed(`Transformed for ${transforms.length} clients`);
+      spinner?.start("Analyzing compatibility...");
+      const framework = toFramework(format);
+      const warnings = analyzeEmail2(html, framework);
+      const allScores = generateCompatibilityScore2(warnings);
+      const scores = {};
+      for (const [id, data] of Object.entries(allScores)) {
+        if (clientSet.has(id)) {
+          scores[id] = data;
+        }
+      }
+      const filteredWarnings = warnings.filter((w) => clientSet.has(w.client));
+      spinner?.succeed("Analysis complete");
+      let darkMode;
+      if (args["dark-mode"]) {
+        spinner?.start("Simulating dark mode...");
+        darkMode = {};
+        for (const t of transforms) {
+          darkMode[t.clientId] = simulateDarkMode(t.html, t.clientId);
+        }
+        spinner?.succeed("Dark mode simulation complete");
+      }
+      if (args.screenshots) {
+        const outDir = args.out ?? "./emailens-screenshots";
+        spinner?.start("Capturing screenshots...");
+        try {
+          const { captureScreenshots } = await import("./screenshots-PMZQU5V7.js");
+          const results = await captureScreenshots(
+            transforms,
+            outDir,
+            (clientId, index, total) => {
+              if (spinner) spinner.text = `Capturing screenshots (${index}/${total}: ${clientId})...`;
+            }
+          );
+          spinner?.succeed(`Screenshots saved to ${outDir} (${results.size} files)`);
+        } catch (err) {
+          spinner?.warn(`Screenshots skipped: ${err.message}`);
+        }
+      }
+      if (args.json) {
+        printJson({ scores, warnings: filteredWarnings, transforms, darkMode });
+      } else {
+        printScoreTable(scores, filteredWarnings, { quiet: args.quiet });
+        printWarnings(filteredWarnings, { quiet: args.quiet });
+      }
+    } catch (err) {
+      spinner?.fail(err.message);
+      process.exit(1);
+    }
+  }
+});
+
+// src/commands/clients.ts
+import { defineCommand as defineCommand3 } from "citty";
+import pc2 from "picocolors";
+import Table2 from "cli-table3";
+import { EMAIL_CLIENTS as EMAIL_CLIENTS3 } from "@emailens/engine";
+var clients_default = defineCommand3({
+  meta: {
+    name: "clients",
+    description: "List all supported email clients"
+  },
+  args: {
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    }
+  },
+  run({ args }) {
+    if (args.json) {
+      const data = EMAIL_CLIENTS3.map((c) => ({
+        id: c.id,
+        name: c.name,
+        category: c.category,
+        engine: c.engine,
+        darkModeSupport: c.darkModeSupport
+      }));
+      console.log(JSON.stringify(data, null, 2));
+      return;
+    }
+    console.log();
+    console.log(pc2.bold("  Emailens \u2014 Supported Email Clients"));
+    console.log();
+    const table = new Table2({
+      head: [
+        pc2.bold("ID"),
+        pc2.bold("Name"),
+        pc2.bold("Category"),
+        pc2.bold("Engine"),
+        pc2.bold("Dark Mode")
+      ],
+      style: { head: [], border: [] }
+    });
+    for (const client of EMAIL_CLIENTS3) {
+      table.push([
+        client.id,
+        client.name,
+        client.category,
+        client.engine,
+        client.darkModeSupport ? pc2.green("Yes") : pc2.dim("No")
+      ]);
+    }
+    console.log(table.toString());
+    console.log();
+    console.log(pc2.dim(`  ${EMAIL_CLIENTS3.length} clients supported`));
+    console.log();
+  }
+});
+
+// src/commands/export.ts
+import { mkdirSync, writeFileSync } from "fs";
+import { join, resolve } from "path";
+import { defineCommand as defineCommand4 } from "citty";
+import ora3 from "ora";
+import {
+  transformForAllClients as transformForAllClients2,
+  analyzeEmail as analyzeEmail3,
+  generateCompatibilityScore as generateCompatibilityScore3,
+  simulateDarkMode as simulateDarkMode2
+} from "@emailens/engine";
+
+// src/output/html-report.ts
+import { EMAIL_CLIENTS as EMAIL_CLIENTS4 } from "@emailens/engine";
+function generateHtmlReport(opts) {
+  const clientMap = new Map(EMAIL_CLIENTS4.map((c) => [c.id, c]));
+  const scoreValues = Object.values(opts.scores);
+  const overallScore = scoreValues.length > 0 ? Math.round(scoreValues.reduce((a, b) => a + b.score, 0) / scoreValues.length) : 0;
+  const scoreColor = (s) => s >= 90 ? "#22c55e" : s >= 70 ? "#eab308" : "#ef4444";
+  const clientCards = Object.entries(opts.scores).sort(([, a], [, b]) => a.score - b.score).map(([clientId, { score, errors, warnings: warns, info }]) => {
+    const client = clientMap.get(clientId);
+    const name = client?.name ?? clientId;
+    const clientWarnings = opts.warnings.filter((w) => w.client === clientId);
+    const issueCount = errors + warns + info;
+    const warningRows = clientWarnings.map((w) => {
+      const icon = w.severity === "error" ? "✗" : w.severity === "warning" ? "⚠" : "ℹ";
+      const color = w.severity === "error" ? "#ef4444" : w.severity === "warning" ? "#eab308" : "#3b82f6";
+      return `<div style="padding:4px 0;border-bottom:1px solid #f1f1f1">
+          <span style="color:${color}">${icon}</span>
+          <strong>${escapeHtml(w.property)}</strong> \u2014 ${escapeHtml(w.message)}
+          ${w.suggestion ? `<br><span style="color:#888;margin-left:20px">&rarr; ${escapeHtml(w.suggestion)}</span>` : ""}
+        </div>`;
+    }).join("");
+    return `<div style="border:1px solid #e5e5e5;border-radius:8px;padding:16px;margin-bottom:16px">
+        <div style="display:flex;justify-content:space-between;align-items:center;margin-bottom:12px">
+          <h3 style="margin:0;font-size:16px">${escapeHtml(name)}</h3>
+          <span style="font-size:24px;font-weight:bold;color:${scoreColor(score)}">${score}</span>
+        </div>
+        <div style="font-size:13px;color:#888;margin-bottom:8px">${client?.engine ?? ""} &middot; ${client?.category ?? ""} &middot; ${issueCount} issue${issueCount === 1 ? "" : "s"}</div>
+        ${clientWarnings.length > 0 ? `<div style="font-size:13px">${warningRows}</div>` : '<div style="color:#22c55e;font-size:13px">No issues</div>'}
+      </div>`;
+  }).join("");
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Emailens Compatibility Report</title>
+<style>
+  * { box-sizing: border-box; }
+  body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif; margin: 0; padding: 24px; background: #fafafa; color: #333; }
+  .container { max-width: 900px; margin: 0 auto; }
+  .header { text-align: center; margin-bottom: 32px; }
+  .header h1 { margin: 0 0 8px; font-size: 24px; }
+  .overall { font-size: 48px; font-weight: bold; }
+  .subtitle { color: #888; font-size: 14px; }
+  .grid { display: grid; grid-template-columns: repeat(auto-fill, minmax(400px, 1fr)); gap: 16px; }
+  .footer { text-align: center; margin-top: 32px; color: #aaa; font-size: 12px; }
+</style>
+</head>
+<body>
+<div class="container">
+  <div class="header">
+    <h1>Emailens Compatibility Report</h1>
+    <div class="overall" style="color:${scoreColor(overallScore)}">${overallScore}/100</div>
+    <div class="subtitle">${Object.keys(opts.scores).length} clients analyzed &middot; ${opts.warnings.length} total issues</div>
+  </div>
+  <div class="grid">
+    ${clientCards}
+  </div>
+  <div class="footer">
+    Generated by <a href="https://github.com/emailens/cli" style="color:#888">@emailens/cli</a>
+  </div>
+</div>
+</body>
+</html>`;
+}
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+
+// src/commands/export.ts
+var export_default = defineCommand4({
+  meta: {
+    name: "export",
+    description: "Export compatibility report as JSON or HTML"
+  },
+  args: {
+    input: {
+      type: "positional",
+      description: "HTML file path or - for stdin",
+      required: true
+    },
+    format: {
+      type: "string",
+      alias: "f",
+      description: "Input format: html, jsx, mjml, maizzle"
+    },
+    clients: {
+      type: "string",
+      alias: "c",
+      description: "Comma-separated client IDs to filter"
+    },
+    "dark-mode": {
+      type: "boolean",
+      alias: "d",
+      description: "Include dark mode simulation"
+    },
+    screenshots: {
+      type: "boolean",
+      description: "Capture screenshots (requires BROWSERLESS_URL)"
+    },
+    out: {
+      type: "string",
+      alias: "o",
+      description: "Output directory (default: ./emailens-report)"
+    },
+    json: {
+      type: "boolean",
+      description: "Export as JSON instead of HTML"
+    },
+    quiet: {
+      type: "boolean",
+      alias: "q",
+      description: "Suppress spinners and decorations"
+    }
+  },
+  async run({ args }) {
+    const spinner = args.quiet ? null : ora3();
+    const outDir = resolve(args.out ?? "./emailens-report");
+    try {
+      const format = resolveFormat(args.format, args.input);
+      spinner?.start("Reading input...");
+      const source = await readInput(args.input);
+      spinner?.succeed("Input read");
+      const html = await compile(source, format, args.input !== "-" ? args.input : void 0);
+      const clientIds = resolveClients(args.clients);
+      const clientSet = new Set(clientIds);
+      spinner?.start("Transforming for all clients...");
+      const allTransforms = transformForAllClients2(html);
+      const transforms = allTransforms.filter((t) => clientSet.has(t.clientId));
+      spinner?.succeed(`Transformed for ${transforms.length} clients`);
+      spinner?.start("Analyzing compatibility...");
+      const framework = toFramework(format);
+      const warnings = analyzeEmail3(html, framework);
+      const allScores = generateCompatibilityScore3(warnings);
+      const scores = {};
+      for (const [id, data] of Object.entries(allScores)) {
+        if (clientSet.has(id)) {
+          scores[id] = data;
+        }
+      }
+      const filteredWarnings = warnings.filter((w) => clientSet.has(w.client));
+      spinner?.succeed("Analysis complete");
+      let darkMode;
+      if (args["dark-mode"]) {
+        spinner?.start("Simulating dark mode...");
+        darkMode = {};
+        for (const t of transforms) {
+          darkMode[t.clientId] = simulateDarkMode2(t.html, t.clientId);
+        }
+        spinner?.succeed("Dark mode simulation complete");
+      }
+      if (args.screenshots) {
+        spinner?.start("Capturing screenshots...");
+        try {
+          const { captureScreenshots } = await import("./screenshots-PMZQU5V7.js");
+          const screenshotDir = join(outDir, "screenshots");
+          const results = await captureScreenshots(
+            transforms,
+            screenshotDir,
+            (clientId, index, total) => {
+              if (spinner) spinner.text = `Capturing screenshots (${index}/${total}: ${clientId})...`;
+            }
+          );
+          spinner?.succeed(`Screenshots saved (${results.size} files)`);
+        } catch (err) {
+          spinner?.warn(`Screenshots skipped: ${err.message}`);
+        }
+      }
+      mkdirSync(outDir, { recursive: true });
+      if (args.json) {
+        spinner?.start("Exporting JSON...");
+        const jsonData = formatJsonOutput({ scores, warnings: filteredWarnings, transforms });
+        const jsonPath = join(outDir, "report.json");
+        writeFileSync(jsonPath, JSON.stringify(jsonData, null, 2));
+        spinner?.succeed(`JSON report saved to ${jsonPath}`);
+      } else {
+        spinner?.start("Generating HTML report...");
+        const htmlReport = generateHtmlReport({
+          scores,
+          warnings: filteredWarnings,
+          transforms,
+          darkMode,
+          originalHtml: html
+        });
+        const htmlPath = join(outDir, "report.html");
+        writeFileSync(htmlPath, htmlReport);
+        spinner?.succeed(`HTML report saved to ${htmlPath}`);
+      }
+      if (!args.quiet) {
+        console.log();
+        console.log(`  Output: ${outDir}`);
+        console.log();
+      }
+    } catch (err) {
+      spinner?.fail(err.message);
+      process.exit(1);
+    }
+  }
+});
+
+// src/index.ts
+var main = defineCommand5({
+  meta: {
+    name: "emailens",
+    version: "0.1.0",
+    description: "Email compatibility analysis CLI \u2014 preview how HTML emails render across 12 email clients."
+  },
+  subCommands: {
+    analyze: analyze_default,
+    preview: preview_default,
+    clients: clients_default,
+    export: export_default
+  }
+});
+runMain(main);
+//# sourceMappingURL=index.js.map