archymedes-cli 2.0.0

package/dist/archymedes-1g1y6q74.mjs

@@ -0,0 +1,86 @@
+// packages/core/src/sandbox-policy.ts
+var ALLOWED_SANDBOX_PROGRAMS = [
+  "bun",
+  "npm",
+  "git",
+  "node",
+  "python",
+  "python3",
+  "pytest",
+  "uv",
+  "cargo",
+  "go",
+  "rg",
+  "ls",
+  "pwd",
+  "find"
+];
+var BASE_TEMPLATE_PROGRAMS = ["npm", "git", "node", "python", "python3", "ls", "pwd", "find"];
+function availableSandboxPrograms(templatePrograms) {
+  const present = new Set(templatePrograms ?? BASE_TEMPLATE_PROGRAMS);
+  return ALLOWED_SANDBOX_PROGRAMS.filter((program) => present.has(program));
+}
+var allowedPrograms = new Set(ALLOWED_SANDBOX_PROGRAMS);
+var blockedArguments = new Set([
+  "-c",
+  "--config-env",
+  "--exec",
+  "--exec-path",
+  "--pre",
+  "--pre-glob",
+  "--upload-pack",
+  "-delete",
+  "-exec",
+  "-execdir",
+  "-ok",
+  "-okdir"
+]);
+var ALLOWED_GIT_SUBCOMMANDS = ["diff", "log", "rev-parse", "show", "status"];
+var SCRIPT_RUNNER_SUBCOMMANDS = ["test", "run"];
+var INLINE_EVAL_FLAGS = ["-e", "--eval", "-p", "--print", "-c"];
+var INLINE_EVAL_PROGRAMS = ["node", "python", "python3"];
+var allowedGitSubcommands = new Set(ALLOWED_GIT_SUBCOMMANDS);
+function assertWorkspacePath(path, label) {
+  if (path !== "/workspace" && !path.startsWith("/workspace/") || path.split("/").includes("..")) {
+    throw new Error(`${label} must stay inside /workspace`);
+  }
+}
+function validateSandboxCommand(command) {
+  if (!allowedPrograms.has(command.program))
+    throw new Error(`Program is not allowed in coding sandboxes: ${command.program}`);
+  if (!Number.isInteger(command.timeoutMs) || command.timeoutMs < 1 || command.timeoutMs > 15 * 60000) {
+    throw new Error("Command timeout must be between 1ms and 15 minutes");
+  }
+  if (command.args.length > 64 || command.args.some((argument) => argument.length > 4096)) {
+    throw new Error("Command arguments exceed the sandbox policy");
+  }
+  if (command.cwd)
+    assertWorkspacePath(command.cwd, "cwd");
+  if (command.args.some((argument) => blockedArguments.has(argument))) {
+    throw new Error("Command contains an argument blocked by the sandbox policy");
+  }
+  if (command.args.some((argument) => argument.startsWith("/") && argument !== "/workspace" && !argument.startsWith("/workspace/"))) {
+    throw new Error("Absolute command arguments must stay inside /workspace");
+  }
+  if (INLINE_EVAL_PROGRAMS.includes(command.program) && command.args.some((argument) => INLINE_EVAL_FLAGS.includes(argument))) {
+    throw new Error("Inline program evaluation is blocked");
+  }
+  if (command.program === "git") {
+    const subcommand = command.args.find((argument) => !argument.startsWith("-"));
+    if (!subcommand || !allowedGitSubcommands.has(subcommand))
+      throw new Error("Git command is not read-only");
+  }
+  if (command.program === "bun" && command.args[0] && !SCRIPT_RUNNER_SUBCOMMANDS.includes(command.args[0])) {
+    throw new Error("Bun command must run a declared script or test");
+  }
+  if (command.program === "npm" && command.args[0] && !SCRIPT_RUNNER_SUBCOMMANDS.includes(command.args[0])) {
+    throw new Error("npm command must run a declared script or test");
+  }
+}
+function validateWorkspaceFile(path, content) {
+  assertWorkspacePath(path, "File path");
+  if (new TextEncoder().encode(content).byteLength > 1e6)
+    throw new Error("Sandbox file exceeds the 1MB limit");
+}
+
+export { ALLOWED_SANDBOX_PROGRAMS, availableSandboxPrograms, ALLOWED_GIT_SUBCOMMANDS, SCRIPT_RUNNER_SUBCOMMANDS, INLINE_EVAL_FLAGS, INLINE_EVAL_PROGRAMS, validateSandboxCommand, validateWorkspaceFile };

