archymedes-cli 2.0.0

package/dist/archymedes-dwvn4c51.mjs

@@ -0,0 +1,826 @@
+import {
+  rgbTo256
+} from "./archymedes-jecyxv5c.mjs";
+
+// 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(`
+`);
+}
+
+// packages/archymedes-cli/src/output.ts
+var terminalStream = {
+  write(text) {
+    process.stdout.write(text);
+  },
+  get columns() {
+    return process.stdout.columns;
+  },
+  get rows() {
+    return process.stdout.rows;
+  }
+};
+
+// packages/archymedes-cli/src/tui.ts
+var RESET2 = "\x1B[0m";
+var DIM2 = "\x1B[2m";
+var CYAN2 = "\x1B[36m";
+var GREEN2 = "\x1B[32m";
+var YELLOW2 = "\x1B[33m";
+var RED = "\x1B[31m";
+function paint2(text, code, depth) {
+  return depth === "none" ? text : `${code}${text}${RESET2}`;
+}
+function archymedesSpinnerFrame(index, glyphs = UNICODE_GLYPHS) {
+  const frames = glyphs.spinnerFrames;
+  const normalized = Number.isFinite(index) ? Math.max(0, Math.floor(index)) : 0;
+  return frames[normalized % frames.length];
+}
+class Spring {
+  angularFrequency;
+  dampingRatio;
+  constructor(angularFrequency, dampingRatio) {
+    this.angularFrequency = angularFrequency;
+    this.dampingRatio = dampingRatio;
+  }
+  update(position, velocity, target, dt) {
+    const omega = this.angularFrequency;
+    const zeta = this.dampingRatio;
+    const f = 1 + 2 * dt * zeta * omega;
+    const oo = omega * omega;
+    const hoo = dt * oo;
+    const hhoo = dt * hoo;
+    const detInv = 1 / (f + hhoo);
+    const detX = f * position + dt * velocity + hhoo * target;
+    const detV = velocity + hoo * (target - position);
+    return [detX * detInv, detV * detInv];
+  }
+}
+
+class SpringAnimator {
+  onTick;
+  spring;
+  position;
+  velocity = 0;
+  target;
+  timer;
+  intervalMs;
+  epsilon;
+  constructor(initial, onTick, options = {}) {
+    this.onTick = onTick;
+    this.position = initial;
+    this.target = initial;
+    this.spring = new Spring(options.angularFrequency ?? 18, options.dampingRatio ?? 0.86);
+    this.intervalMs = options.intervalMs ?? 40;
+    this.epsilon = options.epsilon ?? 0.01;
+  }
+  get value() {
+    return this.position;
+  }
+  get settled() {
+    return !this.timer;
+  }
+  retarget(target) {
+    this.target = target;
+    if (Math.abs(this.target - this.position) < this.epsilon && Math.abs(this.velocity) < this.epsilon) {
+      this.position = target;
+      this.onTick(target);
+      return;
+    }
+    this.ensureRunning();
+  }
+  snapTo(target) {
+    this.stop();
+    this.position = target;
+    this.velocity = 0;
+    this.target = target;
+    this.onTick(target);
+  }
+  ensureRunning() {
+    if (this.timer)
+      return;
+    this.timer = setInterval(() => {
+      const dt = this.intervalMs / 1000;
+      const [pos, vel] = this.spring.update(this.position, this.velocity, this.target, dt);
+      this.position = pos;
+      this.velocity = vel;
+      if (Math.abs(this.target - pos) < this.epsilon && Math.abs(vel) < this.epsilon) {
+        this.position = this.target;
+        this.stop();
+        this.onTick(this.target);
+        return;
+      }
+      this.onTick(pos);
+    }, this.intervalMs);
+  }
+  stop() {
+    if (!this.timer)
+      return;
+    clearInterval(this.timer);
+    this.timer = undefined;
+  }
+}
+function formatElapsed(ms) {
+  const seconds = ms / 1000;
+  return seconds < 60 ? `${seconds.toFixed(1)}s` : `${Math.floor(seconds / 60)}m ${Math.round(seconds % 60)}s`;
+}
+function formatTokens(tokens) {
+  if (tokens < 1000)
+    return `${tokens} tokens`;
+  return `${(tokens / 1000).toFixed(1)}k tokens`;
+}
+function sparkline(values, glyphs = UNICODE_GLYPHS) {
+  const levels = glyphs.sparkLevels;
+  if (values.length === 0)
+    return "";
+  const max = Math.max(...values);
+  if (max <= 0)
+    return levels[0].repeat(values.length);
+  return values.map((value) => levels[Math.min(levels.length - 1, Math.floor(Math.max(0, value) / max * (levels.length - 1)))]).join("");
+}
+var PARTIAL_BLOCKS = ["", "▏", "▎", "▍", "▌", "▋", "▊", "▉"];
+var FULL_BLOCK = "█";
+var TRACK_BLOCK = "░";
+var DEFAULT_GRADIENT_FROM = { r: 124, g: 197, b: 255 };
+var DEFAULT_GRADIENT_TO = { r: 255, g: 207, b: 107 };
+function lerp(from, to, t) {
+  return { r: from.r + (to.r - from.r) * t, g: from.g + (to.g - from.g) * t, b: from.b + (to.b - from.b) * t };
+}
+function paintRgb(text, rgb, depth) {
+  if (depth === "none")
+    return text;
+  const r = Math.round(rgb.r);
+  const g = Math.round(rgb.g);
+  const b = Math.round(rgb.b);
+  const code = depth === "truecolor" ? `\x1B[38;2;${r};${g};${b}m` : `\x1B[38;5;${rgbTo256({ r, g, b })}m`;
+  return `${code}${text}\x1B[0m`;
+}
+function progressBar(fraction, width, options) {
+  const clamped = Math.max(0, Math.min(1, Number.isFinite(fraction) ? fraction : 0));
+  const cells = Math.max(1, Math.floor(width));
+  const from = options.from ?? DEFAULT_GRADIENT_FROM;
+  const to = options.to ?? DEFAULT_GRADIENT_TO;
+  const ascii = options.glyphs === ASCII_GLYPHS;
+  const eighths = ascii ? cells : cells * 8;
+  const filledEighths = Math.round(clamped * eighths);
+  let bar = "";
+  for (let index = 0;index < cells; index += 1) {
+    const t = cells <= 1 ? 0 : index / (cells - 1);
+    const rgb = lerp(from, to, t);
+    if (ascii) {
+      bar += index < filledEighths ? paintRgb("#", rgb, options.depth) : "-";
+      continue;
+    }
+    const cellStart = index * 8;
+    if (filledEighths >= cellStart + 8)
+      bar += paintRgb(FULL_BLOCK, rgb, options.depth);
+    else if (filledEighths > cellStart)
+      bar += paintRgb(PARTIAL_BLOCKS[filledEighths - cellStart], rgb, options.depth);
+    else
+      bar += options.depth === "none" ? TRACK_BLOCK : `\x1B[2m${TRACK_BLOCK}\x1B[0m`;
+  }
+  return bar;
+}
+function table(columns, rows, options) {
+  const glyphs = options.glyphs ?? UNICODE_GLYPHS;
+  const border = borderGlyphsFor(options.borderStyle ?? "round", glyphs);
+  const terminalWidth = Math.max(1, options.width ?? process.stdout.columns ?? 80);
+  const count = columns.length;
+  const widths = columns.map((header, index) => Math.max(visibleWidth(header), ...rows.map((row2) => visibleWidth(row2[index] ?? ""))));
+  const budget = terminalWidth - (count + 1) - count * 2;
+  while (widths.reduce((sum, width) => sum + width, 0) > Math.max(count, budget)) {
+    const widest = widths.indexOf(Math.max(...widths));
+    if (widths[widest] <= 3)
+      break;
+    widths[widest] -= 1;
+  }
+  const cell = (text, width) => {
+    const clipped = visibleWidth(text) > width ? `${sliceToWidth(text, Math.max(0, width - visibleWidth(glyphs.ellipsis)))}${glyphs.ellipsis}` : text;
+    return `${clipped}${" ".repeat(Math.max(0, width - visibleWidth(clipped)))}`;
+  };
+  const rule = (left, mid, right) => `${left}${widths.map((width) => border.horizontal.repeat(width + 2)).join(mid)}${right}`;
+  const row = (cells) => `${border.vertical} ${widths.map((width, index) => cell(cells[index] ?? "", width)).join(` ${border.vertical} `)} ${border.vertical}`;
+  return [
+    rule(border.topLeft, border.horizontal, border.topRight),
+    row(columns.map((header) => paint2(header, DIM2, options.depth))),
+    rule(border.teeLeft, border.cross, border.teeRight),
+    ...rows.map((line) => row(line)),
+    rule(border.bottomLeft, border.horizontal, border.bottomRight)
+  ].join(`
+`);
+}
+function scrollPercent(offsetFromTop, contentLines, viewportHeight) {
+  const maxOffset = Math.max(0, contentLines - viewportHeight);
+  if (maxOffset === 0)
+    return 1;
+  return Math.max(0, Math.min(1, offsetFromTop / maxOffset));
+}
+function scrollIndicator(fraction) {
+  if (fraction >= 1)
+    return "Bot";
+  if (fraction <= 0)
+    return "Top";
+  return `${Math.round(fraction * 100)}%`;
+}
+function paginator(current, total, options = {}) {
+  const count = Math.max(1, Math.floor(total));
+  const index = Math.max(0, Math.min(Math.floor(current), count - 1));
+  if (options.style === "dots") {
+    const glyphs = options.glyphs ?? UNICODE_GLYPHS;
+    return Array.from({ length: count }, (_, position) => position === index ? glyphs.bullet : glyphs.middot).join(" ");
+  }
+  return `${index + 1}/${count}`;
+}
+var VERBS = ["Thinking", "Reasoning", "Tracing", "Considering"];
+function thinkingVerb(elapsedMs) {
+  return VERBS[Math.floor(Math.max(0, elapsedMs) / 6000) % VERBS.length];
+}
+function activityLabel(phase, operation, elapsedMs) {
+  if (phase === "thinking")
+    return thinkingVerb(elapsedMs);
+  switch (operation) {
+    case "read_file":
+      return "Reading file";
+    case "list_files":
+    case "glob_files":
+    case "grep_files":
+      return "Searching workspace";
+    case "write_file":
+    case "edit_file":
+      return "Editing workspace";
+    case "run_command":
+      return "Running command";
+    case "web_search":
+      return "Searching the web";
+    case "deep_research":
+      return "Researching in depth";
+    case "todo_write":
+      return "Updating plan";
+    default:
+      return "Running operation";
+  }
+}
+function stepProgress(done, total, options) {
+  const safeTotal = Math.max(0, Math.floor(Number.isFinite(total) ? total : 0));
+  const safeDone = Math.max(0, Math.min(safeTotal, Math.floor(Number.isFinite(done) ? done : 0)));
+  const counted = `${safeDone}/${safeTotal}`;
+  const label = options.label ? `${options.label} ` : "";
+  if (safeTotal === 0)
+    return `${label}${counted}`;
+  const width = Math.floor(options.width ?? 0);
+  if (width <= 0)
+    return `${label}${counted}`;
+  const bar = progressBar(safeDone / safeTotal, width, {
+    depth: options.depth,
+    glyphs: options.glyphs ?? UNICODE_GLYPHS,
+    ...options.from ? { from: options.from } : {},
+    ...options.to ? { to: options.to } : {}
+  });
+  return `${label}${counted} ${bar}`;
+}
+function formatStatusLine(fields, width, depth, glyphs = UNICODE_GLYPHS, accent = CYAN2) {
+  const label = activityLabel(fields.phase ?? "thinking", fields.operation, fields.elapsedMs);
+  const ellipsis = glyphs.ellipsis;
+  const separator = ` ${glyphs.middot} `;
+  const left = `${fields.spinnerGlyph} ${label}${ellipsis}`;
+  const paintedLeft = `${paint2(fields.spinnerGlyph, accent, depth)} ${paint2(`${label}${ellipsis}`, DIM2, depth)}`;
+  const optional = [
+    fields.cost,
+    fields.tokens > 0 ? formatTokens(fields.tokens) : "",
+    fields.toolCalls > 0 ? `${fields.toolCalls} tool${fields.toolCalls === 1 ? "" : "s"}` : "",
+    fields.badge ?? "",
+    fields.steps && fields.steps.total > 0 ? stepProgress(fields.steps.done, fields.steps.total, { label: fields.steps.label ?? "steps", depth: "none" }) : "",
+    fields.mode,
+    fields.balance ?? ""
+  ].filter((segment) => segment !== "");
+  let kept = [...optional].reverse();
+  for (;; ) {
+    const right = [...kept, formatElapsed(fields.elapsedMs)].join(`${separator}`);
+    const total = visibleWidth(left) + 1 + right.length;
+    if (total <= width || kept.length === 0) {
+      if (total > width) {
+        if (visibleWidth(left) <= width)
+          return paintedLeft;
+        const compact = `${fields.spinnerGlyph} ${ellipsis}`;
+        if (visibleWidth(compact) <= width)
+          return `${paint2(fields.spinnerGlyph, accent, depth)} ${paint2(ellipsis, DIM2, depth)}`;
+        return width > 0 ? paint2(glyphs.star, accent, depth) : "";
+      }
+      const gap = Math.max(1, width - visibleWidth(left) - right.length);
+      return `${paintedLeft}${" ".repeat(gap)}${paint2(right, DIM2, depth)}`;
+    }
+    kept = kept.slice(0, -1);
+  }
+}
+function rowsOccupied(text, columns) {
+  const width = visibleWidth(text);
+  if (width === 0)
+    return 1;
+  return Math.ceil(width / Math.max(1, columns));
+}
+class MarkdownStream {
+  stream;
+  depth;
+  columns;
+  live;
+  glyphs;
+  pending = "";
+  atLineStart = true;
+  state = newMarkdownState();
+  constructor(stream = terminalStream, depth = "none", columns = () => process.stdout.columns ?? 80, live = true, glyphs = UNICODE_GLYPHS) {
+    this.stream = stream;
+    this.depth = depth;
+    this.columns = columns;
+    this.live = live;
+    this.glyphs = glyphs;
+  }
+  get active() {
+    return this.live ? this.pending !== "" : !this.atLineStart;
+  }
+  push(text) {
+    if (!this.live) {
+      if (text === "")
+        return;
+      this.stream.write(text);
+      this.atLineStart = text.endsWith(`
+`);
+      return;
+    }
+    const parts = text.split(`
+`);
+    for (let index = 0;index < parts.length; index += 1) {
+      if (index > 0)
+        this.finalizeLine();
+      if (parts[index] !== "") {
+        this.pending += parts[index];
+        this.stream.write(parts[index]);
+      }
+    }
+  }
+  end() {
+    if (!this.live) {
+      if (!this.atLineStart) {
+        this.stream.write(`
+`);
+        this.atLineStart = true;
+      }
+      return;
+    }
+    if (this.pending !== "")
+      this.finalizeLine();
+    if (this.state.inFence) {
+      const rendered = renderMarkdownLine("```", this.state, { width: this.columns(), depth: this.depth, glyphs: this.glyphs });
+      this.stream.write(`${rendered.join(`
+`)}
+`);
+    }
+  }
+  reset() {
+    this.pending = "";
+    this.atLineStart = true;
+    this.state = newMarkdownState();
+  }
+  finalizeLine() {
+    this.erasePending();
+    const rendered = renderMarkdownLine(this.pending, this.state, { width: this.columns(), depth: this.depth, glyphs: this.glyphs });
+    this.stream.write(`${rendered.join(`
+`)}
+`);
+    this.pending = "";
+  }
+  erasePending() {
+    if (this.pending === "")
+      return;
+    const rows = rowsOccupied(this.pending, this.columns());
+    this.stream.write("\r\x1B[2K");
+    for (let index = 1;index < rows; index += 1)
+      this.stream.write("\x1B[1A\x1B[2K");
+  }
+}
+function box(lines, options) {
+  const terminalWidth = options.width ?? process.stdout.columns ?? 80;
+  const glyphs = options.glyphs ?? UNICODE_GLYPHS;
+  const border = borderGlyphsFor(options.borderStyle ?? "round", glyphs);
+  const titleWidth = options.title ? visibleWidth(options.title) : 0;
+  const titlePaint = TONE_CODES[options.titleColor ?? "cyan"];
+  const edge = (text) => options.borderColor === undefined ? text : paint2(text, TONE_CODES[options.borderColor], options.depth);
+  const contentWidth = Math.min(Math.max(titleWidth, ...lines.map((line) => visibleWidth(line)), 1), Math.max(1, terminalWidth - 4));
+  const horizontal = border.horizontal.repeat(contentWidth + 2);
+  const top = options.title ? `${edge(`${border.topLeft}${border.horizontal}`)} ${paint2(options.title, titlePaint, options.depth)} ${edge(`${border.horizontal.repeat(Math.max(0, contentWidth - titleWidth - 1))}${border.topRight}`)}` : edge(`${border.topLeft}${horizontal}${border.topRight}`);
+  const bottom = edge(`${border.bottomLeft}${horizontal}${border.bottomRight}`);
+  const body = lines.map((line) => {
+    const clipped = visibleWidth(line) > contentWidth ? `${sliceToWidth(line, contentWidth - visibleWidth(glyphs.ellipsis))}${glyphs.ellipsis}` : line;
+    return `${edge(border.vertical)} ${clipped}${" ".repeat(Math.max(0, contentWidth - visibleWidth(clipped)))} ${edge(border.vertical)}`;
+  });
+  return [top, ...body, bottom].join(`
+`);
+}
+function sliceToWidth(text, width) {
+  let taken = "";
+  let used = 0;
+  for (const token of text.match(/\x1b\[[0-9;]*m|[\s\S]/gu) ?? []) {
+    if (token.startsWith("\x1B")) {
+      taken += token;
+      continue;
+    }
+    const next = visibleWidth(token);
+    if (used + next > width)
+      break;
+    taken += token;
+    used += next;
+  }
+  return taken;
+}
+function padToWidth(text, width, align = "left") {
+  const size = visibleWidth(text);
+  if (size >= width)
+    return sliceToWidth(text, width);
+  const slack = width - size;
+  if (align === "right")
+    return " ".repeat(slack) + text;
+  if (align === "center")
+    return " ".repeat(Math.floor(slack / 2)) + text + " ".repeat(Math.ceil(slack / 2));
+  return text + " ".repeat(slack);
+}
+function joinHorizontal(left, right, options) {
+  const separator = options.separator ?? " ";
+  return `${padToWidth(left, options.leftWidth, options.leftAlign)}${separator}${padToWidth(right, options.rightWidth, options.rightAlign)}`;
+}
+var TONE_CODES = { cyan: CYAN2, green: GREEN2, yellow: YELLOW2, red: RED };
+var MODE_COLORS = { plan: YELLOW2, auto: GREEN2, build: CYAN2, defender: RED };
+var PROMPT_CHROME_COLUMNS = 6;
+function renderPromptBox(options) {
+  const { mode, workspace, depth } = options;
+  const glyphs = options.glyphs ?? UNICODE_GLYPHS;
+  const border = borderGlyphsFor(options.palette?.borderStyle ?? options.borderStyle ?? "round", glyphs);
+  const width = Math.max(12, options.width);
+  const primary = options.palette?.primary ?? CYAN2;
+  const modeColor = options.palette ? { plan: options.palette.warning, auto: options.palette.success, build: primary, defender: options.palette.error }[mode] ?? primary : MODE_COLORS[mode] ?? CYAN2;
+  const horizontal = (count) => paint2(border.horizontal.repeat(Math.max(0, count)), primary, depth);
+  const CHROME = PROMPT_CHROME_COLUMNS;
+  const status = options.status ?? "";
+  const separator = ` ${glyphs.middot} `;
+  const full = `${paint2(glyphs.star, primary, depth)} ${paint2("archymedes", primary, depth)}${separator}${paint2(mode, modeColor, depth)}`;
+  const compact = `${paint2(glyphs.star, primary, depth)} ${paint2(mode, modeColor, depth)}`;
+  const statusRoom = status === "" ? 0 : visibleWidth(status) + 2;
+  const showStatus = status !== "" && width - CHROME - 1 - statusRoom - visibleWidth(compact) >= 0;
+  const room = width - CHROME - 1 - (showStatus ? statusRoom : 0);
+  const workspaceRoom = room - visibleWidth(full) - visibleWidth(separator);
+  let title;
+  if (workspaceRoom >= 4) {
+    const shown = visibleWidth(workspace) <= workspaceRoom ? workspace : `${sliceToWidth(workspace, Math.max(0, workspaceRoom - visibleWidth(glyphs.ellipsis)))}${glyphs.ellipsis}`;
+    title = `${full}${separator}${paint2(shown, DIM2, depth)}`;
+  } else if (visibleWidth(full) <= room)
+    title = full;
+  else if (visibleWidth(compact) <= room)
+    title = compact;
+  else
+    title = paint2(glyphs.star, primary, depth);
+  const tail = showStatus ? ` ${status} ` : "";
+  const filler = Math.max(1, width - visibleWidth(title) - visibleWidth(tail) - CHROME);
+  const top = `${paint2(`${border.topLeft}${border.horizontal}`, primary, depth)} ${title} ${horizontal(filler)}${tail}${horizontal(1)}${paint2(border.topRight, primary, depth)}`;
+  const prefix = `${paint2(border.vertical, primary, depth)} ${paint2(glyphs.caret, modeColor, depth)} `;
+  const bottom = `${paint2(border.bottomLeft, primary, depth)}${horizontal(width - 2)}${paint2(border.bottomRight, primary, depth)}`;
+  return { top, prefix, bottom };
+}
+
+export { UNICODE_GLYPHS, ASCII_GLYPHS, borderGlyphsFor, visibleWidth, newMarkdownState, renderMarkdownLine, renderMarkdown, terminalStream, archymedesSpinnerFrame, SpringAnimator, sparkline, progressBar, table, scrollPercent, scrollIndicator, paginator, stepProgress, formatStatusLine, rowsOccupied, box, sliceToWidth, padToWidth, joinHorizontal, renderPromptBox };