@sweny-ai/core 0.1.169 → 0.1.171

package/dist/cli/progress.js

@@ -0,0 +1,69 @@
+/**
+ * Node progress lines for `sweny workflow run` and `sweny try`: a spinner on
+ * the running node when the output is live, then one settled line per node.
+ *
+ *   ⠙ survey  7 tool calls          (live, redrawn in place)
+ *   ✓ survey   18s · 12 tool calls   (settled)
+ *
+ * Not live (pipes, CI, --verbose): no redraws, no spinner, one line per event.
+ */
+import { SPINNER_INTERVAL_MS } from "../theme.js";
+import { glyphsFor, spinnerFramesFor } from "./terminal.js";
+export function toolCallsText(n) {
+    return `${n} tool ${n === 1 ? "call" : "calls"}`;
+}
+export function createNodeProgress(o) {
+    const g = glyphsFor(o.unicode);
+    const frames = spinnerFramesFor(o.unicode);
+    const { paint } = o;
+    const pad = (id) => id.padEnd(o.idWidth ?? 0);
+    let timer;
+    let current;
+    let frame = 0;
+    const draw = () => {
+        if (!current)
+            return;
+        const calls = current.calls > 0 ? `  ${paint.muted(toolCallsText(current.calls))}` : "";
+        o.write(`\r\x1B[2K  ${paint.brand(frames[frame++ % frames.length])} ${current.node}${calls}`);
+    };
+    const clear = () => {
+        if (timer)
+            clearInterval(timer);
+        timer = undefined;
+        if (current && o.live)
+            o.write("\r\x1B[2K");
+        current = undefined;
+    };
+    return {
+        enter(node) {
+            clear();
+            if (o.live) {
+                current = { node, calls: 0 };
+                frame = 0;
+                draw();
+                timer = setInterval(draw, SPINNER_INTERVAL_MS);
+                timer.unref?.();
+            }
+            else if (o.announce) {
+                o.write(`  ${paint.muted(g.pending)} ${paint.muted(node)}${g.ellipsis}\n`);
+            }
+        },
+        tick(node) {
+            if (current && current.node === node)
+                current.calls++;
+        },
+        exit(node, status, detail) {
+            clear();
+            const glyph = status === "success"
+                ? paint.success(g.success)
+                : status === "failed"
+                    ? paint.error(g.failure)
+                    : paint.muted(g.skipped);
+            const tail = detail ? `  ${paint.muted(detail)}` : "";
+            o.write(`  ${glyph} ${detail ? pad(node) : node}${tail}\n`);
+        },
+        stop() {
+            clear();
+        },
+    };
+}

package/dist/cli/renderer.d.ts