package/dist/archymedes-2tp22t9a.mjs

@@ -0,0 +1,254 @@
+import {
+  ASCII_GLYPHS,
+  UNICODE_GLYPHS,
+  padToWidth,
+  progressBar,
+  sliceToWidth,
+  visibleWidth
+} from "./archymedes-dwvn4c51.mjs";
+
+// packages/archymedes-cli/src/canvas.ts
+var BRAILLE_DOTS = [
+  [1, 2, 4, 64],
+  [8, 16, 32, 128]
+];
+var BRAILLE_BLANK = 10240;
+
+class BrailleCanvas {
+  columns;
+  rows;
+  cellColumns;
+  cellRows;
+  bits;
+  ascii;
+  constructor(options) {
+    this.ascii = (options.glyphs ?? UNICODE_GLYPHS) === ASCII_GLYPHS;
+    this.columns = Math.max(1, Math.floor(options.columns));
+    this.rows = Math.max(1, Math.floor(options.rows));
+    this.cellColumns = this.ascii ? 1 : 2;
+    this.cellRows = this.ascii ? 1 : 4;
+    this.bits = Array.from({ length: this.rows }, () => new Array(this.columns).fill(0));
+  }
+  get width() {
+    return this.columns * this.cellColumns;
+  }
+  get height() {
+    return this.rows * this.cellRows;
+  }
+  set(x, y) {
+    const dotX = Math.round(x);
+    const dotY = Math.round(y);
+    if (!Number.isFinite(dotX) || !Number.isFinite(dotY))
+      return;
+    if (dotX < 0 || dotY < 0 || dotX >= this.width || dotY >= this.height)
+      return;
+    const cellX = Math.floor(dotX / this.cellColumns);
+    const cellY = Math.floor(dotY / this.cellRows);
+    if (this.ascii)
+      this.bits[cellY][cellX] = 1;
+    else
+      this.bits[cellY][cellX] |= BRAILLE_DOTS[dotX % this.cellColumns][dotY % this.cellRows];
+  }
+  line(x0, y0, x1, y1) {
+    let x = Math.round(x0);
+    let y = Math.round(y0);
+    const endX = Math.round(x1);
+    const endY = Math.round(y1);
+    if (![x, y, endX, endY].every(Number.isFinite))
+      return;
+    const deltaX = Math.abs(endX - x);
+    const deltaY = -Math.abs(endY - y);
+    const stepX = x < endX ? 1 : -1;
+    const stepY = y < endY ? 1 : -1;
+    let error = deltaX + deltaY;
+    for (let guard = 0;guard <= this.width + this.height; guard += 1) {
+      this.set(x, y);
+      if (x === endX && y === endY)
+        return;
+      const doubled = 2 * error;
+      if (doubled >= deltaY) {
+        error += deltaY;
+        x += stepX;
+      }
+      if (doubled <= deltaX) {
+        error += deltaX;
+        y += stepY;
+      }
+    }
+  }
+  render() {
+    return this.bits.map((row) => row.map((bits) => this.ascii ? bits ? "*" : " " : String.fromCharCode(BRAILLE_BLANK + bits)).join(""));
+  }
+}
+function dotRowFor(value, low, span, dotRows) {
+  const normalized = (value - low) / (span === 0 ? 1 : span);
+  return Math.min(dotRows - 1, Math.max(0, Math.round((1 - normalized) * (dotRows - 1))));
+}
+function seriesBounds(values) {
+  const finite = values.filter((value) => Number.isFinite(value));
+  if (finite.length === 0)
+    return { low: 0, high: 0, span: 1 };
+  const low = Math.min(...finite);
+  const high = Math.max(...finite);
+  return { low, high, span: high - low === 0 ? 1 : high - low };
+}
+
+// packages/archymedes-cli/src/charts.ts
+function barChart(data, options) {
+  if (data.length === 0)
+    return [];
+  const glyphs = options.glyphs ?? UNICODE_GLYPHS;
+  const format = options.format ?? ((value) => `${Math.round(value)}`);
+  const width = Math.max(20, Math.floor(options.width));
+  const labels = data.map((datum) => datum.label);
+  const values = data.map((datum) => format(datum.value));
+  const labelWidth = Math.min(Math.max(...labels.map(visibleWidth)), Math.floor(width * 0.35));
+  const valueWidth = Math.min(Math.max(...values.map(visibleWidth)), Math.floor(width * 0.2));
+  const barWidth = Math.max(1, width - labelWidth - valueWidth - 2);
+  const ceiling = options.max ?? Math.max(...data.map((datum) => datum.value));
+  return data.map((datum, index) => {
+    const fraction = ceiling > 0 ? datum.value / ceiling : 0;
+    const bar = progressBar(fraction, barWidth, {
+      depth: options.depth,
+      glyphs,
+      ...options.from === undefined ? {} : { from: options.from },
+      ...options.to === undefined ? {} : { to: options.to }
+    });
+    return `${padToWidth(sliceToWidth(labels[index], labelWidth), labelWidth)} ${bar} ${padToWidth(values[index], valueWidth, "right")}`;
+  });
+}
+function lineChart(values, options) {
+  return plotSeries([{ values }], options);
+}
+function plotSeries(series, options) {
+  const glyphs = options.glyphs ?? UNICODE_GLYPHS;
+  const height = Math.max(1, Math.floor(options.height));
+  const format = options.format ?? ((value) => `${Math.round(value)}`);
+  const all = series.flatMap((entry) => entry.values.filter((value) => Number.isFinite(value)));
+  if (all.length === 0)
+    return Array.from({ length: height }, () => "");
+  const { low, high, span } = seriesBounds(all);
+  const gutter = options.bare ? 0 : Math.max(visibleWidth(format(high)), visibleWidth(format(low))) + 1;
+  const plotWidth = Math.max(1, Math.floor(options.width) - gutter);
+  const canvas = new BrailleCanvas({ columns: plotWidth, rows: height, glyphs });
+  for (const entry of series) {
+    const finite = entry.values.filter((value) => Number.isFinite(value));
+    if (finite.length === 0)
+      continue;
+    let previous;
+    for (let x = 0;x < canvas.width; x += 1) {
+      const position = canvas.width === 1 ? 0 : x / (canvas.width - 1) * (finite.length - 1);
+      const left = Math.floor(position);
+      const right = Math.min(finite.length - 1, left + 1);
+      const value = finite[left] + (finite[right] - finite[left]) * (position - left);
+      const y = dotRowFor(value, low, span, canvas.height);
+      if (previous)
+        canvas.line(previous.x, previous.y, x, y);
+      else
+        canvas.set(x, y);
+      previous = { x, y };
+    }
+  }
+  return canvas.render().map((drawn, index) => {
+    if (options.bare)
+      return drawn;
+    const label = index === 0 ? format(high) : index === height - 1 ? format(low) : "";
+    return `${padToWidth(label, gutter - 1)} ${drawn}`;
+  });
+}
+function scatterChart(points, options) {
+  const glyphs = options.glyphs ?? UNICODE_GLYPHS;
+  const height = Math.max(1, Math.floor(options.height));
+  const format = options.format ?? ((value) => `${Math.round(value)}`);
+  const finite = points.filter((point) => Number.isFinite(point.x) && Number.isFinite(point.y));
+  if (finite.length === 0)
+    return Array.from({ length: height }, () => "");
+  const vertical = seriesBounds(finite.map((point) => point.y));
+  const horizontal = seriesBounds(finite.map((point) => point.x));
+  const gutter = options.bare ? 0 : Math.max(visibleWidth(format(vertical.high)), visibleWidth(format(vertical.low))) + 1;
+  const plotWidth = Math.max(1, Math.floor(options.width) - gutter);
+  const canvas = new BrailleCanvas({ columns: plotWidth, rows: height, glyphs });
+  for (const point of finite) {
+    const x = Math.round((point.x - horizontal.low) / horizontal.span * (canvas.width - 1));
+    canvas.set(x, dotRowFor(point.y, vertical.low, vertical.span, canvas.height));
+  }
+  return canvas.render().map((drawn, index) => {
+    if (options.bare)
+      return drawn;
+    const label = index === 0 ? format(vertical.high) : index === height - 1 ? format(vertical.low) : "";
+    return `${padToWidth(label, gutter - 1)} ${drawn}`;
+  });
+}
+function waveLine(values, options) {
+  const glyphs = options.glyphs ?? UNICODE_GLYPHS;
+  const width = Math.max(1, Math.floor(options.width));
+  const finite = values.filter((value) => Number.isFinite(value));
+  if (finite.length === 0)
+    return "";
+  const { low, span } = seriesBounds(finite);
+  const ascii = glyphs === ASCII_GLYPHS;
+  const level = ascii ? ["_", "-", "^"] : ["▁", "─", "▔"];
+  const rising = ascii ? "/" : "╱";
+  const falling = ascii ? "\\" : "╲";
+  const sampled = Array.from({ length: width }, (_, column) => {
+    const position = width === 1 ? 0 : column / (width - 1) * (finite.length - 1);
+    const left = Math.floor(position);
+    const right = Math.min(finite.length - 1, left + 1);
+    return finite[left] + (finite[right] - finite[left]) * (position - left);
+  });
+  const bandOf = (value) => Math.min(2, Math.max(0, Math.round((value - low) / span * 2)));
+  return sampled.map((value, column) => {
+    const band = bandOf(value);
+    if (column === 0)
+      return level[band];
+    const previous = bandOf(sampled[column - 1]);
+    if (band > previous)
+      return rising;
+    if (band < previous)
+      return falling;
+    return level[band];
+  }).join("");
+}
+
+class StreamSeries {
+  capacity;
+  samples = [];
+  constructor(capacity) {
+    this.capacity = capacity;
+    if (!Number.isInteger(capacity) || capacity < 1)
+      throw new Error("A stream needs room for at least one sample");
+  }
+  push(value) {
+    if (!Number.isFinite(value))
+      return;
+    this.samples.push(value);
+    if (this.samples.length > this.capacity)
+      this.samples.splice(0, this.samples.length - this.capacity);
+  }
+  values() {
+    return [...this.samples];
+  }
+  get length() {
+    return this.samples.length;
+  }
+  clear() {
+    this.samples.length = 0;
+  }
+}
+function heatStrip(data, options) {
+  if (data.length === 0)
+    return [];
+  const glyphs = options.glyphs ?? UNICODE_GLYPHS;
+  const levels = glyphs.sparkLevels;
+  const width = Math.max(10, Math.floor(options.width));
+  const labelWidth = Math.min(Math.max(...data.map((datum) => visibleWidth(datum.label))), Math.floor(width * 0.4));
+  const cells = Math.max(1, width - labelWidth - 1);
+  const ceiling = options.max ?? Math.max(...data.map((datum) => datum.value));
+  return data.map((datum) => {
+    const fraction = ceiling > 0 ? Math.max(0, Math.min(1, datum.value / ceiling)) : 0;
+    const level = levels[Math.min(levels.length - 1, Math.floor(fraction * levels.length))];
+    return `${padToWidth(sliceToWidth(datum.label, labelWidth), labelWidth)} ${level.repeat(cells)}`;
+  });
+}
+
+export { BrailleCanvas, dotRowFor, seriesBounds, barChart, lineChart, plotSeries, scatterChart, waveLine, StreamSeries, heatStrip };

