chartforge 0.0.2 → 0.1.0

package/cli/dist/GridPlugin-C90wMQsN.cjs

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const BasePlugin = require("./BasePlugin-DcBTEJBs.cjs");
+const misc = require("./misc-tOf-LXeZ.cjs");
+class GridPlugin extends BasePlugin.BasePlugin {
+  constructor(chart, cfg = {}) {
+    super(chart, cfg);
+    const c = chart;
+    this._opts = misc.merge({
+      enabled: true,
+      x: { enabled: true, color: c.theme.axis.grid, strokeWidth: 1, dashArray: "2,2" },
+      y: { enabled: true, color: c.theme.axis.grid, strokeWidth: 1, dashArray: "2,2", ticks: 5 }
+    }, cfg);
+  }
+  init() {
+    if (!this._opts.enabled) return;
+    const c = this._chart;
+    this._group = misc.createSVGElement("g", { className: "cf-grid" });
+    c.mainGroup.insertBefore(this._group, c.mainGroup.firstChild);
+    this._els.push(this._group);
+    this._draw();
+    c.on("beforeRender", () => this._draw());
+  }
+  _draw() {
+    const c = this._chart;
+    misc.removeChildren(this._group);
+    const vb = c.svg.getAttribute("viewBox").split(" ").map(Number);
+    const W = vb[2], H = vb[3];
+    const pad = c.config.padding ?? {};
+    const p = { top: pad.top ?? 40, right: pad.right ?? 40, bottom: pad.bottom ?? 60, left: pad.left ?? 60 };
+    const sx = p.left, ex = W - p.right;
+    const sy = p.top, ey = H - p.bottom;
+    if (this._opts.y?.enabled) {
+      const nticks = this._opts.y.ticks ?? 5;
+      const step = (ey - sy) / nticks;
+      for (let i = 0; i <= nticks; i++) {
+        const y = ey - i * step;
+        this._group.appendChild(misc.createSVGElement("line", {
+          x1: sx,
+          y1: y,
+          x2: ex,
+          y2: y,
+          stroke: this._opts.y.color ?? "#ccc",
+          "stroke-width": this._opts.y.strokeWidth ?? 1,
+          "stroke-dasharray": this._opts.y.dashArray ?? "2,2",
+          opacity: "0.5"
+        }));
+      }
+    }
+    if (this._opts.x?.enabled) {
+      const labels = c.config.data.labels ?? [];
+      const step = (ex - sx) / (labels.length || 1);
+      for (let i = 0; i <= labels.length; i++) {
+        const x = sx + step * i;
+        this._group.appendChild(misc.createSVGElement("line", {
+          x1: x,
+          y1: sy,
+          x2: x,
+          y2: ey,
+          stroke: this._opts.x.color ?? "#ccc",
+          "stroke-width": this._opts.x.strokeWidth ?? 1,
+          "stroke-dasharray": this._opts.x.dashArray ?? "2,2",
+          opacity: "0.5"
+        }));
+      }
+    }
+  }
+}
+exports.GridPlugin = GridPlugin;

package/cli/dist/builtins-5HYzyd_B.cjs

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const lightTheme = {
+  background: "#ffffff",
+  foreground: "#000000",
+  grid: "#e5e5e5",
+  text: "#333333",
+  textSecondary: "#666666",
+  colors: ["#3b82f6", "#ef4444", "#10b981", "#f59e0b", "#8b5cf6", "#ec4899", "#06b6d4", "#84cc16"],
+  tooltip: { background: "#ffffff", text: "#000000", border: "#e5e5e5", shadow: "rgba(0,0,0,0.1)" },
+  legend: { text: "#333333", hover: "#000000" },
+  axis: { line: "#d1d5db", text: "#6b7280", grid: "#f3f4f6" }
+};
+const darkTheme = {
+  background: "#1a1a1a",
+  foreground: "#ffffff",
+  grid: "#333333",
+  text: "#e5e5e5",
+  textSecondary: "#999999",
+  colors: ["#60a5fa", "#f87171", "#34d399", "#fbbf24", "#a78bfa", "#f472b6", "#22d3ee", "#a3e635"],
+  tooltip: { background: "#2a2a2a", text: "#ffffff", border: "#444444", shadow: "rgba(0,0,0,0.3)" },
+  legend: { text: "#e5e5e5", hover: "#ffffff" },
+  axis: { line: "#404040", text: "#9ca3af", grid: "#262626" }
+};
+const neonTheme = {
+  background: "#0a0a0a",
+  foreground: "#00ffff",
+  grid: "#1a1a2e",
+  text: "#00ffff",
+  textSecondary: "#ff00ff",
+  colors: ["#00ffff", "#ff00ff", "#ffff00", "#00ff00", "#ff0080", "#8000ff", "#ff8000", "#0080ff"],
+  tooltip: { background: "#1a1a2e", text: "#00ffff", border: "#00ffff", shadow: "rgba(0,255,255,0.3)" },
+  legend: { text: "#00ffff", hover: "#ff00ff" },
+  axis: { line: "#1a1a2e", text: "#00ffff", grid: "#16161f" }
+};
+const BUILT_IN_THEMES = {
+  light: lightTheme,
+  dark: darkTheme,
+  neon: neonTheme
+};
+exports.BUILT_IN_THEMES = BUILT_IN_THEMES;
+exports.darkTheme = darkTheme;
+exports.lightTheme = lightTheme;
+exports.neonTheme = neonTheme;