@@ -7,6 +7,10 @@ export interface DagRendererOptions {
     animate?: boolean;
     /** Stream to write to when animate=true or render() is called. Default: process.stderr. */
     stream?: NodeJS.WriteStream;
+    /** Show the status legend under the graph. Default: true. */
+    legend?: boolean;
+    /** Draw with Unicode box characters, else ASCII. Default: what the terminal supports. */
+    unicode?: boolean;
 }
 export declare class DagRenderer {
     private readonly workflow;

package/dist/cli/renderer.js

@@ -1,4 +1,6 @@
 import chalk from "chalk";
+import { GLYPHS, ROLE_COLORS } from "../theme.js";
+import { supportsUnicode, toAsciiDrawing } from "./terminal.js";
 // ── Helpers ──────────────────────────────────────────────────────
 /** Strip ANSI escape codes for accurate visible-width calculations. */
 export function stripAnsi(str) {
@@ -48,17 +50,18 @@ function topologicalOrder(workflow) {
     }
     return order;
 }
-// ── Status icons + colors ────────────────────────────────────────
+// ── Status icons + colors (the theme glyph set, one role color each) ─
+const G = GLYPHS.unicode;
 function statusIcon(state) {
     switch (state) {
         case "completed":
-            return chalk.green("●");
+            return chalk.hex(ROLE_COLORS.success)(G.success);
         case "running":
-            return chalk.yellow("◉");
+            return chalk.hex(ROLE_COLORS.brand)(G.running);
         case "pending":
-            return chalk.gray("○");
+            return chalk.hex(ROLE_COLORS.muted)(G.pending);
         case "failed":
-            return chalk.red("✕");
+            return chalk.hex(ROLE_COLORS.error)(G.failure);
     }
 }
 // ── Graph helpers ────────────────────────────────────────────────
@@ -143,7 +146,7 @@ function renderNodeBox(nodeName, nodeRenderState, innerWidth, indent, topConnect
     else {
         bottom = `${pad}└${"─".repeat(innerWidth)}┘`;
     }
-    // Content lines — icon on first line, wrapped name
+    // Content lines: icon on first line, wrapped name
     // Available space for text: innerWidth - 4 (1 space + icon + 1 space + text + padding + 1 space)
     // "│ ○ Name...padding │"  → icon(1) + spaces(2) + name + pad
     const iconVis = stripAnsi(icon); // 1 char
@@ -184,10 +187,10 @@ function renderNodeBox(nodeName, nodeRenderState, innerWidth, indent, topConnect
 // ── Legend ───────────────────────────────────────────────────────
 function renderLegend() {
     const items = [
-        `${chalk.green("●")} completed`,
-        `${chalk.yellow("◉")} running`,
-        `${chalk.gray("○")} pending`,
-        `${chalk.red("✕")} failed`,
+        `${statusIcon("completed")} completed`,
+        `${statusIcon("running")} running`,
+        `${statusIcon("pending")} pending`,
+        `${statusIcon("failed")} failed`,
     ];
     return `\n  ${chalk.dim(items.join("   "))}`;
 }
@@ -202,6 +205,8 @@ export class DagRenderer {
         this.workflow = workflow;
         this.options = {
             animate: options.animate ?? false,
+            legend: options.legend ?? true,
+            unicode: options.unicode ?? supportsUnicode(),
             stream: options.stream ??
                 (typeof process !== "undefined" ? process.stderr : undefined),
         };
@@ -298,7 +303,7 @@ export class DagRenderer {
                     continue;
                 const leftState = this.nodeStates.get(leftId) ?? { state: "pending", toolCallCount: 0 };
                 const rightState = this.nodeStates.get(rightId) ?? { state: "pending", toolCallCount: 0 };
-                // Determine child box widths — each child gets its own width based on its name
+                // Determine child box widths: each child gets its own width based on its name
                 const leftKids = children.get(leftId) ?? [];
                 const rightKids = children.get(rightId) ?? [];
                 // For side-by-side, compute widths that fit
@@ -391,8 +396,10 @@ export class DagRenderer {
                 }
             }
         }
-        lines.push(renderLegend());
-        return lines.join("\n");
+        if (this.options.legend)
+            lines.push(renderLegend());
+        const out = lines.join("\n");
+        return this.options.unicode ? out : toAsciiDrawing(out);
     }
     /**
      * Writes the current DAG render to the stream.

package/dist/cli/run-output.d.ts

@@ -68,6 +68,11 @@ export interface RunPolicy {
 export declare function degradedKey(entry: string): string;
 /** Sum the per-node results into one run summary. */
 export declare function summarizeRun(results: Map<string, NodeResult>, durationMs: number, crashed?: boolean, trace?: ExecutionTrace): RunSummary;
+/**
+ * The policy facts the run knew, as short phrases: `env scoped`, `sandbox on`,
+ * `1 output staged`. No phrase for a fact no node reported.
+ */
+export declare function policyParts(p: RunPolicy | undefined): string[];
 /**
  * `policy: env scoped, sandbox on, 1 output staged`. Only what the run knew:
  * no segment for a fact no node reported. Undefined when there is nothing to say.
@@ -76,8 +81,12 @@ export declare function formatPolicySegment(p: RunPolicy | undefined): string |
 export declare function formatReceiptDuration(ms: number): string;
 export declare function formatTokenCount(n: number): string;
 export declare function formatCost(usd: number): string;
+/** `tokens 52k of 50k`: the overrun, in the budget's unit. */
+export declare function formatBudgetAmount(b: NonNullable<RunSummary["budget"]>): string;
 /** `budget exceeded: tokens 52k of 50k (run, at node gather)`. */
 export declare function formatBudgetOverrun(b: NonNullable<RunSummary["budget"]>): string;
+/** `agreed 4/5`, or `fell through 2/2` when no decision passed the gates. */
+export declare function formatDeciderCounts(d: NonNullable<RunSummary["decider"]>): string;
 /**
  * One plain line: `✓ 3/3 nodes · 41 tool calls · 2m10s · 12k tokens · $0.18`.
  * Token and cost segments are omitted when the SDK reported none. A harness
@@ -86,15 +95,11 @@ export declare function formatBudgetOverrun(b: NonNullable<RunSummary["budget"]>
  * when writing to a TTY.
  */
 export declare function formatReceipt(s: RunSummary): string;
-/** Receipt for a terminal: colored only when `color` is true. */
+/** Receipt for a terminal: in the success or error color only when `color` is true. */
 export declare function renderReceiptLine(s: RunSummary, color: boolean): string;
-/** Brand blue (blue-600 / blue-700), not indigo. Applied to successful nodes. */
-export declare const STEP_SUMMARY_CLASS_DEFS: {
-    readonly success: "fill:#2563eb,stroke:#1d4ed8,color:#fff,stroke-width:2px";
-};
 /** Per-node Mermaid status from run results. */
 export declare function nodeStates(results: Map<string, NodeResult>): Record<string, NodeStatus>;
-/** Markdown for `$GITHUB_STEP_SUMMARY`: receipt + status-colored Mermaid DAG. */
+/** Markdown for `$GITHUB_STEP_SUMMARY`: receipt + Mermaid DAG in the brand classDefs. */
 export declare function formatStepSummary(workflow: Workflow, results: Map<string, NodeResult>, summary: RunSummary, trace?: ExecutionTrace): string;
 /**
  * Append the step summary to the file named by GITHUB_STEP_SUMMARY.
@@ -116,6 +121,8 @@ export interface RunLogger extends Logger {
 export declare function createRunLogger(opts: {
     verbose: boolean;
     tty: boolean;
+    /** Color the markers. Default: `tty` and color is enabled for stderr. */
+    color?: boolean;
     write?: (s: string) => void;
 }): RunLogger;
 export declare const WORKFLOW_RUN_DESCRIPTION = "Run a workflow from a YAML or JSON file. With no file, batch-runs every workflow in .sweny/e2e/ (lists and confirms first; use --yes to skip the prompt).";