package/dist/archymedes-44c1mqas.mjs

@@ -0,0 +1,171 @@
+import {
+  UNICODE_GLYPHS,
+  borderGlyphsFor,
+  visibleWidth
+} from "./archymedes-dwvn4c51.mjs";
+
+// packages/archymedes-cli/src/ansi.ts
+var RESET = "\x1B[0m";
+var BOLD = "\x1B[1m";
+var DIM = "\x1B[2m";
+var REVERSE = "\x1B[7m";
+var RED = "\x1B[31m";
+var GREEN = "\x1B[32m";
+var YELLOW = "\x1B[33m";
+var MAGENTA = "\x1B[35m";
+var CYAN = "\x1B[36m";
+function paint(text, code, depth) {
+  return depth === "none" || code === "" ? text : `${code}${text}${RESET}`;
+}
+function paintAll(text, codes, depth) {
+  return depth === "none" || codes.length === 0 ? text : `${codes.join("")}${text}${RESET}`;
+}
+
+// packages/archymedes-cli/src/sections.ts
+var FALLBACK_TONE_CODE = {
+  neutral: DIM,
+  good: GREEN,
+  bad: RED,
+  warn: YELLOW,
+  accent: CYAN
+};
+function toneCode(tone, style) {
+  if (style.depth === "none")
+    return "";
+  const palette = style.palette;
+  if (!palette)
+    return FALLBACK_TONE_CODE[tone];
+  switch (tone) {
+    case "neutral":
+      return DIM;
+    case "good":
+      return palette.success || FALLBACK_TONE_CODE.good;
+    case "bad":
+      return palette.error || FALLBACK_TONE_CODE.bad;
+    case "warn":
+      return palette.warning || FALLBACK_TONE_CODE.warn;
+    case "accent":
+      return palette.primary || FALLBACK_TONE_CODE.accent;
+  }
+}
+var GUTTER = "  ";
+function setOf(style) {
+  return style.glyphs ?? UNICODE_GLYPHS;
+}
+function rule(style, options = {}) {
+  const glyphs = setOf(style);
+  const tone = options.tone ?? "neutral";
+  const width = Math.max(4, style.width - GUTTER.length);
+  const trailing = options.trailing ? clip(` ${options.trailing}`, Math.max(4, Math.floor(width / 2)), glyphs) : "";
+  const trailingWidth = visibleWidth(trailing);
+  if (!options.label) {
+    const bare = Math.max(0, width - trailingWidth);
+    return `${GUTTER}${paint(glyphs.boxHorizontal.repeat(bare), DIM, style.depth)}${trailing ? paint(trailing, DIM, style.depth) : ""}`;
+  }
+  const lead = glyphs.boxHorizontal.repeat(2);
+  const label = clip(` ${options.label} `, Math.max(0, width - visibleWidth(lead) - trailingWidth), glyphs);
+  const used = visibleWidth(lead) + visibleWidth(label) + trailingWidth;
+  const fill = Math.max(0, width - used);
+  return [
+    GUTTER,
+    paint(lead, DIM, style.depth),
+    label ? paintAll(label, [toneCode(tone, style), BOLD], style.depth) : "",
+    paint(glyphs.boxHorizontal.repeat(fill), DIM, style.depth),
+    trailing ? paint(trailing, DIM, style.depth) : ""
+  ].join("");
+}
+function heading(text, level, style, tone = "accent") {
+  if (level === 1) {
+    return [
+      `${GUTTER}${paintAll(text, [toneCode(tone, style), BOLD], style.depth)}`,
+      rule(style, { tone })
+    ].join(`
+`);
+  }
+  if (level === 2)
+    return `${GUTTER}${paintAll(text, [toneCode(tone, style), BOLD], style.depth)}`;
+  return `${GUTTER}${paint(text, DIM, style.depth)}`;
+}
+function note(text, style, tone = "neutral") {
+  return `${GUTTER}${GUTTER}${paint(text, toneCode(tone, style), style.depth)}`;
+}
+function panel(lines, style, options = {}) {
+  const glyphs = setOf(style);
+  const depth = style.depth;
+  const tone = options.tone ?? "neutral";
+  const available = Math.max(8, style.width - GUTTER.length - 4);
+  const border = borderGlyphsFor(style.palette?.borderStyle ?? "round", glyphs);
+  if (options.gutterOnly) {
+    const edge2 = paint(border.vertical, toneCode(tone, style), depth);
+    const head = options.title ? [`${GUTTER}${paintAll(options.title, [toneCode(tone, style), BOLD], depth)}${options.badge ? paint(`  ${options.badge}`, DIM, depth) : ""}`] : [];
+    return [...head, ...lines.map((line) => `${GUTTER}${edge2} ${clip(line, available, glyphs)}`)].join(`
+`);
+  }
+  const horizontal = border.horizontal;
+  const titleCell = options.title ? ` ${options.title} ` : "";
+  const badgeCell = options.badge ? ` ${options.badge} ` : "";
+  const contentWidth = Math.min(Math.max(visibleWidth(titleCell) + visibleWidth(badgeCell) - 1, ...lines.map((line) => visibleWidth(line)), 8), available);
+  const titleShown = titleCell ? clip(titleCell, Math.max(0, contentWidth + 1 - visibleWidth(badgeCell)), glyphs) : "";
+  const fill = Math.max(0, contentWidth + 1 - visibleWidth(titleShown) - visibleWidth(badgeCell));
+  const top = [
+    GUTTER,
+    paint(border.topLeft + horizontal, DIM, depth),
+    titleShown ? paintAll(titleShown, [toneCode(tone, style), BOLD], depth) : "",
+    paint(horizontal.repeat(fill), DIM, depth),
+    badgeCell ? paint(badgeCell, DIM, depth) : "",
+    paint(border.topRight, DIM, depth)
+  ].join("");
+  const bottom = `${GUTTER}${paint(border.bottomLeft + horizontal.repeat(contentWidth + 2) + border.bottomRight, DIM, depth)}`;
+  const edge = paint(border.vertical, DIM, depth);
+  const body = lines.map((line) => {
+    const clipped = clip(line, contentWidth, glyphs);
+    return `${GUTTER}${edge} ${clipped}${" ".repeat(Math.max(0, contentWidth - visibleWidth(clipped)))} ${edge}`;
+  });
+  return [top, ...body, bottom].join(`
+`);
+}
+function clip(text, width, glyphs = UNICODE_GLYPHS) {
+  if (visibleWidth(text) <= width)
+    return text;
+  const marker = glyphs.ellipsis;
+  const budget = Math.max(0, width - visibleWidth(marker));
+  let taken = "";
+  let used = 0;
+  const parts = text.split(/(\x1b\[[0-9;]*m)/);
+  let styled = false;
+  for (const part of parts) {
+    if (part.startsWith("\x1B[")) {
+      taken += part;
+      styled = styled || part !== "\x1B[0m";
+      continue;
+    }
+    for (const character of part) {
+      const next = visibleWidth(character);
+      if (used + next > budget)
+        return `${taken}${marker}${styled ? "\x1B[0m" : ""}`;
+      taken += character;
+      used += next;
+    }
+  }
+  return `${taken}${marker}${styled ? "\x1B[0m" : ""}`;
+}
+function outcomeMark(outcome, style) {
+  const glyphs = setOf(style);
+  switch (outcome) {
+    case "pass":
+      return paint(glyphs.check, GREEN, style.depth);
+    case "fail":
+      return paint(glyphs.cross, RED, style.depth);
+    case "skip":
+      return paint(glyphs.circleEmpty, DIM, style.depth);
+    default:
+      return paint(glyphs.pending, CYAN, style.depth);
+  }
+}
+function keyValues(rows, style) {
+  const width = Math.max(0, ...rows.map(([key]) => visibleWidth(key)));
+  return rows.map(([key, value]) => `${GUTTER}${paint(key.padEnd(width + 2), DIM, style.depth)}${value}`).join(`
+`);
+}
+
+export { BOLD, DIM, REVERSE, RED, GREEN, YELLOW, MAGENTA, CYAN, paint, paintAll, GUTTER, rule, heading, note, panel, clip, outcomeMark, keyValues };