archymedes-cli 2.1.0 → 2.2.0

package/README.md

@@ -309,3 +309,18 @@ TUI dependency resolution. The reviewed archive and SHA256 checksum are written
 See [the release assessment](https://github.com/chrisnkuno/archymedes-cli/blob/main/docs/RELEASE_ASSESSMENT.md) for scope and remaining release proof.
 
 The startup geometry makes a brief rotation on roomy interactive terminals. Set `ARCHYMEDES_NO_MOTION=1` to keep it still. Preview it with `bun run preview:tui archymedes --animate`.
+
+## Fixed workspace
+
+Start with `archymedes --layout fixed` for a persistent mode bar, an anchored composer, and menus
+that open inside the transcript area. `/layout` switches layouts during a session;
+`ARCHYMEDES_LAYOUT=fixed` makes the fixed workspace your launch preference.
+
+Use `/mode` to choose plan, build, auto, or defender with the arrow keys. Page Up / Page Down
+read retained transcript history; Escape returns to live output. Home and End still edit the
+composer. Each tab retains up to 5,000 output lines. Resize reflows the live transcript.
+
+The opening geometry rotates while the workspace is idle and settles as soon as you type.
+`ARCHYMEDES_NO_MOTION=1` disables this motion and menu focus animation. `--ascii`, `NO_COLOR`,
+and the existing themes remain supported. Try the real interface offline from the repository
+with `bun run preview:workspace`; the preview uses a temporary project and a local model fixture.

package/dist/archymedes-5zn4zp84.mjs

@@ -0,0 +1,646 @@
+// packages/archymedes-cli/src/theme.ts
+var BLUEPRINT = `
+/* Blueprint navy, chalk-white ink and an amber pencil — the original drafting table. */
+@theme blueprint {
+    --primary: #7cc5ff;
+    --secondary: #9fb4e8;
+    --accent: #ffcf6b;
+    --bg: #0a1524;
+    --surface: #122135;
+    --text: #e8eefb;
+    --text-muted: #6f89b0;
+    --success: #79dfa6;
+    --warning: #ffcf6b;
+    --error: #ff8f7a;
+    --border: round;
+    --border-color: #24406a;
+    --border-focus: #7cc5ff;
+}
+`;
+var PARCHMENT = `
+/* The same drawing inked on paper, for a light terminal. */
+@theme parchment {
+    --primary: #2f5fbf;
+    --secondary: #5a4a86;
+    --accent: #9a6a00;
+    --bg: #faf6ec;
+    --surface: #f1eadd;
+    --text: #1b1a16;
+    --text-muted: #6a6252;
+    --success: #196a44;
+    --warning: #8a5300;
+    --error: #b3243b;
+    --border: round;
+    --border-color: #d8cfb8;
+    --border-focus: #2f5fbf;
+}
+`;
+var CHALKBOARD = `
+/* A slate: near-black green, chalk white, chalk yellow — for terminals with contrast to spare. */
+@theme chalkboard {
+    --primary: #9fe8d8;
+    --secondary: #d8d0b0;
+    --accent: #ffe066;
+    --bg: #0d1a15;
+    --surface: #16271f;
+    --text: #f2efe4;
+    --text-muted: #86987f;
+    --success: #7ef2b0;
+    --warning: #ffd166;
+    --error: #ff7a7a;
+    --border: single;
+    --border-color: #2c443a;
+    --border-focus: #ffe066;
+}
+`;
+var HIGH_CONTRAST = `
+/* Maximum separation, named colours only — for low vision and for terminals with a fixed palette. */
+@theme high-contrast {
+    --primary: brightCyan;
+    --secondary: brightMagenta;
+    --accent: brightYellow;
+    --bg: black;
+    --surface: black;
+    --text: brightWhite;
+    --text-muted: white;
+    --success: brightGreen;
+    --warning: brightYellow;
+    --error: brightRed;
+    --border: single;
+    --border-color: white;
+    --border-focus: brightCyan;
+}
+`;
+var ARCHYMEDES = `
+/* Bronze instruments, limestone ink and olive accents on charcoal — Archymedes's own. */
+@theme archymedes {
+    --primary: #e7bb78;
+    --secondary: #b9c59a;
+    --accent: #e5a58c;
+    --bg: #191815;
+    --surface: #25231e;
+    --text: #f2ecdf;
+    --text-muted: #aaa18f;
+    --success: #b5cc96;
+    --warning: #efc778;
+    --error: #f29686;
+    --border: single;
+    --border-color: #736956;
+    --border-focus: #e7bb78;
+}
+`;
+var RAINBOW = `
+/* Every hue at once — the opening art and the thinking spinner sweep the full spectrum. */
+@theme rainbow {
+    --primary: #ff5f5f;
+    --secondary: #5fd7ff;
+    --accent: #ffd75f;
+    --bg: #0c0c0c;
+    --surface: #161616;
+    --text: #f2f2f2;
+    --text-muted: #9a9a9a;
+    --success: #5fff87;
+    --warning: #ffaf5f;
+    --error: #ff3b3b;
+    --border: double;
+    --border-color: #8a8a8a;
+    --border-focus: #d75fff;
+}
+`;
+var BUILTIN_THEME_SOURCES = {
+  archymedes: ARCHYMEDES,
+  blueprint: BLUEPRINT,
+  parchment: PARCHMENT,
+  chalkboard: CHALKBOARD,
+  "high-contrast": HIGH_CONTRAST,
+  rainbow: RAINBOW
+};
+var DEFAULT_THEME_NAME = "archymedes";
+var NAMED_COLORS = {
+  black: 0,
+  red: 1,
+  green: 2,
+  yellow: 3,
+  blue: 4,
+  magenta: 5,
+  cyan: 6,
+  white: 7,
+  brightblack: 8,
+  brightred: 9,
+  brightgreen: 10,
+  brightyellow: 11,
+  brightblue: 12,
+  brightmagenta: 13,
+  brightcyan: 14,
+  brightwhite: 15,
+  gray: 8,
+  grey: 8
+};
+function parseColor(value) {
+  const text = value.trim();
+  const named = NAMED_COLORS[text.toLowerCase().replace(/[\s_-]/g, "")];
+  if (named !== undefined)
+    return named;
+  const hex = /^#([0-9a-f]{3}|[0-9a-f]{6})$/i.exec(text);
+  if (!hex)
+    return;
+  const digits = hex[1];
+  const full = digits.length === 3 ? digits.split("").map((digit) => digit + digit).join("") : digits;
+  return {
+    r: Number.parseInt(full.slice(0, 2), 16),
+    g: Number.parseInt(full.slice(2, 4), 16),
+    b: Number.parseInt(full.slice(4, 6), 16)
+  };
+}
+function rgbTo256({ r, g, b }) {
+  const level = (value) => {
+    if (value < 48)
+      return 0;
+    if (value < 115)
+      return 1;
+    return Math.min(5, Math.round((value - 35) / 40));
+  };
+  const cubeIndex = 16 + 36 * level(r) + 6 * level(g) + level(b);
+  const cubeValue = (step) => step === 0 ? 0 : 55 + step * 40;
+  const cube = { r: cubeValue(level(r)), g: cubeValue(level(g)), b: cubeValue(level(b)) };
+  const greyAverage = (r + g + b) / 3;
+  const greyStep = Math.max(0, Math.min(23, Math.round((greyAverage - 8) / 10)));
+  const greyValue = 8 + greyStep * 10;
+  const grey = { r: greyValue, g: greyValue, b: greyValue };
+  return distance({ r, g, b }, grey) < distance({ r, g, b }, cube) ? 232 + greyStep : cubeIndex;
+}
+function distance(a, b) {
+  return (a.r - b.r) ** 2 + (a.g - b.g) ** 2 + (a.b - b.b) ** 2;
+}
+function colorCode(value, depth) {
+  if (depth === "none")
+    return "";
+  const parsed = parseColor(value);
+  if (parsed === undefined)
+    return "";
+  if (typeof parsed === "number")
+    return parsed < 8 ? `\x1B[${30 + parsed}m` : `\x1B[${90 + parsed - 8}m`;
+  return depth === "truecolor" ? `\x1B[38;2;${parsed.r};${parsed.g};${parsed.b}m` : `\x1B[38;5;${rgbTo256(parsed)}m`;
+}
+function rainbowHex(t) {
+  const hue = (t % 1 + 1) % 1 * 360;
+  const c = 0.5;
+  const x = c * (1 - Math.abs(hue / 60 % 2 - 1));
+  const m = 0.6 - c / 2;
+  const [r1, g1, b1] = hue < 60 ? [c, x, 0] : hue < 120 ? [x, c, 0] : hue < 180 ? [0, c, x] : hue < 240 ? [0, x, c] : hue < 300 ? [x, 0, c] : [c, 0, x];
+  const channel = (value) => Math.round((value + m) * 255).toString(16).padStart(2, "0");
+  return `#${channel(r1)}${channel(g1)}${channel(b1)}`;
+}
+function rainbowText(text, depth, phase = 0) {
+  if (depth === "none")
+    return text;
+  const characters = [...text];
+  let out = "";
+  let open;
+  characters.forEach((character, index) => {
+    if (character === " ") {
+      if (open !== undefined) {
+        out += "\x1B[0m";
+        open = undefined;
+      }
+      out += character;
+      return;
+    }
+    const code = colorCode(rainbowHex(phase + index / 12), depth);
+    if (code !== open) {
+      out += code;
+      open = code;
+    }
+    out += character;
+  });
+  return open === undefined ? out : `${out}\x1B[0m`;
+}
+var DEFAULT_TOKENS = {
+  primary: "cyan",
+  secondary: "blue",
+  accent: "yellow",
+  bg: "black",
+  surface: "black",
+  text: "white",
+  textMuted: "brightBlack",
+  success: "green",
+  warning: "yellow",
+  error: "red",
+  border: "round",
+  borderColor: "brightBlack",
+  borderFocus: "cyan"
+};
+var TOKEN_NAMES = {
+  primary: "primary",
+  secondary: "secondary",
+  accent: "accent",
+  bg: "bg",
+  background: "bg",
+  surface: "surface",
+  text: "text",
+  fg: "text",
+  "text-muted": "textMuted",
+  muted: "textMuted",
+  success: "success",
+  warning: "warning",
+  error: "error",
+  border: "border",
+  "border-color": "borderColor",
+  "border-focus": "borderFocus",
+  highlight: "secondary"
+};
+function parseThemeSource(source) {
+  const themes = [];
+  const withoutLineComments = source.replace(/(^|\s)\/\/[^\n]*/g, "$1");
+  const blockPattern = /(?:\/\*([\s\S]*?)\*\/\s*)?@theme\s+([A-Za-z0-9_-]+)\s*\{([^}]*)\}/g;
+  for (const match of withoutLineComments.matchAll(blockPattern)) {
+    const description = (match[1] ?? "").replace(/\s+/g, " ").trim();
+    const tokens = { ...DEFAULT_TOKENS };
+    for (const declaration of match[3].matchAll(/(?:--|\$)([a-z0-9-]+)\s*:\s*([^;}]+)[;]?/gi)) {
+      const key = TOKEN_NAMES[declaration[1].toLowerCase()];
+      if (key)
+        tokens[key] = declaration[2].trim();
+    }
+    themes.push({ name: match[2], description, tokens });
+  }
+  return themes;
+}
+function builtinThemes() {
+  return Object.values(BUILTIN_THEME_SOURCES).flatMap((source) => parseThemeSource(source));
+}
+function findBuiltinTheme(name) {
+  return builtinThemes().find((theme) => theme.name.toLowerCase() === name.trim().toLowerCase());
+}
+function borderStyleOf(value) {
+  const text = value.trim().toLowerCase();
+  return text === "single" || text === "double" || text === "none" ? text : "round";
+}
+function buildPalette(theme, depth) {
+  const code = (value) => colorCode(value, depth);
+  return {
+    theme: theme.name,
+    depth,
+    primary: code(theme.tokens.primary),
+    secondary: code(theme.tokens.secondary),
+    accent: code(theme.tokens.accent),
+    text: code(theme.tokens.text),
+    muted: code(theme.tokens.textMuted),
+    success: code(theme.tokens.success),
+    warning: code(theme.tokens.warning),
+    error: code(theme.tokens.error),
+    border: code(theme.tokens.borderColor),
+    borderFocus: code(theme.tokens.borderFocus),
+    borderStyle: borderStyleOf(theme.tokens.border),
+    bg: theme.tokens.bg,
+    surface: theme.tokens.surface,
+    tokens: theme.tokens
+  };
+}
+var NO_COLOR_PALETTE = buildPalette(findBuiltinTheme(DEFAULT_THEME_NAME) ?? { name: DEFAULT_THEME_NAME, description: "", tokens: DEFAULT_TOKENS }, "none");
+
+// packages/archymedes-cli/src/glyphs.ts
+var UNICODE_GLYPHS = {
+  starGlyphs: [".", "·", "✧", "✦", "✶"],
+  spinnerFrames: ["  ◜  ", "  ◠  ", "  ◝  ", "  ◞  ", "  ◡  ", "  ◟  "],
+  star: "✦",
+  starDim: "✧",
+  check: "✓",
+  cross: "✗",
+  pending: "⋯",
+  prompt: "❯",
+  caret: "›",
+  bullet: "•",
+  ellipsis: "…",
+  middot: "·",
+  elbow: "⎿",
+  boxTopLeft: "╭",
+  boxTopRight: "╮",
+  boxBottomLeft: "╰",
+  boxBottomRight: "╯",
+  boxHorizontal: "─",
+  boxVertical: "│",
+  boxTeeLeft: "├",
+  boxTeeRight: "┤",
+  boxCross: "┼",
+  circleEmpty: "○",
+  circleHalf: "◐",
+  circleFull: "●",
+  checkbox: "☐",
+  checkboxDone: "☑",
+  paused: "⏸",
+  cancelled: "⊘",
+  treeBranch: "├─",
+  treeLast: "╰─",
+  treeTrunk: "│ ",
+  collapsed: "▸",
+  expanded: "▾",
+  arrowUp: "↑",
+  arrowLeft: "←",
+  arrowRight: "→",
+  arrowDown: "↓",
+  plus: "+",
+  minus: "-",
+  warning: "!",
+  effectWorkspace: "✎",
+  effectExternal: "◎",
+  sparkLevels: ["▁", "▂", "▃", "▄", "▅", "▆", "▇", "█"]
+};
+var ASCII_GLYPHS = {
+  starGlyphs: [".", ".", "+", "*", "*"],
+  spinnerFrames: ["-", "\\", "|", "/"],
+  star: "*",
+  starDim: "+",
+  check: "+",
+  cross: "x",
+  pending: "~",
+  prompt: ">",
+  caret: ">",
+  bullet: "-",
+  ellipsis: "...",
+  middot: "-",
+  elbow: "\\",
+  boxTopLeft: "+",
+  boxTopRight: "+",
+  boxBottomLeft: "+",
+  boxBottomRight: "+",
+  boxHorizontal: "-",
+  boxVertical: "|",
+  boxTeeLeft: "+",
+  boxTeeRight: "+",
+  boxCross: "+",
+  circleEmpty: "o",
+  circleHalf: "*",
+  circleFull: "*",
+  checkbox: "[ ]",
+  checkboxDone: "[x]",
+  paused: "=",
+  cancelled: "x",
+  treeBranch: "|-",
+  treeLast: "`-",
+  treeTrunk: "| ",
+  collapsed: ">",
+  expanded: "v",
+  arrowUp: "^",
+  arrowLeft: "<-",
+  arrowRight: "->",
+  arrowDown: "v",
+  plus: "+",
+  minus: "-",
+  warning: "!",
+  effectWorkspace: "w",
+  effectExternal: "e",
+  sparkLevels: [" ", ".", ":", "-", "=", "+", "*", "#"]
+};
+var ROUND_BORDER = { topLeft: "╭", topRight: "╮", bottomLeft: "╰", bottomRight: "╯", horizontal: "─", vertical: "│", teeLeft: "├", teeRight: "┤", cross: "┼" };
+var SINGLE_BORDER = { topLeft: "┌", topRight: "┐", bottomLeft: "└", bottomRight: "┘", horizontal: "─", vertical: "│", teeLeft: "├", teeRight: "┤", cross: "┼" };
+var DOUBLE_BORDER = { topLeft: "╔", topRight: "╗", bottomLeft: "╚", bottomRight: "╝", horizontal: "═", vertical: "║", teeLeft: "╠", teeRight: "╣", cross: "╬" };
+var ASCII_BORDER = { topLeft: "+", topRight: "+", bottomLeft: "+", bottomRight: "+", horizontal: "-", vertical: "|", teeLeft: "+", teeRight: "+", cross: "+" };
+function borderGlyphsFor(style, glyphs) {
+  if (glyphs === ASCII_GLYPHS)
+    return ASCII_BORDER;
+  if (style === "single")
+    return SINGLE_BORDER;
+  if (style === "double")
+    return DOUBLE_BORDER;
+  return ROUND_BORDER;
+}
+
+// packages/archymedes-cli/src/markdown.ts
+var RESET = "\x1B[0m";
+var BOLD = "\x1B[1m";
+var DIM = "\x1B[2m";
+var ITALIC = "\x1B[3m";
+var STRIKE = "\x1B[9m";
+var CYAN = "\x1B[36m";
+var BLUE = "\x1B[34m";
+var GREEN = "\x1B[32m";
+var YELLOW = "\x1B[33m";
+var ANSI = /\x1b\[[0-9;]*m/g;
+function visibleWidth(text) {
+  let width = 0;
+  for (const character of text.replace(ANSI, "")) {
+    const code = character.codePointAt(0) ?? 0;
+    if (code >= 768 && code <= 879)
+      continue;
+    width += isWide(code) ? 2 : 1;
+  }
+  return width;
+}
+function isWide(code) {
+  return code >= 4352 && code <= 4447 || code >= 11904 && code <= 42191 || code >= 44032 && code <= 55203 || code >= 63744 && code <= 64255 || code >= 65072 && code <= 65135 || code >= 65280 && code <= 65376 || code >= 127744 && code <= 129535;
+}
+var INLINE_PATTERN = /(?<!\\)(`[^`\n]+`)|(?<!\\)(\*\*[^*\n]+\*\*)|(?<!\\)(__[^_\n]+__)|(?<!\\)(~~[^~\n]+~~)|(?<!\\)(\*[^*\n]+\*)|(?<!\\)(_[^_\n]+_)|(!?\[([^\]\n]+)\]\((https?:\/\/[^\s)\n]+)\))|(<(https?:\/\/[^>\s]+)>)/g;
+var unescapeMarkdown = (text) => text.replace(/\\([\\`*_[\]{}()#+.!~>-])/g, "$1");
+function parseInline(line) {
+  const tokens = [];
+  let lastIndex = 0;
+  INLINE_PATTERN.lastIndex = 0;
+  for (let match = INLINE_PATTERN.exec(line);match !== null; match = INLINE_PATTERN.exec(line)) {
+    if (match.index > lastIndex)
+      tokens.push({ text: unescapeMarkdown(line.slice(lastIndex, match.index)), code: "" });
+    const [whole, code, boldStars, boldUnderscores, strike, italicStars, italicUnderscores, link, linkLabel, linkUrl, autolink, autolinkUrl] = match;
+    if (code !== undefined)
+      tokens.push({ text: code.slice(1, -1), code: CYAN });
+    else if (boldStars !== undefined)
+      tokens.push({ text: boldStars.slice(2, -2), code: BOLD });
+    else if (boldUnderscores !== undefined)
+      tokens.push({ text: boldUnderscores.slice(2, -2), code: BOLD });
+    else if (strike !== undefined)
+      tokens.push({ text: strike.slice(2, -2), code: STRIKE });
+    else if (italicStars !== undefined)
+      tokens.push({ text: italicStars.slice(1, -1), code: ITALIC });
+    else if (italicUnderscores !== undefined)
+      tokens.push({ text: italicUnderscores.slice(1, -1), code: ITALIC });
+    else if (link !== undefined)
+      tokens.push({ text: `${link.startsWith("!") ? `image: ${linkLabel}` : linkLabel} (${linkUrl})`, code: CYAN });
+    else if (autolink !== undefined)
+      tokens.push({ text: autolinkUrl, code: CYAN });
+    lastIndex = match.index + whole.length;
+  }
+  if (lastIndex < line.length)
+    tokens.push({ text: unescapeMarkdown(line.slice(lastIndex)), code: "" });
+  return tokens.filter((token) => token.text.length > 0);
+}
+function paint(text, code, depth) {
+  return depth === "none" || code === "" ? text : `${code}${text}${RESET}`;
+}
+function wrapTokens(tokens, width, options) {
+  const firstPrefix = options.firstPrefix ?? "";
+  const continuationPrefix = options.continuationPrefix ?? "";
+  const lines = [];
+  let current = "";
+  let currentWidth = 0;
+  let prefix = firstPrefix;
+  let prefixWidth = visibleWidth(firstPrefix);
+  const limit = Math.max(1, width);
+  const flush = () => {
+    lines.push(`${prefix}${current}`.replace(/[ \t]+$/, ""));
+    current = "";
+    currentWidth = 0;
+    prefix = continuationPrefix;
+    prefixWidth = visibleWidth(continuationPrefix);
+  };
+  for (const token of tokens) {
+    for (const word of token.text.split(/(\s+)/)) {
+      if (word === "")
+        continue;
+      const wordWidth = visibleWidth(word);
+      if (/^\s+$/.test(word)) {
+        if (currentWidth > 0 && prefixWidth + currentWidth + wordWidth <= limit) {
+          current += word;
+          currentWidth += wordWidth;
+        }
+        continue;
+      }
+      if (currentWidth > 0 && prefixWidth + currentWidth + wordWidth > limit)
+        flush();
+      if (prefixWidth + wordWidth > limit) {
+        let remaining = word;
+        while (remaining.length > 0) {
+          const available = Math.max(1, limit - prefixWidth - currentWidth);
+          if (visibleWidth(remaining) <= available)
+            break;
+          const head = [...remaining].slice(0, available).join("");
+          current += paint(head, token.code, options.depth);
+          remaining = [...remaining].slice(available).join("");
+          flush();
+        }
+        if (remaining.length > 0) {
+          current += paint(remaining, token.code, options.depth);
+          currentWidth += visibleWidth(remaining);
+        }
+        continue;
+      }
+      current += paint(word, token.code, options.depth);
+      currentWidth += wordWidth;
+    }
+  }
+  if (current !== "" || lines.length === 0)
+    lines.push(`${prefix}${current}`.replace(/[ \t]+$/, ""));
+  return lines;
+}
+function newMarkdownState() {
+  return { inFence: false, fenceLanguage: "" };
+}
+var HEADING = /^(#{1,6})\s+(.*)$/;
+var BULLET = /^(\s*)([-*+])\s+(.*)$/;
+var TASK = /^(\s*)[-*+]\s+\[([ xX])\]\s+(.*)$/;
+var NUMBERED = /^(\s*)(\d+[.)])\s+(.*)$/;
+var BLOCKQUOTE = /^>\s?(.*)$/;
+var RULE = /^\s*([-*_])\s*(?:\1\s*){2,}$/;
+var FENCE = /^\s*```(.*)$/;
+var TABLE_SEPARATOR_CELL = /^:?-{3,}:?$/;
+function tableCells(line) {
+  if (!line.includes("|"))
+    return null;
+  const trimmed = line.trim().replace(/^\|/, "").replace(/\|$/, "");
+  const cells = trimmed.split("|").map((cell) => cell.trim());
+  return cells.length >= 2 ? cells : null;
+}
+function fitCell(text, width, glyphs = UNICODE_GLYPHS) {
+  let result = "";
+  for (const character of text) {
+    if (visibleWidth(result + character) > width) {
+      while (visibleWidth(result) > Math.max(0, width - visibleWidth(glyphs.ellipsis)))
+        result = [...result].slice(0, -1).join("");
+      result += glyphs.ellipsis;
+      return result + " ".repeat(Math.max(0, width - visibleWidth(result)));
+    }
+    result += character;
+  }
+  return result + " ".repeat(Math.max(0, width - visibleWidth(result)));
+}
+function renderTableLine(cells, separator, width, depth, glyphs) {
+  const cellWidth = Math.max(3, Math.floor((Math.max(width, 12) - cells.length - 1) / cells.length));
+  if (separator)
+    return paint(`${glyphs.boxTeeLeft}${cells.map(() => glyphs.boxHorizontal.repeat(cellWidth)).join(glyphs.boxCross)}${glyphs.boxTeeRight}`, DIM, depth);
+  const contentWidth = Math.max(1, cellWidth - 2);
+  const rendered = cells.map((cell) => fitCell(parseInline(cell).map((token) => token.text).join(""), contentWidth, glyphs));
+  return `${glyphs.boxVertical}${rendered.map((cell) => ` ${cell} `).join(glyphs.boxVertical)}${glyphs.boxVertical}`;
+}
+function renderMarkdownLine(line, state, options) {
+  const { width, depth } = options;
+  const glyphs = options.glyphs ?? UNICODE_GLYPHS;
+  const fence = FENCE.exec(line);
+  if (fence) {
+    const ruleWidth = Math.max(4, Math.min(width - 4, 40));
+    if (state.inFence) {
+      state.inFence = false;
+      state.fenceLanguage = "";
+      return [paint(`  ${glyphs.boxBottomLeft}${glyphs.boxHorizontal.repeat(ruleWidth)}`, DIM, depth)];
+    }
+    state.inFence = true;
+    state.fenceLanguage = fence[1].trim();
+    const label = state.fenceLanguage ? ` ${state.fenceLanguage} ` : "";
+    const drawn = 1 + visibleWidth(label);
+    return [paint(`  ${glyphs.boxTopLeft}${glyphs.boxHorizontal}${label}${glyphs.boxHorizontal.repeat(Math.max(0, ruleWidth - drawn))}`, DIM, depth)];
+  }
+  if (state.inFence) {
+    return [`${paint(`  ${glyphs.boxVertical} `, DIM, depth)}${paint(line, GREEN, depth)}`];
+  }
+  const table = tableCells(line);
+  if (table) {
+    const separator = table.every((cell) => TABLE_SEPARATOR_CELL.test(cell));
+    return [renderTableLine(table, separator, width, depth, glyphs)];
+  }
+  if (RULE.test(line) && line.trim().length > 0) {
+    return [paint("  " + glyphs.boxHorizontal.repeat(Math.max(4, Math.min(width - 4, 40))), DIM, depth)];
+  }
+  const heading = HEADING.exec(line);
+  if (heading) {
+    const level = heading[1].length;
+    const code = level <= 2 ? `${BOLD}${CYAN}` : BOLD;
+    const tokens = parseInline(heading[2]).map((token) => ({ text: token.text, code }));
+    return wrapTokens(tokens, width, { depth });
+  }
+  const task = TASK.exec(line);
+  if (task) {
+    return wrapTokens(parseInline(task[3]), width, {
+      firstPrefix: `${task[1]}${paint(task[2].trim() ? glyphs.checkboxDone : glyphs.checkbox, task[2].trim() ? GREEN : BLUE, depth)} `,
+      continuationPrefix: `${task[1]}  `,
+      depth
+    });
+  }
+  const bullet = BULLET.exec(line);
+  if (bullet) {
+    const indent = bullet[1];
+    return wrapTokens(parseInline(bullet[3]), width, {
+      firstPrefix: `${indent}${paint(glyphs.bullet, BLUE, depth)} `,
+      continuationPrefix: `${indent}  `,
+      depth
+    });
+  }
+  const numbered = NUMBERED.exec(line);
+  if (numbered) {
+    const indent = numbered[1];
+    const marker = numbered[2];
+    return wrapTokens(parseInline(numbered[3]), width, {
+      firstPrefix: `${indent}${paint(marker, BLUE, depth)} `,
+      continuationPrefix: `${indent}${" ".repeat(marker.length + 1)}`,
+      depth
+    });
+  }
+  const quote = BLOCKQUOTE.exec(line);
+  if (quote) {
+    return wrapTokens([{ text: quote[1], code: DIM }], width, {
+      firstPrefix: paint(`${glyphs.boxVertical} `, YELLOW, depth),
+      continuationPrefix: paint(`${glyphs.boxVertical} `, YELLOW, depth),
+      depth
+    });
+  }
+  if (line.trim() === "")
+    return [""];
+  return wrapTokens(parseInline(line), width, { depth });
+}
+function renderMarkdown(text, options) {
+  const state = newMarkdownState();
+  const glyphs = options.glyphs ?? UNICODE_GLYPHS;
+  const rendered = text.split(`
+`).flatMap((line) => renderMarkdownLine(line, state, options));
+  if (state.inFence)
+    rendered.push(paint(`  ${glyphs.boxBottomLeft}${glyphs.boxHorizontal.repeat(4)}`, DIM, options.depth));
+  return rendered.join(`
+`);
+}
+
+export { UNICODE_GLYPHS, ASCII_GLYPHS, borderGlyphsFor, visibleWidth, newMarkdownState, renderMarkdownLine, renderMarkdown, BUILTIN_THEME_SOURCES, rgbTo256, rainbowText, parseThemeSource, NO_COLOR_PALETTE };

package/dist/{archymedes-44c1mqas.mjs → archymedes-cdgejs3p.mjs}

@@ -2,7 +2,7 @@ import {
   UNICODE_GLYPHS,
   borderGlyphsFor,
   visibleWidth
-} from "./archymedes-dwvn4c51.mjs";
+} from "./archymedes-5zn4zp84.mjs";
 
 // packages/archymedes-cli/src/ansi.ts
 var RESET = "\x1B[0m";