package/dist/cli/run-output.js

@@ -6,10 +6,11 @@
  * model prose: only counts, durations, token totals, and cost.
  */
 import fs from "node:fs";
-import chalk from "chalk";
 import { consoleLogger } from "../types.js";
 import { summarizeDecisions } from "../decider.js";
 import { toMermaidBlock } from "../mermaid.js";
+import { createPaint } from "./style.js";
+import { colorEnabled, glyphs } from "./terminal.js";
 /** The short key of a `degraded` entry: the text before its first colon. */
 export function degradedKey(entry) {
     const i = entry.indexOf(":");
@@ -90,12 +91,12 @@ function decisionCounts(trace) {
     return { compared: d.compared, agreed: d.agreed, fellThrough: d.fell_through };
 }
 /**
- * `policy: env scoped, sandbox on, 1 output staged`. Only what the run knew:
- * no segment for a fact no node reported. Undefined when there is nothing to say.
+ * The policy facts the run knew, as short phrases: `env scoped`, `sandbox on`,
+ * `1 output staged`. No phrase for a fact no node reported.
  */
-export function formatPolicySegment(p) {
+export function policyParts(p) {
     if (!p)
-        return undefined;
+        return [];
     const parts = [];
     if (p.envScope !== undefined)
         parts.push(p.envScope ? "env scoped" : "env unscoped");
@@ -113,6 +114,14 @@ export function formatPolicySegment(p) {
         if (p.outputs.applied > 0)
             parts.push(`${n(p.outputs.applied)} applied`);
     }
+    return parts;
+}
+/**
+ * `policy: env scoped, sandbox on, 1 output staged`. Only what the run knew:
+ * no segment for a fact no node reported. Undefined when there is nothing to say.
+ */
+export function formatPolicySegment(p) {
+    const parts = policyParts(p);
     return parts.length > 0 ? `policy: ${parts.join(", ")}` : undefined;
 }
 export function formatReceiptDuration(ms) {
@@ -137,11 +146,19 @@ export function formatCost(usd) {
         return "<$0.01";
     return `$${usd.toFixed(2)}`;
 }
-/** `budget exceeded: tokens 52k of 50k (run, at node gather)`. */
-export function formatBudgetOverrun(b) {
+/** `tokens 52k of 50k`: the overrun, in the budget's unit. */
+export function formatBudgetAmount(b) {
     const amount = (n) => b.unit === "cost_usd" ? (n < 0.01 ? `$${n.toFixed(4)}` : formatCost(n)) : formatTokenCount(n);
     const unit = b.unit === "cost_usd" ? "cost" : "tokens";
-    return `budget exceeded: ${unit} ${amount(b.spent)} of ${amount(b.limit)} (${b.scope}, at node ${b.node})`;
+    return `${unit} ${amount(b.spent)} of ${amount(b.limit)}`;
+}
+/** `budget exceeded: tokens 52k of 50k (run, at node gather)`. */
+export function formatBudgetOverrun(b) {
+    return `budget exceeded: ${formatBudgetAmount(b)} (${b.scope}, at node ${b.node})`;
+}
+/** `agreed 4/5`, or `fell through 2/2` when no decision passed the gates. */
+export function formatDeciderCounts(d) {
+    return d.compared > 0 ? `agreed ${d.agreed}/${d.compared}` : `fell through ${d.fellThrough}/${d.fellThrough}`;
 }
 /**
  * One plain line: `✓ 3/3 nodes · 41 tool calls · 2m10s · 12k tokens · $0.18`.
@@ -162,28 +179,19 @@ export function formatReceipt(s) {
         ...(s.degraded && s.degraded.length > 0 ? [`degraded: ${s.degraded.join(", ")}`] : []),
         ...(formatPolicySegment(s.policy) ? [formatPolicySegment(s.policy)] : []),
         ...(s.budget ? [formatBudgetOverrun(s.budget)] : []),
-        ...(s.decider
-            ? [
-                s.decider.compared > 0
-                    ? `decider agreed ${s.decider.agreed}/${s.decider.compared}`
-                    : `decider fell through ${s.decider.fellThrough}/${s.decider.fellThrough}`,
-            ]
-            : []),
+        ...(s.decider ? [`decider ${formatDeciderCounts(s.decider)}`] : []),
     ];
     return parts.join(" · ");
 }
-/** Receipt for a terminal: colored only when `color` is true. */
+/** Receipt for a terminal: in the success or error color only when `color` is true. */
 export function renderReceiptLine(s, color) {
     const line = formatReceipt(s);
     if (!color)
         return line;
-    return s.ok ? chalk.green(line) : chalk.red(line);
+    const paint = createPaint(true);
+    return s.ok ? paint.success(line) : paint.error(line);
 }
 // ── Step summary ────────────────────────────────────────────────
-/** Brand blue (blue-600 / blue-700), not indigo. Applied to successful nodes. */
-export const STEP_SUMMARY_CLASS_DEFS = {
-    success: "fill:#2563eb,stroke:#1d4ed8,color:#fff,stroke-width:2px",
-};
 /** Per-node Mermaid status from run results. */
 export function nodeStates(results) {
     const state = {};
@@ -192,7 +200,7 @@ export function nodeStates(results) {
     }
     return state;
 }
-/** Markdown for `$GITHUB_STEP_SUMMARY`: receipt + status-colored Mermaid DAG. */
+/** Markdown for `$GITHUB_STEP_SUMMARY`: receipt + Mermaid DAG in the brand classDefs. */
 export function formatStepSummary(workflow, results, summary, trace) {
     const state = nodeStates(results);
     return [
@@ -200,7 +208,7 @@ export function formatStepSummary(workflow, results, summary, trace) {
         "",
         `\`${formatReceipt(summary)}\``,
         "",
-        toMermaidBlock(workflow, { state, trace, classDefs: STEP_SUMMARY_CLASS_DEFS }),
+        toMermaidBlock(workflow, { state, trace }),
         "",
         "",
     ].join("\n");
@@ -219,7 +227,7 @@ export function writeStepSummary(workflow, results, summary, trace, env = proces
         return true;
     }
     catch (err) {
-        process.stderr.write(`  ⚠ could not write GITHUB_STEP_SUMMARY: ${err instanceof Error ? err.message : err}\n`);
+        process.stderr.write(`  ${glyphs().warning} could not write GITHUB_STEP_SUMMARY: ${err instanceof Error ? err.message : err}\n`);
         return false;
     }
 }
@@ -234,6 +242,8 @@ export function createRunLogger(opts) {
     const write = opts.write ?? ((s) => void process.stderr.write(s));
     if (opts.verbose)
         return { ...consoleLogger, flush() { } };
+    const paint = createPaint(opts.color ?? (opts.tty && colorEnabled(process.stderr)));
+    const g = glyphs();
     const held = [];
     const emit = (line) => {
         if (opts.tty)
@@ -245,8 +255,8 @@ export function createRunLogger(opts) {
     return {
         info: noop,
         debug: noop,
-        warn: (msg) => emit(`  ${chalk.yellow("⚠")} ${msg.trim()}\n`),
-        error: (msg) => emit(`  ${chalk.red("✗")} ${msg.trim()}\n`),
+        warn: (msg) => emit(`  ${paint.warning(g.warning)} ${msg.trim()}\n`),
+        error: (msg) => emit(`  ${paint.error(g.failure)} ${msg.trim()}\n`),
         flush() {
             while (held.length)
                 write(held.shift());

package/dist/cli/runs.js

@@ -2,9 +2,11 @@
  * `sweny runs` and `sweny runs diff`: read-only views over `.sweny/runs/`.
  * Metadata only. Color only when `color` is true (TTY).
  */
-import chalk from "chalk";
 import { findRun, listRuns } from "./run-history.js";
 import { formatCost, formatReceiptDuration, formatTokenCount } from "./run-output.js";
+import { createPaint } from "./style.js";
+import { colorEnabled } from "./terminal.js";
+import { GLYPHS } from "../theme.js";
 // ── Small formatters ────────────────────────────────────────────
 export function formatAge(startedAt, nowMs = Date.now()) {
     const s = Math.max(0, Math.round((nowMs - Date.parse(startedAt)) / 1000));
@@ -18,15 +20,18 @@ export function formatAge(startedAt, nowMs = Date.now()) {
         return `${h}h ago`;
     return `${Math.floor(h / 24)}d ago`;
 }
-const ICON = { success: "✓", failed: "✗", crashed: "✗", skipped: "−" };
+const G = GLYPHS.unicode;
+const ICON = { success: G.success, failed: G.failure, crashed: G.failure, skipped: G.skipped };
+/** Status text in its role color: success, error, or muted for skipped. */
 function paint(text, status, color) {
     if (!color)
         return text;
+    const p = createPaint(true);
     if (status === "success")
-        return chalk.green(text);
+        return p.success(text);
     if (status === "skipped")
-        return chalk.dim(text);
-    return chalk.red(text);
+        return p.muted(text);
+    return p.error(text);
 }
 const tokensText = (n) => (n === null ? "-" : formatTokenCount(n));
 const costText = (n) => (n === null ? "-" : formatCost(n));
@@ -63,7 +68,8 @@ export function formatRunsTable(runs, color, nowMs = Date.now()) {
             .join("  ")
             .trimEnd();
     const headLine = line(head);
-    return [color ? chalk.dim(headLine) : headLine, ...rows.map((r) => line(r.cells, r.status))].join("\n") + "\n";
+    return ([color ? createPaint(true).muted(headLine) : headLine, ...rows.map((r) => line(r.cells, r.status))].join("\n") +
+        "\n");
 }
 // ── sweny runs diff ─────────────────────────────────────────────
 const sign = (n) => (n > 0 ? "+" : n < 0 ? "-" : "");
@@ -94,7 +100,7 @@ function nodeChanges(a, b) {
 }
 const routeKey = (r) => `${r.from} → ${r.to}`;
 export function formatRunDiff(a, b, color) {
-    const dim = (s) => (color ? chalk.dim(s) : s);
+    const dim = createPaint(color).muted;
     const out = [];
     const hdr = (tag, r) => `  ${tag}  ${r.run_id}  ${r.workflow_id}  ${paint(`${ICON[r.status] ?? "?"} ${r.status}`, r.status, color)}  ${formatReceiptDuration(r.duration_ms)}`;
     out.push(hdr("a", a), hdr("b", b), "");
@@ -183,7 +189,7 @@ export function registerRunsCommand(program) {
         .action((opts) => {
         const limit = Number(opts.limit ?? "20");
         if (!Number.isInteger(limit) || limit < 1) {
-            console.error(chalk.red("  --limit must be a positive integer"));
+            console.error(createPaint(colorEnabled(process.stderr)).error("  --limit must be a positive integer"));
             process.exitCode = 1;
             return;
         }
@@ -195,7 +201,7 @@ export function registerRunsCommand(program) {
             process.stdout.write(JSON.stringify(runs, null, 2) + "\n");
             return;
         }
-        process.stdout.write("\n" + formatRunsTable(runs, process.stdout.isTTY ?? false) + "\n");
+        process.stdout.write("\n" + formatRunsTable(runs, colorEnabled(process.stdout)) + "\n");
     });
     runsCmd
         .command("diff [a] [b]")
@@ -206,11 +212,11 @@ export function registerRunsCommand(program) {
         const runs = listRuns();
         const picked = pickRunsForDiff(runs, refs, opts.workflow);
         if ("error" in picked) {
-            console.error(chalk.red(`  ${picked.error}`));
+            console.error(createPaint(colorEnabled(process.stderr)).error(`  ${picked.error}`));
             process.exitCode = 1;
             return;
         }
-        process.stdout.write("\n" + formatRunDiff(picked.a, picked.b, process.stdout.isTTY ?? false) + "\n");
+        process.stdout.write("\n" + formatRunDiff(picked.a, picked.b, colorEnabled(process.stdout)) + "\n");
     });
     return runsCmd;
 }

package/dist/cli/style.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Terminal painters built from the theme tokens. The only place the CLI
+ * turns a color role into ANSI.
+ *
+ * `createPaint(false)` returns identity painters, so a formatter takes one
+ * `Paint` and renders the same text with or without color.
+ */
+export type Painter = (text: string) => string;
+export interface Paint {
+    brand: Painter;
+    success: Painter;
+    warning: Painter;
+    error: Painter;
+    info: Painter;
+    muted: Painter;
+    /** Emphasis without a color: bold. */
+    strong: Painter;
+    link: Painter;
+}
+/** Painters for one output. `enabled: false` paints nothing. */
+export declare function createPaint(enabled: boolean): Paint;
+/**
+ * Honor `NO_COLOR` for every chalk call in the process, including the ones
+ * that do not go through `createPaint`. Call once at CLI startup.
+ */
+export declare function applyNoColor(env?: Record<string, string | undefined>): void;

package/dist/cli/style.js

@@ -0,0 +1,48 @@
+/**
+ * Terminal painters built from the theme tokens. The only place the CLI
+ * turns a color role into ANSI.
+ *
+ * `createPaint(false)` returns identity painters, so a formatter takes one
+ * `Paint` and renders the same text with or without color.
+ */
+import chalk, { Chalk, chalkStderr } from "chalk";
+import { ROLE_COLORS } from "../theme.js";
+const identity = (s) => s;
+/** Painters for one output. `enabled: false` paints nothing. */
+export function createPaint(enabled) {
+    if (!enabled) {
+        return {
+            brand: identity,
+            success: identity,
+            warning: identity,
+            error: identity,
+            info: identity,
+            muted: identity,
+            strong: identity,
+            link: identity,
+        };
+    }
+    // Force a level so a caller that decided "color on" gets color even when
+    // chalk's own detection looked at a different stream.
+    const k = new Chalk({ level: Math.max(chalk.level, chalkStderr.level, 1) });
+    return {
+        brand: (s) => k.hex(ROLE_COLORS.brand)(s),
+        success: (s) => k.hex(ROLE_COLORS.success)(s),
+        warning: (s) => k.hex(ROLE_COLORS.warning)(s),
+        error: (s) => k.hex(ROLE_COLORS.error)(s),
+        info: (s) => k.hex(ROLE_COLORS.info)(s),
+        muted: (s) => k.hex(ROLE_COLORS.muted)(s),
+        strong: (s) => k.bold(s),
+        link: (s) => k.hex(ROLE_COLORS.info).underline(s),
+    };
+}
+/**
+ * Honor `NO_COLOR` for every chalk call in the process, including the ones
+ * that do not go through `createPaint`. Call once at CLI startup.
+ */
+export function applyNoColor(env = process.env) {
+    if (env.NO_COLOR) {
+        chalk.level = 0;
+        chalkStderr.level = 0;
+    }
+}

package/dist/cli/terminal.d.ts

@@ -0,0 +1,47 @@
+/**
+ * What the terminal can show: color, Unicode, width, live redraws.
+ *
+ * Every check reads the env and stream passed in, so specs can pin each
+ * case. Defaults read the real process.
+ */
+import { type GlyphSet, type TicketBox } from "../theme.js";
+type Env = Record<string, string | undefined>;
+/** The narrowest layout SWEny designs for. Narrower terminals still work, they just wrap. */
+export declare const MIN_COLUMNS = 40;
+/**
+ * True when the terminal can draw box-drawing characters and the glyph set.
+ *
+ * `SWENY_ASCII=1` forces ASCII; `SWENY_UNICODE=1` forces Unicode. Otherwise a
+ * locale that names a charset decides (`LC_ALL`, then `LC_CTYPE`, then
+ * `LANG`): UTF-8 is Unicode, `C`/`POSIX`/anything else is ASCII. The Linux
+ * console (`TERM=linux`) is ASCII. With no locale set, POSIX terminals are
+ * assumed Unicode; Windows is Unicode only in terminals known to support it.
+ */
+export declare function supportsUnicode(env?: Env, platform?: string): boolean;
+/**
+ * True when output to `stream` should carry ANSI color. `NO_COLOR` (any
+ * non-empty value) always wins; then `FORCE_COLOR` (anything but `0`); then a
+ * TTY that is not `TERM=dumb`.
+ */
+export declare function colorEnabled(stream: {
+    isTTY?: boolean;
+} | undefined, env?: Env): boolean;
+/**
+ * True when `stream` gets the rich view (the ticket, redraws, a spinner):
+ * a TTY, not CI, not dumb. Everything else gets plain lines.
+ */
+export declare function richOutput(stream: {
+    isTTY?: boolean;
+} | undefined, env?: Env): boolean;
+/** Usable width of `stream`: its column count, else `COLUMNS`, else 80. */
+export declare function terminalColumns(stream: {
+    columns?: number;
+} | undefined, env?: Env): number;
+export declare function glyphsFor(unicode: boolean): GlyphSet;
+export declare function ticketBoxFor(unicode: boolean): TicketBox;
+export declare function spinnerFramesFor(unicode: boolean): readonly string[];
+/** The glyphs for the current process. */
+export declare function glyphs(env?: Env): GlyphSet;
+/** Replace single-column Unicode drawing characters with their ASCII stand-ins. */
+export declare function toAsciiDrawing(text: string): string;
+export {};