package/cli/dist/chartforge.cjs

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+"use strict";
+require("./index-BtGYSrj-.cjs");

package/cli/dist/index-BtGYSrj-.cjs

@@ -0,0 +1,240 @@
+"use strict";
+const FLAGS = {
+  // Input
+  "input": { alias: "i", type: "string", desc: "Input file path (JSON/CSV/TSV/YAML) or - for stdin" },
+  "url": { alias: "u", type: "string", desc: "Fetch data from HTTP/HTTPS URL" },
+  "data": { alias: "d", type: "string", desc: "Inline JSON data string" },
+  "format": { alias: "f", type: "string", desc: "Input format: json | csv | tsv | yaml" },
+  "jq": { type: "string", desc: "Dot-path to extract from JSON response (e.g. data.items)" },
+  "method": { alias: "X", type: "string", desc: "HTTP method: GET | POST (default: GET)", default: "GET" },
+  "headers": { alias: "H", type: "string", desc: "JSON string of HTTP headers" },
+  "body": { alias: "b", type: "string", desc: "HTTP request body (for POST)" },
+  "interval": { type: "number", desc: "Poll interval in seconds for --serve (default: 5)", default: 5 },
+  // Chart
+  "type": { alias: "t", type: "string", desc: "Chart type: column|bar|line|pie|donut|scatter|stackedColumn|stackedBar|funnel|heatmap|candlestick", default: "column" },
+  "title": { type: "string", desc: "Chart title" },
+  "width": { alias: "w", type: "number", desc: "Chart width in pixels (default: 800)", default: 800 },
+  "height": { alias: "h", type: "number", desc: "Chart height in pixels (default: 450)", default: 450 },
+  "theme": { type: "string", desc: "Theme: light | dark | neon (default: dark)", default: "dark" },
+  "labels": { alias: "l", type: "string", desc: "Comma-separated label override" },
+  // Output
+  "output": { alias: "o", type: "string", desc: "Output file path (default: auto-named in cwd)" },
+  "out": { type: "string", desc: "Output format: html | svg | png | terminal (default: html)", default: "html" },
+  "open": { type: "boolean", desc: "Open output in browser after rendering", default: false },
+  "watch": { type: "boolean", desc: "Watch input file and re-render on change", default: false },
+  // Misc
+  "verbose": { alias: "v", type: "boolean", desc: "Verbose output", default: false },
+  "no-color": { type: "boolean", desc: "Disable ANSI colors", default: false },
+  "help": { type: "boolean", desc: "Show this help message", default: false },
+  "version": { alias: "V", type: "boolean", desc: "Print version", default: false }
+};
+const ALIAS_MAP = /* @__PURE__ */ new Map();
+for (const [name, def] of Object.entries(FLAGS)) {
+  if (def.alias) ALIAS_MAP.set(def.alias, name);
+}
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  const opts = {};
+  let command = "render";
+  for (const [key, def] of Object.entries(FLAGS)) {
+    if (def.default !== void 0) opts[key] = def.default;
+  }
+  let i = 0;
+  while (i < args.length) {
+    const arg = args[i];
+    if (!arg.startsWith("-")) {
+      if (["render", "serve", "watch", "help", "version"].includes(arg)) {
+        command = arg;
+      } else {
+        opts["input"] = arg;
+      }
+      i++;
+      continue;
+    }
+    if (arg.includes("=")) {
+      const [rawKey2, ...rest] = arg.replace(/^-+/, "").split("=");
+      const key2 = ALIAS_MAP.get(rawKey2) ?? rawKey2;
+      const value = rest.join("=");
+      const def2 = FLAGS[key2];
+      opts[key2] = def2?.type === "number" ? Number(value) : value;
+      i++;
+      continue;
+    }
+    const rawKey = arg.replace(/^-+/, "");
+    const key = ALIAS_MAP.get(rawKey) ?? rawKey;
+    const def = FLAGS[key];
+    if (!def) {
+      i++;
+      continue;
+    }
+    if (def.type === "boolean") {
+      opts[key] = true;
+      i++;
+    } else {
+      const value = args[i + 1];
+      opts[key] = def.type === "number" ? Number(value) : value;
+      i += 2;
+    }
+  }
+  if (opts["no-color"]) process.env["NO_COLOR"] = "1";
+  return {
+    command: command === "help" ? "help" : command,
+    opts
+  };
+}
+function printHelp(version) {
+  const c2 = (code, s) => process.stdout.isTTY ? `\x1B[${code}m${s}\x1B[0m` : s;
+  console.log();
+  console.log(c2("36;1", "  ⬡ ChartForge CLI") + c2("90", ` v${version}`));
+  console.log(c2("2", "  SVG/PNG/HTML/Terminal chart generator"));
+  console.log();
+  console.log(c2("1", "  Usage"));
+  console.log(c2("36", "    npx chartforge") + " [command] [options]");
+  console.log(c2("36", "    chartforge") + " <file>  [options]");
+  console.log();
+  console.log(c2("1", "  Commands"));
+  const cmds = [
+    ["render", "Render a chart from file, URL, or stdin (default)"],
+    ["serve", "Poll a URL and live-refresh output"],
+    ["watch", "Watch a file and re-render on change"],
+    ["help", "Show this help message"],
+    ["version", "Print version number"]
+  ];
+  for (const [cmd, desc] of cmds) {
+    console.log(`    ${c2("36", cmd.padEnd(10))} ${desc}`);
+  }
+  console.log();
+  console.log(c2("1", "  Options"));
+  for (const [name, def] of Object.entries(FLAGS)) {
+    if (name === "help" || name === "version") continue;
+    const alias = def.alias ? `-${def.alias}, ` : "    ";
+    const flag = `${alias}--${name}`;
+    const dflt = def.default !== void 0 && def.default !== false ? c2("90", ` [${def.default}]`) : "";
+    console.log(`    ${c2("33", flag.padEnd(24))} ${def.desc}${dflt}`);
+  }
+  console.log();
+  console.log(c2("1", "  Examples"));
+  const examples = [
+    ["# From file", ""],
+    ["chartforge data.json", ""],
+    ["chartforge data.csv -t line -o chart.html --open", ""],
+    ["", ""],
+    ["# From stdin", ""],
+    ["echo '[10,20,30]' | chartforge - -t bar --out terminal", ""],
+    ["cat sales.csv | chartforge - -t column --theme neon --out svg", ""],
+    ["", ""],
+    ["# From HTTP URL", ""],
+    ["chartforge --url https://api.example.com/data --jq data.series", ""],
+    ["chartforge --url https://api/csv --format csv -t line", ""],
+    ["", ""],
+    ["# Live terminal dashboard", ""],
+    ["chartforge serve --url https://api.example.com/metrics --interval 3 --out terminal", ""],
+    ["", ""],
+    ["# Watch file", ""],
+    ["chartforge watch --input data.json --out html --open", ""],
+    ["", ""],
+    ["# Export PNG (requires sharp)", ""],
+    ["chartforge data.json --out png --output chart.png", ""],
+    ["", ""],
+    ["# Pipe SVG to file", ""],
+    ["chartforge data.json --out svg -o - > chart.svg", ""],
+    ["", ""],
+    ["# Inline data", ""],
+    [`chartforge --data '{"series":[{"data":[1,2,3]}]}' --out terminal`, ""],
+    ["", ""],
+    ["# HTTP POST with auth", ""],
+    [`chartforge --url https://api/data --method POST --headers '{"Authorization":"Bearer TOKEN"}' --body '{"range":"7d"}'`, ""]
+  ];
+  for (const [ex] of examples) {
+    if (!ex) {
+      console.log();
+      continue;
+    }
+    if (ex.startsWith("#")) {
+      console.log(c2("90", `  ${ex}`));
+      continue;
+    }
+    console.log(c2("2", `  $ `) + c2("36", ex));
+  }
+  console.log();
+}
+const USE_COLOR = !process.env["NO_COLOR"] && process.stdout.isTTY;
+const c = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  cyan: "\x1B[36m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  red: "\x1B[31m",
+  gray: "\x1B[90m"
+};
+const paint = (code, text) => USE_COLOR ? `${code}${text}${c.reset}` : text;
+const logger = {
+  prefix: paint(c.cyan + c.bold, "⬡ ChartForge"),
+  info: (msg) => console.log(`${logger.prefix} ${paint(c.gray, "›")} ${msg}`),
+  success: (msg) => console.log(`${logger.prefix} ${paint(c.green, "✓")} ${paint(c.green, msg)}`),
+  warn: (msg) => console.warn(`${logger.prefix} ${paint(c.yellow, "⚠")} ${paint(c.yellow, msg)}`),
+  error: (msg, err) => {
+    console.error(`${logger.prefix} ${paint(c.red, "✗")} ${paint(c.red, msg)}`);
+    if (err) console.error(paint(c.dim, String(err instanceof Error ? err.stack : err)));
+  },
+  step: (msg) => console.log(`  ${paint(c.cyan, "→")} ${msg}`),
+  dim: (msg) => console.log(paint(c.dim, `  ${msg}`)),
+  blank: () => console.log(),
+  // Banner shown on startup
+  banner: () => {
+    console.log();
+    console.log(paint(c.cyan + c.bold, [
+      "  ╔═══════════════════════════╗",
+      "  ║   ⬡  C H A R T F O R G E  ║",
+      "  ║   CLI Visualization Tool  ║",
+      "  ╚═══════════════════════════╝"
+    ].join("\n")));
+    console.log(paint(c.dim, "  SVG • PNG • HTML • Terminal"));
+    console.log();
+  }
+};
+const VERSION = "1.0.0";
+async function main() {
+  const { command, opts } = parseArgs(process.argv);
+  if (command === "version" || opts.version) {
+    console.log(`chartforge/${VERSION}`);
+    return;
+  }
+  if (command === "help" || opts.help) {
+    printHelp(VERSION);
+    return;
+  }
+  logger.banner();
+  try {
+    switch (command) {
+      case "serve": {
+        const { runServe } = await Promise.resolve().then(() => require("./serve-74PsUgLE.cjs"));
+        await runServe(opts);
+        break;
+      }
+      case "watch": {
+        const { runWatch } = await Promise.resolve().then(() => require("./watch-Dv_eG4Wh.cjs"));
+        await runWatch(opts);
+        break;
+      }
+      default: {
+        const { runRender } = await Promise.resolve().then(() => require("./render-OAxwCzdV.cjs"));
+        await runRender(opts);
+        break;
+      }
+    }
+  } catch (err) {
+    logger.error(
+      err instanceof Error ? err.message : String(err),
+      opts.verbose ? err : void 0
+    );
+    process.exit(1);
+  }
+}
+main().catch((err) => {
+  console.error("[ChartForge]", err);
+  process.exit(1);
+});
+exports.logger = logger;

