@vertaaux/cli 0.2.3 → 0.3.1

package/node_modules/@vertaaux/tui/dist/index.cjs

@@ -0,0 +1,1157 @@
+'use strict';
+
+var chalk = require('chalk');
+var events = require('events');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var chalk__default = /*#__PURE__*/_interopDefault(chalk);
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/ansi.ts
+var ESC = "\x1B";
+var CSI = `${ESC}[`;
+var cursor = {
+  /** Move cursor to row, col (1-indexed) */
+  to: (row, col) => `${CSI}${row};${col}H`,
+  /** Move cursor to top-left */
+  home: `${CSI}H`,
+  /** Move cursor up N lines */
+  up: (n = 1) => `${CSI}${n}A`,
+  /** Move cursor down N lines */
+  down: (n = 1) => `${CSI}${n}B`,
+  /** Move cursor to column N (1-indexed) */
+  column: (n) => `${CSI}${n}G`,
+  /** Hide cursor */
+  hide: `${CSI}?25l`,
+  /** Show cursor */
+  show: `${CSI}?25h`,
+  /** Save cursor position */
+  save: `${ESC}7`,
+  /** Restore cursor position */
+  restore: `${ESC}8`
+};
+var screen = {
+  /** Clear entire screen */
+  clear: `${CSI}2J`,
+  /** Clear from cursor to end of screen */
+  clearDown: `${CSI}J`,
+  /** Clear from cursor to end of line */
+  clearLine: `${CSI}K`,
+  /** Clear entire line */
+  clearFullLine: `${CSI}2K`,
+  /** Enter alternate screen buffer (preserves scrollback) */
+  altEnter: `${CSI}?1049h`,
+  /** Exit alternate screen buffer */
+  altExit: `${CSI}?1049l`
+};
+var style = {
+  /** Reset all attributes */
+  reset: `${CSI}0m`
+};
+var borders = {
+  single: {
+    topLeft: "\u250C",
+    // ┌
+    topRight: "\u2510",
+    // ┐
+    bottomLeft: "\u2514",
+    // └
+    bottomRight: "\u2518",
+    // ┘
+    horizontal: "\u2500",
+    // ─
+    vertical: "\u2502"
+    // │
+  },
+  double: {
+    topLeft: "\u2554",
+    // ╔
+    topRight: "\u2557",
+    // ╗
+    bottomLeft: "\u255A",
+    // ╚
+    bottomRight: "\u255D",
+    // ╝
+    horizontal: "\u2550",
+    // ═
+    vertical: "\u2551"
+    // ║
+  },
+  rounded: {
+    topLeft: "\u256D",
+    // ╭
+    topRight: "\u256E",
+    // ╮
+    bottomLeft: "\u2570",
+    // ╰
+    bottomRight: "\u256F",
+    // ╯
+    horizontal: "\u2500",
+    // ─
+    vertical: "\u2502"
+    // │
+  },
+  heavy: {
+    topLeft: "\u250F",
+    // ┏
+    topRight: "\u2513",
+    // ┓
+    bottomLeft: "\u2517",
+    // ┗
+    bottomRight: "\u251B",
+    // ┛
+    horizontal: "\u2501",
+    // ━
+    vertical: "\u2503"
+    // ┃
+  }
+};
+function stripAnsi(str) {
+  return str.replace(/\x1b\[[0-9;]*[A-Za-z]|\x1b[78]/g, "");
+}
+function visibleLength(str) {
+  return stripAnsi(str).length;
+}
+function padEnd(str, width) {
+  const visible = visibleLength(str);
+  if (visible >= width) return str;
+  return str + " ".repeat(width - visible);
+}
+function padStart(str, width) {
+  const visible = visibleLength(str);
+  if (visible >= width) return str;
+  return " ".repeat(width - visible) + str;
+}
+function center(str, width) {
+  const visible = visibleLength(str);
+  if (visible >= width) return str;
+  const left = Math.floor((width - visible) / 2);
+  const right = width - visible - left;
+  return " ".repeat(left) + str + " ".repeat(right);
+}
+function truncate(str, maxWidth) {
+  if (maxWidth <= 0) return "";
+  const stripped = stripAnsi(str);
+  if (stripped.length <= maxWidth) return str;
+  if (maxWidth <= 3) return stripped.slice(0, maxWidth);
+  return stripped.slice(0, maxWidth - 1) + "\u2026";
+}
+var brand = {
+  lime: "#78FFB4",
+  tealLight: "#6BEEBD",
+  teal: "#5EDDC6",
+  cyan: "#51CCCE",
+  dark: "#0A0F1A"
+};
+var gradient = [brand.lime, brand.tealLight, brand.teal, brand.cyan];
+var severity = {
+  critical: "#FF6B6B",
+  error: "#FF6B6B",
+  serious: "#FFD93D",
+  warning: "#FFD93D",
+  moderate: "#6BCEFF",
+  minor: "#6BCEFF",
+  info: "#888888"
+};
+var severityLabels = {
+  critical: "CRITICAL",
+  error: "ERROR",
+  serious: "SERIOUS",
+  warning: "WARNING",
+  moderate: "MODERATE",
+  minor: "MINOR",
+  info: "INFO"
+};
+var severityOrder = {
+  critical: 0,
+  error: 1,
+  serious: 2,
+  warning: 3,
+  minor: 4,
+  moderate: 5,
+  info: 6
+};
+var SCORE_THRESHOLDS = [
+  { min: 90, color: "#4ADE80" },
+  // Green — excellent
+  { min: 70, color: "#FACC15" },
+  // Yellow — needs work
+  { min: 0, color: "#F87171" }
+  // Red — poor
+];
+function scoreColor(score) {
+  for (const { min, color } of SCORE_THRESHOLDS) {
+    if (score >= min) return color;
+  }
+  return SCORE_THRESHOLDS[SCORE_THRESHOLDS.length - 1].color;
+}
+var tokens = {
+  success: "#4ADE80",
+  error: "#F87171",
+  warning: "#FACC15",
+  info: "#6BCEFF",
+  muted: "#6B7280",
+  accent: brand.lime
+};
+var _colorEnabled = true;
+function setColorEnabled(enabled) {
+  _colorEnabled = enabled;
+}
+function isColorEnabled() {
+  return _colorEnabled;
+}
+function colorize(text, hex) {
+  if (!_colorEnabled) return text;
+  return chalk__default.default.hex(hex)(text);
+}
+function boldColor(text, hex) {
+  if (!_colorEnabled) return text;
+  return chalk__default.default.hex(hex).bold(text);
+}
+function dim(text) {
+  if (!_colorEnabled) return text;
+  return chalk__default.default.dim(text);
+}
+function bold(text) {
+  if (!_colorEnabled) return text;
+  return chalk__default.default.bold(text);
+}
+function applyGradient(text, colors = gradient) {
+  if (!_colorEnabled) return text;
+  const colorCount = colors.length;
+  let result = "";
+  let idx = 0;
+  for (const char of text) {
+    if (char !== " " && char !== "\n") {
+      result += chalk__default.default.hex(colors[idx % colorCount])(char);
+      idx++;
+    } else {
+      result += char;
+    }
+  }
+  return result;
+}
+
+// src/detect.ts
+function isCI() {
+  return Boolean(
+    process.env.CI || process.env.CONTINUOUS_INTEGRATION || process.env.BUILD_NUMBER || process.env.GITHUB_ACTIONS || process.env.GITLAB_CI || process.env.CIRCLECI || process.env.JENKINS_URL || process.env.TRAVIS || process.env.BUILDKITE
+  );
+}
+function isTTY() {
+  return Boolean(process.stderr.isTTY);
+}
+function isStdoutTTY() {
+  return Boolean(process.stdout.isTTY);
+}
+function isStdinTTY() {
+  return Boolean(process.stdin.isTTY);
+}
+function shouldUseColor() {
+  if (process.env.NO_COLOR !== void 0) return false;
+  if (process.env.FORCE_COLOR !== void 0) return true;
+  if (isCI()) return false;
+  return isTTY();
+}
+function getTerminalWidth() {
+  return process.stderr.columns || 80;
+}
+function getTerminalHeight() {
+  return process.stderr.rows || 24;
+}
+function supportsUnicode() {
+  if (process.env.TERM === "dumb") return false;
+  if (process.platform === "win32") {
+    return Boolean(process.env.WT_SESSION || process.env.TERM_PROGRAM);
+  }
+  return true;
+}
+
+// src/primitives/text.ts
+var text_exports = {};
+__export(text_exports, {
+  bold: () => bold2,
+  dim: () => dim2,
+  error: () => error,
+  heading: () => heading,
+  hr: () => hr,
+  info: () => info,
+  keyValue: () => keyValue,
+  label: () => label,
+  link: () => link,
+  scoreBadge: () => scoreBadge,
+  severityBadge: () => severityBadge,
+  statusDot: () => statusDot,
+  subheading: () => subheading,
+  success: () => success,
+  warning: () => warning
+});
+function heading(text) {
+  return boldColor(text, brand.lime);
+}
+function subheading(text) {
+  return boldColor(text, brand.teal);
+}
+function label(text) {
+  return bold(text);
+}
+function dim2(text) {
+  return dim(text);
+}
+function bold2(text) {
+  return bold(text);
+}
+function link(text) {
+  if (!isColorEnabled()) return text;
+  return colorize(`\x1B[4m${text}\x1B[24m`, tokens.info);
+}
+function severityBadge(level) {
+  const normalized = level.toLowerCase();
+  const displayLabel = severityLabels[normalized] || level.toUpperCase();
+  const hex = severity[normalized] || tokens.muted;
+  return boldColor(displayLabel, hex);
+}
+function scoreBadge(score) {
+  const hex = scoreColor(score);
+  return boldColor(String(score), hex);
+}
+function success(text) {
+  return colorize(text, tokens.success);
+}
+function error(text) {
+  return colorize(text, tokens.error);
+}
+function warning(text) {
+  return colorize(text, tokens.warning);
+}
+function info(text) {
+  return colorize(text, tokens.info);
+}
+function keyValue(key, value) {
+  return `${bold(key)}: ${value}`;
+}
+function hr(width, char = "\u2500") {
+  const line = char.repeat(width);
+  return dim(line);
+}
+function statusDot(status) {
+  const map = {
+    pass: { symbol: "\u25CF", hex: tokens.success },
+    // ●
+    fail: { symbol: "\u25CF", hex: tokens.error },
+    // ●
+    warn: { symbol: "\u25CF", hex: tokens.warning },
+    // ●
+    skip: { symbol: "\u25CB", hex: tokens.muted },
+    // ○
+    active: { symbol: "\u25CF", hex: brand.lime }
+    // ●
+  };
+  const { symbol, hex } = map[status] || map.skip;
+  return colorize(symbol, hex);
+}
+
+// src/primitives/box.ts
+function box(content, opts = {}) {
+  const {
+    border = "rounded",
+    padding = 1,
+    paddingY = 0,
+    title,
+    subtitle,
+    width: fixedWidth,
+    borderColor = brand.teal,
+    titleColor = brand.lime
+  } = opts;
+  if (border === "none") {
+    return renderNoBorder(content, padding);
+  }
+  const chars = borders[border];
+  const termWidth = fixedWidth || Math.min(getTerminalWidth(), 100);
+  const innerWidth = termWidth - 2 - padding * 2;
+  const bc = (ch) => colorize(ch, borderColor);
+  const lines = wrapLines(content, innerWidth);
+  const pad = " ".repeat(padding);
+  const result = [];
+  result.push(renderTopBorder(chars, termWidth, title, titleColor, borderColor));
+  for (let i = 0; i < paddingY; i++) {
+    result.push(bc(chars.vertical) + " ".repeat(termWidth - 2) + bc(chars.vertical));
+  }
+  for (const line of lines) {
+    const padded = pad + padEnd(line, innerWidth) + pad;
+    result.push(bc(chars.vertical) + padded + bc(chars.vertical));
+  }
+  for (let i = 0; i < paddingY; i++) {
+    result.push(bc(chars.vertical) + " ".repeat(termWidth - 2) + bc(chars.vertical));
+  }
+  result.push(renderBottomBorder(chars, termWidth, subtitle, borderColor));
+  return result.join("\n");
+}
+function renderNoBorder(content, padding) {
+  const pad = " ".repeat(padding);
+  return content.split("\n").map((line) => pad + line + pad).join("\n");
+}
+function renderTopBorder(chars, width, title, titleColor, borderColor) {
+  const bc = (ch) => colorize(ch, borderColor);
+  const hLen = width - 2;
+  if (title) {
+    const titleStr = isColorEnabled() ? ` ${colorize(title, titleColor)} ` : ` ${title} `;
+    const titleVisible = visibleLength(titleStr);
+    const leftDash = 1;
+    const rightDash = Math.max(0, hLen - leftDash - titleVisible);
+    return bc(chars.topLeft) + bc(chars.horizontal.repeat(leftDash)) + titleStr + bc(chars.horizontal.repeat(rightDash)) + bc(chars.topRight);
+  }
+  return bc(chars.topLeft) + bc(chars.horizontal.repeat(hLen)) + bc(chars.topRight);
+}
+function renderBottomBorder(chars, width, subtitle, borderColor) {
+  const bc = (ch) => colorize(ch, borderColor);
+  const hLen = width - 2;
+  if (subtitle) {
+    const subStr = ` ${dim(subtitle)} `;
+    const subVisible = visibleLength(subStr);
+    const rightDash = 1;
+    const leftDash = Math.max(0, hLen - rightDash - subVisible);
+    return bc(chars.bottomLeft) + bc(chars.horizontal.repeat(leftDash)) + subStr + bc(chars.horizontal.repeat(rightDash)) + bc(chars.bottomRight);
+  }
+  return bc(chars.bottomLeft) + bc(chars.horizontal.repeat(hLen)) + bc(chars.bottomRight);
+}
+function wrapLines(text, maxWidth) {
+  const result = [];
+  for (const rawLine of text.split("\n")) {
+    if (rawLine.length <= maxWidth) {
+      result.push(rawLine);
+      continue;
+    }
+    const words = rawLine.split(" ");
+    let current = "";
+    for (const word of words) {
+      if (current.length === 0) {
+        current = word;
+      } else if (current.length + 1 + word.length <= maxWidth) {
+        current += " " + word;
+      } else {
+        result.push(current);
+        current = word;
+      }
+    }
+    if (current.length > 0) {
+      result.push(current);
+    }
+  }
+  return result;
+}
+
+// src/primitives/table.ts
+function renderTable(rows, columns, opts = {}) {
+  if (rows.length === 0) return "";
+  const maxWidth = opts.maxWidth || getTerminalWidth();
+  const colWidths = calculateColumnWidths(rows, columns, maxWidth);
+  const lines = [];
+  if (opts.groupLabel) {
+    lines.push(dim(`\u2500\u2500 ${opts.groupLabel} ${"\u2500".repeat(Math.max(0, maxWidth - opts.groupLabel.length - 4))}`));
+  }
+  lines.push(renderHeaderRow(columns, colWidths));
+  lines.push(renderSeparator(colWidths));
+  for (const row of rows) {
+    lines.push(renderDataRow(row, columns, colWidths));
+    if (opts.rowBorders) {
+      lines.push(renderSeparator(colWidths));
+    }
+  }
+  return lines.join("\n");
+}
+function calculateColumnWidths(rows, columns, maxWidth) {
+  const GAP = 2;
+  const widths = [];
+  let fixedTotal = 0;
+  let autoCount = 0;
+  for (const col of columns) {
+    if (col.width) {
+      widths.push(col.width);
+      fixedTotal += col.width;
+    } else {
+      const headerLen = col.label.length;
+      const maxContent = rows.reduce((max, row) => {
+        const val = row[col.key] || "";
+        return Math.max(max, val.length);
+      }, headerLen);
+      widths.push(maxContent);
+      autoCount++;
+    }
+  }
+  const gaps = (columns.length - 1) * GAP;
+  const totalNeeded = widths.reduce((s, w) => s + w, 0) + gaps;
+  if (totalNeeded > maxWidth && autoCount > 0) {
+    const available = maxWidth - fixedTotal - gaps;
+    const autoWidths = widths.filter((_, i) => !columns[i].width);
+    const autoTotal = autoWidths.reduce((s, w) => s + w, 0);
+    for (let i = 0; i < widths.length; i++) {
+      if (!columns[i].width) {
+        widths[i] = Math.max(8, Math.floor(widths[i] / autoTotal * available));
+      }
+    }
+  }
+  return widths;
+}
+function renderHeaderRow(columns, widths) {
+  const cells = columns.map(
+    (col, i) => bold(alignCell(col.label, widths[i], col.align || "left"))
+  );
+  return cells.join("  ");
+}
+function renderSeparator(widths) {
+  return dim(widths.map((w) => "\u2500".repeat(w)).join("\u2500\u2500"));
+}
+function renderDataRow(row, columns, widths) {
+  const cells = columns.map((col, i) => {
+    const raw = row[col.key] || "";
+    const truncated = truncate(raw, widths[i]);
+    const aligned = alignCell(truncated, widths[i], col.align || "left");
+    return col.color ? col.color(aligned) : aligned;
+  });
+  return cells.join("  ");
+}
+function alignCell(text, width, align) {
+  switch (align) {
+    case "right":
+      return padStart(text, width);
+    case "center": {
+      const visible = visibleLength(text);
+      if (visible >= width) return text;
+      const left = Math.floor((width - visible) / 2);
+      const right = width - visible - left;
+      return " ".repeat(left) + text + " ".repeat(right);
+    }
+    default:
+      return padEnd(text, width);
+  }
+}
+
+// src/primitives/spinner.ts
+var BRAILLE_FRAMES = ["\u287F", "\u28DF", "\u28EF", "\u28F7", "\u28FE", "\u28FD", "\u28FB", "\u28BF"];
+var FRAME_INTERVAL = 80;
+function createSpinner(text, output = process.stderr) {
+  let frameIndex = 0;
+  let currentText = text;
+  let currentPhase = "";
+  let timer = null;
+  let running = false;
+  const enabled = isTTY();
+  function render() {
+    if (!enabled) return;
+    const frame = isColorEnabled() ? colorize(BRAILLE_FRAMES[frameIndex], brand.lime) : BRAILLE_FRAMES[frameIndex];
+    const phaseStr = currentPhase ? dim(` [${currentPhase}]`) : "";
+    const line = `${frame} ${currentText}${phaseStr}`;
+    output.write(screen.clearLine + "\r" + line);
+    frameIndex = (frameIndex + 1) % BRAILLE_FRAMES.length;
+  }
+  function clearLine() {
+    if (!enabled) return;
+    output.write(screen.clearLine + "\r");
+  }
+  function writeFinalLine(symbol, text2) {
+    clearLine();
+    output.write(`${symbol} ${text2}
+`);
+  }
+  const instance = {
+    get isRunning() {
+      return running;
+    },
+    start() {
+      if (running) return;
+      running = true;
+      frameIndex = 0;
+      if (enabled) {
+        render();
+        timer = setInterval(render, FRAME_INTERVAL);
+      }
+    },
+    stop() {
+      running = false;
+      if (timer) {
+        clearInterval(timer);
+        timer = null;
+      }
+      clearLine();
+    },
+    setText(text2) {
+      currentText = text2;
+    },
+    setPhase(phase) {
+      currentPhase = phase;
+    },
+    succeed(text2) {
+      instance.stop();
+      const sym = isColorEnabled() ? colorize("\u2713", "#4ADE80") : "\u2713";
+      writeFinalLine(sym, text2);
+    },
+    fail(text2) {
+      instance.stop();
+      const sym = isColorEnabled() ? colorize("\u2717", "#F87171") : "\u2717";
+      writeFinalLine(sym, text2);
+    },
+    warn(text2) {
+      instance.stop();
+      const sym = isColorEnabled() ? colorize("\u26A0", "#FACC15") : "\u26A0";
+      writeFinalLine(sym, text2);
+    },
+    info(text2) {
+      instance.stop();
+      const sym = isColorEnabled() ? colorize("\u2139", "#6BCEFF") : "\u2139";
+      writeFinalLine(sym, text2);
+    }
+  };
+  return instance;
+}
+
+// src/primitives/progress.ts
+var FILL_CHAR = "\u2588";
+var EMPTY_CHAR = "\u2591";
+function createProgressBar(opts) {
+  const {
+    total,
+    label: label2 = "",
+    width: fixedWidth,
+    color = brand.lime,
+    output = process.stderr
+  } = opts;
+  const enabled = isTTY();
+  let startTime = Date.now();
+  function renderBar(current, barWidth) {
+    const pct = total > 0 ? Math.min(current / total, 1) : 0;
+    const pctStr = `${Math.round(pct * 100)}%`;
+    const termWidth = barWidth || fixedWidth || Math.max(20, getTerminalWidth() - (label2.length + 12));
+    const filled = Math.round(pct * termWidth);
+    const empty = termWidth - filled;
+    const bar = isColorEnabled() ? colorize(FILL_CHAR.repeat(filled), color) + dim(EMPTY_CHAR.repeat(empty)) : FILL_CHAR.repeat(filled) + EMPTY_CHAR.repeat(empty);
+    const eta = formatETA(current, total, startTime);
+    const labelStr = label2 ? padEnd(label2, 16) : "";
+    return `${labelStr}${bar} ${pctStr}${eta ? ` ${dim(eta)}` : ""}`;
+  }
+  return {
+    update(current) {
+      if (!enabled) return;
+      const line = renderBar(current);
+      output.write(screen.clearLine + "\r" + line);
+    },
+    complete(message) {
+      if (!enabled) return;
+      output.write(screen.clearLine + "\r");
+      if (message) {
+        const sym = isColorEnabled() ? colorize("\u2713", "#4ADE80") : "\u2713";
+        output.write(`${sym} ${message}
+`);
+      }
+    },
+    fail(message) {
+      if (!enabled) return;
+      output.write(screen.clearLine + "\r");
+      if (message) {
+        const sym = isColorEnabled() ? colorize("\u2717", "#F87171") : "\u2717";
+        output.write(`${sym} ${message}
+`);
+      }
+    },
+    render(current, barWidth) {
+      return renderBar(current, barWidth);
+    }
+  };
+}
+function formatETA(current, total, startTime) {
+  if (current <= 0 || total <= 0) return "";
+  const elapsed = (Date.now() - startTime) / 1e3;
+  const rate = current / elapsed;
+  const remaining = (total - current) / rate;
+  if (remaining <= 0 || !isFinite(remaining)) return "";
+  if (remaining < 60) return `~${Math.ceil(remaining)}s`;
+  return `~${Math.ceil(remaining / 60)}m`;
+}
+function createMultiProgress(opts = {}) {
+  const output = opts.output || process.stderr;
+  const bars = /* @__PURE__ */ new Map();
+  let drawnLines = 0;
+  return {
+    add(id, barOpts) {
+      const bar = createProgressBar({ ...barOpts, output });
+      bars.set(id, { bar, current: 0, total: barOpts.total, completed: false });
+    },
+    update(id, current) {
+      const entry = bars.get(id);
+      if (entry) {
+        entry.current = current;
+      }
+    },
+    complete(id) {
+      const entry = bars.get(id);
+      if (entry) {
+        entry.current = entry.total;
+        entry.completed = true;
+      }
+    },
+    renderAll() {
+      const lines = [];
+      for (const [, entry] of bars) {
+        lines.push(entry.bar.render(entry.current));
+      }
+      return lines.join("\n");
+    },
+    draw() {
+      if (!isTTY()) return;
+      if (drawnLines > 0) {
+        output.write(cursor.up(drawnLines));
+      }
+      const lines = [];
+      for (const [, entry] of bars) {
+        lines.push(screen.clearLine + entry.bar.render(entry.current));
+      }
+      output.write(lines.join("\n") + "\n");
+      drawnLines = lines.length;
+    },
+    clear() {
+      if (!isTTY() || drawnLines === 0) return;
+      output.write(cursor.up(drawnLines));
+      for (let i = 0; i < drawnLines; i++) {
+        output.write(screen.clearLine + "\n");
+      }
+      output.write(cursor.up(drawnLines));
+      drawnLines = 0;
+    }
+  };
+}
+
+// src/primitives/list.ts
+function renderList(items, opts = {}) {
+  const { ordered = false, indent = 0, bullet = "\u2022" } = opts;
+  const pad = "  ".repeat(indent);
+  return items.map((item, i) => {
+    const prefix = ordered ? `${pad}${i + 1}.` : `${pad}${bullet}`;
+    return `${prefix} ${item}`;
+  }).join("\n");
+}
+function renderTree(node, prefix = "", isLast = true, isRoot = true) {
+  const lines = [];
+  if (isRoot) {
+    lines.push(node.label);
+  } else {
+    const connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+    lines.push(prefix + dim(connector) + node.label);
+  }
+  if (node.children && !node.collapsed) {
+    const childPrefix = isRoot ? "" : prefix + (isLast ? "    " : dim("\u2502   "));
+    node.children.forEach((child, index) => {
+      const childIsLast = index === node.children.length - 1;
+      lines.push(renderTree(child, childPrefix, childIsLast, false));
+    });
+  }
+  return lines.join("\n");
+}
+function renderGroupedList(groups, opts = {}) {
+  const entries = groups instanceof Map ? [...groups.entries()] : Object.entries(groups);
+  const sections = [];
+  for (const [groupLabel, items] of entries) {
+    if (items.length === 0) continue;
+    const header = dim(`\u2500\u2500 ${groupLabel} (${items.length}) ${"\u2500".repeat(20)}`);
+    const list = renderList(items, { ...opts, indent: (opts.indent || 0) + 1 });
+    sections.push(`${header}
+${list}`);
+  }
+  return sections.join("\n\n");
+}
+
+// src/primitives/diff.ts
+function renderDiff(lines, opts = {}) {
+  const { mode = "unified" } = opts;
+  if (mode === "side-by-side") {
+    return renderSideBySide(lines, opts);
+  }
+  return renderUnified(lines);
+}
+function renderUnified(lines) {
+  return lines.map((line) => {
+    switch (line.type) {
+      case "header":
+        return dim(line.content);
+      case "add":
+        return colorize(`+ ${line.content}`, tokens.success);
+      case "remove":
+        return colorize(`- ${line.content}`, tokens.error);
+      case "context":
+        return dim(`  ${line.content}`);
+    }
+  }).join("\n");
+}
+function renderSideBySide(lines, opts) {
+  const maxWidth = opts.maxWidth || getTerminalWidth();
+  const halfWidth = Math.floor((maxWidth - 3) / 2);
+  const left = [];
+  const right = [];
+  for (const line of lines) {
+    if (line.type === "header") {
+      left.push(dim(line.content));
+      right.push("");
+    } else if (line.type === "remove") {
+      left.push(colorize(truncateLine(line.content, halfWidth), tokens.error));
+      right.push("");
+    } else if (line.type === "add") {
+      left.push("");
+      right.push(colorize(truncateLine(line.content, halfWidth), tokens.success));
+    } else {
+      const ctx = dim(truncateLine(line.content, halfWidth));
+      left.push(ctx);
+      right.push(ctx);
+    }
+  }
+  const merged = mergeSideBySide(left, right, halfWidth);
+  return merged.join("\n");
+}
+function mergeSideBySide(left, right, halfWidth) {
+  const result = [];
+  const sep = dim(" \u2502 ");
+  let li = 0;
+  let ri = 0;
+  while (li < left.length || ri < right.length) {
+    const l = li < left.length ? left[li] : "";
+    const r = ri < right.length ? right[ri] : "";
+    if (l === "" && r === "") {
+      li++;
+      ri++;
+      continue;
+    }
+    if (l !== "" && r === "") {
+      result.push(padEnd(l, halfWidth) + sep + padEnd("", halfWidth));
+      li++;
+      ri++;
+      continue;
+    }
+    if (l === "" && r !== "") {
+      result.push(padEnd("", halfWidth) + sep + padEnd(r, halfWidth));
+      li++;
+      ri++;
+      continue;
+    }
+    result.push(padEnd(l, halfWidth) + sep + padEnd(r, halfWidth));
+    li++;
+    ri++;
+  }
+  return result;
+}
+function truncateLine(text, maxWidth) {
+  if (text.length <= maxWidth) return text;
+  return text.slice(0, maxWidth - 1) + "\u2026";
+}
+function parseDiff(diffText) {
+  const lines = [];
+  for (const raw of diffText.split("\n")) {
+    if (raw.startsWith("@@") || raw.startsWith("---") || raw.startsWith("+++") || raw.startsWith("diff ")) {
+      lines.push({ type: "header", content: raw });
+    } else if (raw.startsWith("+")) {
+      lines.push({ type: "add", content: raw.slice(1) });
+    } else if (raw.startsWith("-")) {
+      lines.push({ type: "remove", content: raw.slice(1) });
+    } else {
+      lines.push({ type: "context", content: raw.startsWith(" ") ? raw.slice(1) : raw });
+    }
+  }
+  return lines;
+}
+
+// src/dashboard/state.ts
+var AuditPhase = {
+  Connecting: "Connecting",
+  Crawling: "Crawling",
+  Analyzing: "Analyzing",
+  Scoring: "Scoring",
+  Done: "Done",
+  Failed: "Failed"
+};
+var PHASE_ORDER = [
+  AuditPhase.Connecting,
+  AuditPhase.Crawling,
+  AuditPhase.Analyzing,
+  AuditPhase.Scoring,
+  AuditPhase.Done
+];
+function phaseIndex(phase) {
+  const idx = PHASE_ORDER.indexOf(phase);
+  return idx >= 0 ? idx : 0;
+}
+function phaseTotal() {
+  return PHASE_ORDER.length - 1;
+}
+
+// src/dashboard/frame.ts
+function renderFrame(state, width, _height) {
+  const sections = [];
+  const innerWidth = Math.min(width - 4, 96);
+  const time = formatTime(/* @__PURE__ */ new Date());
+  sections.push(
+    box(padEnd(state.url, innerWidth - state.mode.length - 14) + `${dim("mode:")} ${state.mode}`, {
+      border: "rounded",
+      title: `VertaaUX Audit`,
+      subtitle: time,
+      width: innerWidth + 4,
+      borderColor: brand.teal,
+      titleColor: brand.lime
+    })
+  );
+  const currentPhaseIdx = phaseIndex(state.phase);
+  const phaseDots = PHASE_ORDER.slice(0, -1).map((_, i) => {
+    if (i < currentPhaseIdx) return statusDot("pass");
+    if (i === currentPhaseIdx) return statusDot("active");
+    return statusDot("skip");
+  }).join("");
+  const phaseLabel = bold(state.phase);
+  const phasePct = state.phaseTotal > 0 ? dim(` (${state.phaseIndex}/${state.phaseTotal})`) : "";
+  sections.push(`  Phase: ${phaseLabel}       ${phaseDots}${phasePct}`);
+  sections.push("");
+  const barWidth = innerWidth - 22;
+  const analyzerNames = Object.keys(state.progress);
+  if (analyzerNames.length > 0) {
+    for (const name of analyzerNames) {
+      const current = state.progress[name] || 0;
+      const total = state.totals[name] || 100;
+      const pct = total > 0 ? Math.min(current / total, 1) : 0;
+      const filled = Math.round(pct * barWidth);
+      const empty = barWidth - filled;
+      const fillStr = isColorEnabled() ? colorize("\u2588".repeat(filled), brand.lime) + dim("\u2591".repeat(empty)) : "\u2588".repeat(filled) + "\u2591".repeat(empty);
+      const pctStr = `${Math.round(pct * 100)}%`;
+      const label2 = padEnd(capitalize(name), 16);
+      sections.push(`  ${label2}${fillStr} ${pctStr}`);
+    }
+  } else {
+    sections.push(dim("  Waiting for analyzers..."));
+  }
+  sections.push("");
+  const issueStr = `Issues found: ${bold(String(state.issueCount))}`;
+  const scoreStr = state.scorePreview !== null ? `Score preview: ${colorize(String(state.scorePreview), scoreColor(state.scorePreview))}` : dim("Score: --");
+  sections.push(`  ${issueStr}    ${scoreStr}`);
+  sections.push("");
+  const keys = dim("[q] abort  [v] verbose");
+  const elapsed = dim(formatElapsed(state.elapsed));
+  const footerPad = Math.max(0, innerWidth - visibleLength(keys) - visibleLength(elapsed));
+  sections.push(`  ${keys}${" ".repeat(footerPad)}${elapsed}`);
+  return sections.join("\n");
+}
+function formatTime(date) {
+  const h = String(date.getHours()).padStart(2, "0");
+  const m = String(date.getMinutes()).padStart(2, "0");
+  const s = String(date.getSeconds()).padStart(2, "0");
+  return `${h}:${m}:${s}`;
+}
+function formatElapsed(ms) {
+  const totalSecs = Math.floor(ms / 1e3);
+  const mins = Math.floor(totalSecs / 60);
+  const secs = totalSecs % 60;
+  return `${String(mins).padStart(2, "0")}:${String(secs).padStart(2, "0")} elapsed`;
+}
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+// src/layout/alternate.ts
+var AlternateScreenRenderer = class {
+  output;
+  entered = false;
+  constructor(output = process.stderr) {
+    this.output = output;
+  }
+  update(state) {
+    if (!this.entered) {
+      this.output.write(screen.altEnter + cursor.hide);
+      this.entered = true;
+    }
+    const width = getTerminalWidth();
+    getTerminalHeight();
+    const frame = renderFrame(state, width);
+    this.output.write(cursor.home + screen.clear + frame);
+  }
+  finish(result) {
+    this.dispose();
+    const summary = this.renderSummary(result);
+    this.output.write(summary + "\n");
+  }
+  dispose() {
+    if (this.entered) {
+      this.output.write(cursor.show + screen.altExit);
+      this.entered = false;
+    }
+  }
+  renderSummary(result) {
+    const status = result.passed ? colorize("PASSED", "#4ADE80") : colorize("FAILED", "#F87171");
+    const scoreStr = colorize(String(result.overallScore), result.overallScore >= 70 ? "#4ADE80" : "#F87171");
+    const lines = [
+      `${bold("Audit Complete")} \u2014 ${status}`,
+      `${dim("URL:")} ${result.url}`,
+      `${dim("Score:")} ${scoreStr} ${dim(`| ${result.issueCount} issues | ${formatElapsed2(result.elapsed)}`)}`
+    ];
+    const categories = Object.entries(result.scores).map(([cat, score]) => `  ${cat}: ${score}`).join("\n");
+    if (categories) {
+      lines.push(dim(categories));
+    }
+    return box(lines.join("\n"), { border: "rounded", title: "VertaaUX", width: Math.min(getTerminalWidth(), 80) });
+  }
+};
+function formatElapsed2(ms) {
+  const secs = Math.round(ms / 1e3);
+  if (secs < 60) return `${secs}s`;
+  return `${Math.floor(secs / 60)}m ${secs % 60}s`;
+}
+
+// src/layout/inline.ts
+var InlineRenderer = class {
+  output;
+  lastPhase = "";
+  constructor(output = process.stderr) {
+    this.output = output;
+  }
+  update(state) {
+    if (state.phase !== this.lastPhase) {
+      this.lastPhase = state.phase;
+      const ts = timestamp();
+      const phasePct = state.phaseTotal > 0 ? ` (${state.phaseIndex}/${state.phaseTotal})` : "";
+      this.output.write(
+        `${dim(ts)} ${bold(state.phase)}${dim(phasePct)} ${dim(`| ${state.issueCount} issues`)}
+`
+      );
+    }
+  }
+  finish(result) {
+    const ts = timestamp();
+    const status = result.passed ? isColorEnabled() ? colorize("PASSED", "#4ADE80") : "PASSED" : isColorEnabled() ? colorize("FAILED", "#F87171") : "FAILED";
+    const elapsed = formatElapsed3(result.elapsed);
+    this.output.write(
+      `${dim(ts)} ${bold("Audit Complete")} ${status} score=${result.overallScore} issues=${result.issueCount} ${dim(elapsed)}
+`
+    );
+  }
+  dispose() {
+  }
+};
+function timestamp() {
+  const now = /* @__PURE__ */ new Date();
+  return `[${pad2(now.getHours())}:${pad2(now.getMinutes())}:${pad2(now.getSeconds())}]`;
+}
+function pad2(n) {
+  return n < 10 ? `0${n}` : String(n);
+}
+function formatElapsed3(ms) {
+  const secs = Math.round(ms / 1e3);
+  if (secs < 60) return `(${secs}s)`;
+  return `(${Math.floor(secs / 60)}m ${secs % 60}s)`;
+}
+
+// src/layout/renderer.ts
+function createRenderer(mode = "auto", output = process.stderr) {
+  if (mode === "auto") {
+    mode = isTTY() && !isCI() ? "alternate" : "inline";
+  }
+  if (mode === "alternate") {
+    return new AlternateScreenRenderer(output);
+  }
+  return new InlineRenderer(output);
+}
+function createKeyboardHandler(stdin = process.stdin) {
+  const emitter = new events.EventEmitter();
+  let started = false;
+  let wasRawMode = false;
+  function onData(data) {
+    const key = data.toString();
+    if (key === "") {
+      emitter.emit("quit");
+      return;
+    }
+    switch (key.toLowerCase()) {
+      case "q":
+        emitter.emit("quit");
+        break;
+      case "v":
+        emitter.emit("verbose");
+        break;
+    }
+  }
+  return {
+    start() {
+      if (started) return;
+      if (!stdin.isTTY || typeof stdin.setRawMode !== "function") return;
+      started = true;
+      wasRawMode = stdin.isRaw;
+      stdin.setRawMode(true);
+      stdin.resume();
+      stdin.on("data", onData);
+    },
+    dispose() {
+      if (!started) return;
+      started = false;
+      stdin.removeListener("data", onData);
+      if (stdin.isTTY && typeof stdin.setRawMode === "function") {
+        stdin.setRawMode(wasRawMode);
+      }
+      stdin.pause();
+    },
+    on(event, handler) {
+      emitter.on(event, handler);
+    }
+  };
+}
+
+exports.AlternateScreenRenderer = AlternateScreenRenderer;
+exports.AuditPhase = AuditPhase;
+exports.InlineRenderer = InlineRenderer;
+exports.PHASE_ORDER = PHASE_ORDER;
+exports.applyGradient = applyGradient;
+exports.bold = bold;
+exports.boldColor = boldColor;
+exports.borders = borders;
+exports.box = box;
+exports.brand = brand;
+exports.center = center;
+exports.colorize = colorize;
+exports.createKeyboardHandler = createKeyboardHandler;
+exports.createMultiProgress = createMultiProgress;
+exports.createProgressBar = createProgressBar;
+exports.createRenderer = createRenderer;
+exports.createSpinner = createSpinner;
+exports.cursor = cursor;
+exports.dim = dim;
+exports.getTerminalHeight = getTerminalHeight;
+exports.getTerminalWidth = getTerminalWidth;
+exports.gradient = gradient;
+exports.isCI = isCI;
+exports.isColorEnabled = isColorEnabled;
+exports.isStdinTTY = isStdinTTY;
+exports.isStdoutTTY = isStdoutTTY;
+exports.isTTY = isTTY;
+exports.padEnd = padEnd;
+exports.padStart = padStart;
+exports.parseDiff = parseDiff;
+exports.phaseIndex = phaseIndex;
+exports.phaseTotal = phaseTotal;
+exports.renderDiff = renderDiff;
+exports.renderFrame = renderFrame;
+exports.renderGroupedList = renderGroupedList;
+exports.renderList = renderList;
+exports.renderTable = renderTable;
+exports.renderTree = renderTree;
+exports.scoreColor = scoreColor;
+exports.screen = screen;
+exports.setColorEnabled = setColorEnabled;
+exports.severity = severity;
+exports.severityLabels = severityLabels;
+exports.severityOrder = severityOrder;
+exports.shouldUseColor = shouldUseColor;
+exports.stripAnsi = stripAnsi;
+exports.style = style;
+exports.supportsUnicode = supportsUnicode;
+exports.text = text_exports;
+exports.tokens = tokens;
+exports.truncate = truncate;
+exports.visibleLength = visibleLength;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map