package/cli/dist/misc-tOf-LXeZ.cjs

@@ -0,0 +1,52 @@
+"use strict";
+function createSVGElement(tag, attrs = {}) {
+  const el = document.createElementNS("http://www.w3.org/2000/svg", tag);
+  for (const [key, value] of Object.entries(attrs)) {
+    if (key === "className") {
+      el.setAttribute("class", String(value));
+    } else if (key.startsWith("on") && typeof value === "function") {
+      el.addEventListener(key.slice(2).toLowerCase(), value);
+    } else {
+      el.setAttribute(key, String(value));
+    }
+  }
+  return el;
+}
+function removeChildren(el) {
+  while (el.firstChild) el.removeChild(el.firstChild);
+}
+function polarToCartesian(cx, cy, r, angleDeg) {
+  const rad = (angleDeg - 90) * Math.PI / 180;
+  return { x: cx + r * Math.cos(rad), y: cy + r * Math.sin(rad) };
+}
+function uid() {
+  return `cf-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+}
+function debounce(fn, delay) {
+  let id;
+  return (...args) => {
+    clearTimeout(id);
+    id = setTimeout(() => fn(...args), delay);
+  };
+}
+function merge(target, ...sources) {
+  for (const src of sources) {
+    if (!src) continue;
+    for (const key of Object.keys(src)) {
+      const sv = src[key];
+      const tv = target[key];
+      if (sv && typeof sv === "object" && !Array.isArray(sv) && tv && typeof tv === "object" && !Array.isArray(tv)) {
+        merge(tv, sv);
+      } else if (sv !== void 0) {
+        target[key] = sv;
+      }
+    }
+  }
+  return target;
+}
+exports.createSVGElement = createSVGElement;
+exports.debounce = debounce;
+exports.merge = merge;
+exports.polarToCartesian = polarToCartesian;
+exports.removeChildren = removeChildren;
+exports.uid = uid;

package/cli/dist/png-By3-3Jat.cjs

@@ -0,0 +1,61 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index = require("./index-BtGYSrj-.cjs");
+async function renderToPNG(svgResult, scale = 2) {
+  try {
+    const sharp = (await import("sharp")).default;
+    const buf = Buffer.from(svgResult.svg, "utf8");
+    return await sharp(buf).resize(svgResult.width * scale, svgResult.height * scale).png({ compressionLevel: 9 }).toBuffer();
+  } catch {
+  }
+  try {
+    const { Resvg } = await import("@resvg/resvg-js");
+    const resvg = new Resvg(svgResult.svg, {
+      fitTo: { mode: "width", value: svgResult.width * scale }
+    });
+    const img = resvg.render();
+    return img.asPng();
+  } catch {
+  }
+  index.logger.warn(
+    "PNG export requires one of: sharp, @resvg/resvg-js\n  Install with: npm install sharp\n  Or:           npm install @resvg/resvg-js"
+  );
+  throw new Error("No PNG renderer available");
+}
+async function hasPNGSupport() {
+  try {
+    await import("sharp");
+    return true;
+  } catch {
+  }
+  try {
+    await import("@resvg/resvg-js");
+    return true;
+  } catch {
+  }
+  return false;
+}
+exports.hasPNGSupport = hasPNGSupport;
+exports.renderToPNG = renderToPNG;

package/cli/dist/render-OAxwCzdV.cjs

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const fs = require("fs");
+const path = require("path");
+const writer = require("./writer-CRUdthqh.cjs");
+const index = require("./index-BtGYSrj-.cjs");
+async function readStdin() {
+  return new Promise((resolve, reject) => {
+    let data = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => data += chunk);
+    process.stdin.on("end", () => resolve(data));
+    process.stdin.on("error", reject);
+  });
+}
+function readFile(filePath) {
+  return fs.readFileSync(filePath, "utf8");
+}
+function detectFormat(filePath) {
+  const ext = path.extname(filePath).toLowerCase().slice(1);
+  return ext || "json";
+}
+async function loadFromFile(filePath, format) {
+  const raw = filePath === "-" ? await readStdin() : readFile(filePath);
+  const fmt = format ?? detectFormat(filePath);
+  return writer.parseInput(raw, fmt);
+}
+async function runRender(opts) {
+  const outFmt = opts.out ?? "html";
+  const verbose = opts.verbose ?? false;
+  let data;
+  if (opts.url) {
+    if (verbose) index.logger.step(`Fetching from URL: ${opts.url}`);
+    data = await writer.fetchData({
+      url: opts.url,
+      method: opts.method,
+      headers: opts.headers ? JSON.parse(opts.headers) : void 0,
+      body: opts.body,
+      jq: opts.jq
+    });
+  } else if (opts.data) {
+    if (verbose) index.logger.step("Parsing inline data");
+    data = writer.parseJSON(opts.data, opts.jq);
+  } else if (opts.input) {
+    if (verbose) index.logger.step(`Reading file: ${opts.input}`);
+    data = await loadFromFile(opts.input, opts.format);
+  } else {
+    if (verbose) index.logger.step("Reading from stdin");
+    data = await loadFromFile("-", opts.format);
+  }
+  if (verbose) {
+    index.logger.dim(`Loaded ${data.series.length} series, ${data.series[0]?.data?.length ?? 0} points`);
+  }
+  if (outFmt === "terminal") {
+    const rendered = writer.renderToTerminal(data, {
+      type: opts.type,
+      title: opts.title,
+      width: opts.width
+    });
+    writer.writeStdout(rendered);
+    return;
+  }
+  if (verbose) index.logger.step("Rendering SVG");
+  const svgResult = await writer.renderToSVG(data, opts);
+  let outPath = opts.output;
+  if (outFmt === "svg") {
+    const dest2 = outPath ?? writer.defaultFilename("svg");
+    if (dest2 === "-") {
+      writer.writeStdout(svgResult.svg);
+    } else {
+      writer.writeOutput(svgResult.svg, dest2);
+    }
+    return;
+  }
+  if (outFmt === "png") {
+    const { renderToPNG } = await Promise.resolve().then(() => require("./png-By3-3Jat.cjs"));
+    if (verbose) index.logger.step("Converting to PNG");
+    const pngBuf = await renderToPNG(svgResult);
+    const dest2 = outPath ?? writer.defaultFilename("png");
+    writer.writeOutput(pngBuf, dest2);
+    if (opts.open) await writer.openInBrowser(dest2);
+    return;
+  }
+  if (verbose) index.logger.step("Generating HTML page");
+  const html = writer.generateHTML(svgResult, data, opts);
+  const dest = outPath ?? writer.defaultFilename("html");
+  if (dest === "-") {
+    writer.writeStdout(html);
+  } else {
+    writer.writeOutput(html, dest);
+    if (opts.open) await writer.openInBrowser(dest);
+  }
+}
+exports.runRender = runRender;

package/cli/dist/serve-74PsUgLE.cjs

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const writer = require("./writer-CRUdthqh.cjs");
+const index = require("./index-BtGYSrj-.cjs");
+async function runServe(opts) {
+  if (!opts.url) {
+    index.logger.error("--serve requires --url <endpoint>");
+    process.exit(1);
+  }
+  const interval = opts.interval ?? 5;
+  const outFmt = opts.out ?? "terminal";
+  index.logger.info(`Live mode — polling ${opts.url} every ${interval}s`);
+  index.logger.dim(`Format: ${outFmt}  |  Ctrl+C to stop`);
+  index.logger.blank();
+  const controller = new AbortController();
+  process.on("SIGINT", () => {
+    index.logger.blank();
+    index.logger.info("Stopped.");
+    controller.abort();
+    process.exit(0);
+  });
+  await writer.pollData(
+    {
+      url: opts.url,
+      method: opts.method,
+      headers: opts.headers ? JSON.parse(opts.headers) : void 0,
+      body: opts.body,
+      jq: opts.jq
+    },
+    interval,
+    async (data, tick) => {
+      if (outFmt === "terminal") {
+        if (tick > 0) process.stdout.write("\x1B[2J\x1B[H");
+        const rendered = writer.renderToTerminal(data, {
+          type: opts.type,
+          title: `${opts.title ?? "Live Chart"} — tick ${tick + 1}`,
+          width: opts.width
+        });
+        process.stdout.write(rendered);
+      } else {
+        const svgResult = await writer.renderToSVG(data, opts);
+        const dest = opts.output ?? writer.defaultFilename(outFmt === "html" ? "html" : outFmt);
+        if (outFmt === "html") {
+          writer.writeOutput(writer.generateHTML(svgResult, data, opts), dest);
+        } else if (outFmt === "svg") {
+          writer.writeOutput(svgResult.svg, dest);
+        } else if (outFmt === "png") {
+          const { renderToPNG } = await Promise.resolve().then(() => require("./png-By3-3Jat.cjs"));
+          writer.writeOutput(await renderToPNG(svgResult), dest);
+        }
+        if (tick === 0 && opts.open) await writer.openInBrowser(dest);
+        index.logger.info(`Tick ${tick + 1} — saved to ${dest}`);
+      }
+    },
+    controller.signal
+  );
+}
+exports.runServe = runServe;

package/cli/dist/watch-Dv_eG4Wh.cjs

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const fs = require("fs");
+const path = require("path");
+const render = require("./render-OAxwCzdV.cjs");
+const index = require("./index-BtGYSrj-.cjs");
+async function runWatch(opts) {
+  const filePath = opts.input;
+  if (!filePath || filePath === "-") {
+    index.logger.error("--watch requires --input <file>");
+    process.exit(1);
+  }
+  const abs = path.resolve(filePath);
+  index.logger.info(`Watching ${abs} for changes…`);
+  index.logger.dim("Press Ctrl+C to stop");
+  index.logger.blank();
+  await render.runRender({ ...opts, open: opts.open }).catch(
+    (err) => index.logger.error("Render failed", err)
+  );
+  let debounceTimer = null;
+  fs.watch(abs, { persistent: true }, (event) => {
+    if (event !== "change") return;
+    if (debounceTimer) clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(async () => {
+      index.logger.info(`File changed — re-rendering…`);
+      await render.runRender({ ...opts, open: false }).catch(
+        (err) => index.logger.error("Re-render failed", err)
+      );
+    }, 200);
+  });
+  await new Promise(() => {
+  });
+}
+exports.runWatch = runWatch;