@sweny-ai/core 0.1.169 → 0.1.171

package/dist/cli/terminal.js

@@ -0,0 +1,123 @@
+/**
+ * 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 { GLYPHS, SPINNER_FRAMES, TICKET_BOX } from "../theme.js";
+/** The narrowest layout SWEny designs for. Narrower terminals still work, they just wrap. */
+export 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 function supportsUnicode(env = process.env, platform = process.platform) {
+    if (truthy(env.SWENY_ASCII))
+        return false;
+    if (truthy(env.SWENY_UNICODE))
+        return true;
+    if (env.TERM === "linux")
+        return false;
+    const locale = env.LC_ALL || env.LC_CTYPE || env.LANG;
+    if (locale)
+        return /utf-?8/i.test(locale);
+    if (platform !== "win32")
+        return true;
+    return Boolean(env.WT_SESSION ||
+        env.TERMINUS_SUBLIME ||
+        env.ConEmuTask === "{cmd::Cmder}" ||
+        env.TERM_PROGRAM === "vscode" ||
+        env.TERM === "xterm-256color" ||
+        env.TERM === "alacritty" ||
+        env.TERMINAL_EMULATOR === "JetBrains-JediTerm");
+}
+/**
+ * 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 function colorEnabled(stream, env = process.env) {
+    if (env.NO_COLOR)
+        return false;
+    if (env.FORCE_COLOR !== undefined && env.FORCE_COLOR !== "")
+        return env.FORCE_COLOR !== "0";
+    if (env.TERM === "dumb")
+        return false;
+    return Boolean(stream?.isTTY);
+}
+/**
+ * True when `stream` gets the rich view (the ticket, redraws, a spinner):
+ * a TTY, not CI, not dumb. Everything else gets plain lines.
+ */
+export function richOutput(stream, env = process.env) {
+    return Boolean(stream?.isTTY) && !truthy(env.CI) && env.TERM !== "dumb";
+}
+/** Usable width of `stream`: its column count, else `COLUMNS`, else 80. */
+export function terminalColumns(stream, env = process.env) {
+    const fromStream = stream?.columns;
+    if (typeof fromStream === "number" && fromStream > 0)
+        return fromStream;
+    const fromEnv = Number(env.COLUMNS);
+    if (Number.isInteger(fromEnv) && fromEnv > 0)
+        return fromEnv;
+    return 80;
+}
+export function glyphsFor(unicode) {
+    return unicode ? GLYPHS.unicode : GLYPHS.ascii;
+}
+export function ticketBoxFor(unicode) {
+    return unicode ? TICKET_BOX.unicode : TICKET_BOX.ascii;
+}
+export function spinnerFramesFor(unicode) {
+    return unicode ? SPINNER_FRAMES.unicode : SPINNER_FRAMES.ascii;
+}
+/** The glyphs for the current process. */
+export function glyphs(env = process.env) {
+    return glyphsFor(supportsUnicode(env));
+}
+function truthy(v) {
+    return v !== undefined && v !== "" && v !== "0" && v.toLowerCase() !== "false";
+}
+/**
+ * Box-drawing and glyph fallbacks for text drawn with Unicode (the DAG
+ * renderer). Each maps to a single ASCII column so alignment holds.
+ */
+const ASCII_FALLBACK = {
+    "┌": "+",
+    "┐": "+",
+    "└": "+",
+    "┘": "+",
+    "├": "+",
+    "┤": "+",
+    "┬": "+",
+    "┴": "+",
+    "┼": "+",
+    "╭": "+",
+    "╮": "+",
+    "╰": "+",
+    "╯": "+",
+    "─": "-",
+    "┄": "-",
+    "╌": "-",
+    "│": "|",
+    "┆": ":",
+    "▼": "v",
+    "▶": ">",
+    [GLYPHS.unicode.success]: GLYPHS.ascii.success,
+    [GLYPHS.unicode.failure]: GLYPHS.ascii.failure,
+    [GLYPHS.unicode.skipped]: GLYPHS.ascii.skipped,
+    [GLYPHS.unicode.pending]: GLYPHS.ascii.pending,
+    [GLYPHS.unicode.running]: GLYPHS.ascii.running,
+    [GLYPHS.unicode.brand]: GLYPHS.ascii.brand,
+    [GLYPHS.unicode.sep]: GLYPHS.ascii.sep,
+};
+const ASCII_FALLBACK_RE = new RegExp(`[${Object.keys(ASCII_FALLBACK).join("")}]`, "g");
+/** Replace single-column Unicode drawing characters with their ASCII stand-ins. */
+export function toAsciiDrawing(text) {
+    return text.replace(ASCII_FALLBACK_RE, (ch) => ASCII_FALLBACK[ch] ?? ch);
+}

package/dist/cli/ticket.d.ts

@@ -0,0 +1,89 @@
+/**
+ * The receipt ticket: the run receipt as a small perforated card with a tear
+ * line and a policy stamp. Shown at the end of a run on a TTY, and at the top
+ * of the PR comment. CI logs, pipes and `--json` keep the plain receipt line.
+ *
+ * METADATA ONLY, like the receipt line: counts, durations, tokens, cost,
+ * policy facts. Never prompts, node outputs, tool inputs, or model prose.
+ */
+import type { RunSummary } from "./run-output.js";
+import { type Paint } from "./style.js";
+/** Widest ticket, in columns, frame included. */
+export declare const TICKET_MAX_WIDTH = 48;
+/** Narrowest ticket. Below this the fields stop being readable. */
+export declare const TICKET_MIN_WIDTH = 32;
+/** Left indent the CLI prints the ticket at. */
+export declare const TICKET_INDENT = 2;
+/** How long the stub sits empty before the stamp lands (the one animation frame). */
+export declare const STAMP_DELAY_MS = 140;
+export interface TicketData {
+    summary: RunSummary;
+    /** Workflow id, shown under the status. */
+    workflow: string;
+    /** Full run id; the ticket shows its short hash. */
+    runId?: string;
+    /** The run crashed before finishing (not a node failure). */
+    crashed?: boolean;
+}
+export interface TicketRenderOptions {
+    /** Columns available, indent included. Default 80. The ticket fits in `columns - 2`. */
+    columns?: number;
+    /** Box drawing and glyphs in Unicode (default) or ASCII. */
+    unicode?: boolean;
+    /** Painters. Default: no color. */
+    paint?: Paint;
+    /** Draw the policy stamp. False leaves the stub empty: the frame before the stamp lands. Default true. */
+    stamp?: boolean;
+}
+export interface RenderedTicket {
+    /** The ticket, one string per row, no indent. */
+    lines: string[];
+    /** Index of the stamp row in `lines`, or -1 when the run reported no policy facts. */
+    stampRow: number;
+}
+/** `20260930-110000-3f9a2c` shows as `3f9a2c`; any other id as its first 8 characters. */
+export declare function shortRunId(runId: string): string;
+/** The ticket's status word. */
+export declare function ticketStatus(data: TicketData): "passed" | "failed" | "budget stop" | "crashed";
+/**
+ * The policy stamp words, from what the run reported: `ENV SCOPED`,
+ * `SANDBOXED`. Empty when no node reported env scope or sandbox facts.
+ * `strong` is false when any fact is weaker than the default (an unscoped
+ * env, no sandbox), which the stamp shows in the warning color.
+ */
+export declare function stampWords(summary: RunSummary): {
+    words: string[];
+    strong: boolean;
+};
+/** Ticket width for a terminal of `columns`: fits beside the indent, within the min and max. */
+export declare function ticketWidth(columns: number): number;
+/**
+ * Render the ticket. Pure: same input, same rows. Every row is exactly the
+ * ticket width in visible columns.
+ */
+export declare function renderTicket(data: TicketData, opts?: TicketRenderOptions): RenderedTicket;
+/** The ticket as plain text (no color, Unicode): what the PR comment carries. */
+export declare function formatTicketText(data: TicketData, columns?: number): string;
+export interface ReceiptStream {
+    write(s: string): unknown;
+    isTTY?: boolean;
+    columns?: number;
+}
+export interface WriteReceiptOptions extends Omit<TicketData, "summary"> {
+    stream: ReceiptStream;
+    env?: Record<string, string | undefined>;
+    /** Land the stamp one frame after the ticket. Default true on a rich stream. */
+    animate?: boolean;
+    /** Override the rich (ticket) or plain (one line) choice. Default: `richOutput(stream, env)`. */
+    rich?: boolean;
+    /** Override color. Default: `colorEnabled(stream, env)`. */
+    color?: boolean;
+    /** Override Unicode. Default: `supportsUnicode(env)`. */
+    unicode?: boolean;
+}
+/**
+ * Print the receipt. A TTY (not CI) gets the ticket, its stamp landing one
+ * frame after the card; anything else gets the plain line. Both end with a
+ * blank line.
+ */
+export declare function writeReceipt(summary: RunSummary, opts: WriteReceiptOptions): Promise<void>;

package/dist/cli/ticket.js

@@ -0,0 +1,218 @@
+/**
+ * The receipt ticket: the run receipt as a small perforated card with a tear
+ * line and a policy stamp. Shown at the end of a run on a TTY, and at the top
+ * of the PR comment. CI logs, pipes and `--json` keep the plain receipt line.
+ *
+ * METADATA ONLY, like the receipt line: counts, durations, tokens, cost,
+ * policy facts. Never prompts, node outputs, tool inputs, or model prose.
+ */
+import { formatBudgetAmount, formatCost, formatDeciderCounts, formatReceiptDuration, formatTokenCount, policyParts, renderReceiptLine, } from "./run-output.js";
+import { createPaint } from "./style.js";
+import { colorEnabled, glyphsFor, richOutput, supportsUnicode, terminalColumns, ticketBoxFor } from "./terminal.js";
+/** Widest ticket, in columns, frame included. */
+export const TICKET_MAX_WIDTH = 48;
+/** Narrowest ticket. Below this the fields stop being readable. */
+export const TICKET_MIN_WIDTH = 32;
+/** Left indent the CLI prints the ticket at. */
+export const TICKET_INDENT = 2;
+/** How long the stub sits empty before the stamp lands (the one animation frame). */
+export const STAMP_DELAY_MS = 140;
+const LABEL_WIDTH = 12;
+/** `20260930-110000-3f9a2c` shows as `3f9a2c`; any other id as its first 8 characters. */
+export function shortRunId(runId) {
+    const m = /-([0-9a-f]{6,})$/i.exec(runId);
+    return m ? m[1] : runId.slice(0, 8);
+}
+/** The ticket's status word. */
+export function ticketStatus(data) {
+    if (data.crashed)
+        return "crashed";
+    if (data.summary.budget)
+        return "budget stop";
+    return data.summary.ok ? "passed" : "failed";
+}
+/**
+ * The policy stamp words, from what the run reported: `ENV SCOPED`,
+ * `SANDBOXED`. Empty when no node reported env scope or sandbox facts.
+ * `strong` is false when any fact is weaker than the default (an unscoped
+ * env, no sandbox), which the stamp shows in the warning color.
+ */
+export function stampWords(summary) {
+    const p = summary.policy;
+    const words = [];
+    let strong = true;
+    if (p?.envScope !== undefined) {
+        words.push(p.envScope ? "ENV SCOPED" : "ENV UNSCOPED");
+        strong &&= p.envScope;
+    }
+    if (p?.sandbox) {
+        const on = p.sandbox.mode !== "off" && p.sandbox.started;
+        words.push(on ? "SANDBOXED" : "UNSANDBOXED");
+        strong &&= on;
+    }
+    return { words, strong };
+}
+/** Field rows, label then value, metadata only. */
+function ticketFields(s) {
+    const failed = Math.max(0, s.nodesTotal - s.nodesOk - s.nodesSkipped);
+    const nodes = [
+        `${s.nodesOk}/${s.nodesTotal}`,
+        ...(failed > 0 ? [`${failed} failed`] : []),
+        ...(s.nodesSkipped > 0 ? [`${s.nodesSkipped} skipped`] : []),
+    ].join(", ");
+    const policy = policyParts(s.policy);
+    return [
+        ["nodes", nodes],
+        ["tool calls", String(s.toolCalls)],
+        ["duration", formatReceiptDuration(s.durationMs)],
+        ...(s.tokens !== undefined ? [["tokens", formatTokenCount(s.tokens)]] : []),
+        ...(s.costUsd !== undefined ? [["cost", formatCost(s.costUsd)]] : []),
+        ...(s.harness !== undefined && s.harness !== "claude-code" ? [["harness", s.harness]] : []),
+        ...(s.degraded && s.degraded.length > 0 ? [["degraded", s.degraded.join(", ")]] : []),
+        ...(s.decider ? [["decider", formatDeciderCounts(s.decider)]] : []),
+        ...(s.budget
+            ? [
+                ["budget", `${formatBudgetAmount(s.budget)} (${s.budget.scope})`],
+                ["stopped at", s.budget.node],
+            ]
+            : []),
+        ...(policy.length > 0 ? [["policy", policy.join(", ")]] : []),
+    ];
+}
+/** Word-wrap to `width`, hard-breaking any word longer than the line. */
+function wrap(text, width) {
+    const out = [];
+    let line = "";
+    for (let word of text.split(" ")) {
+        while (word.length > width) {
+            if (line) {
+                out.push(line);
+                line = "";
+            }
+            out.push(word.slice(0, width));
+            word = word.slice(width);
+        }
+        if (!line)
+            line = word;
+        else if (line.length + 1 + word.length <= width)
+            line += ` ${word}`;
+        else {
+            out.push(line);
+            line = word;
+        }
+    }
+    if (line || out.length === 0)
+        out.push(line);
+    return out;
+}
+function clip(text, width, ellipsis) {
+    if (text.length <= width)
+        return text;
+    return text.slice(0, Math.max(0, width - ellipsis.length)) + ellipsis;
+}
+/** Ticket width for a terminal of `columns`: fits beside the indent, within the min and max. */
+export function ticketWidth(columns) {
+    return Math.max(TICKET_MIN_WIDTH, Math.min(TICKET_MAX_WIDTH, columns - TICKET_INDENT));
+}
+/**
+ * Render the ticket. Pure: same input, same rows. Every row is exactly the
+ * ticket width in visible columns.
+ */
+export function renderTicket(data, opts = {}) {
+    const unicode = opts.unicode ?? true;
+    const paint = opts.paint ?? createPaint(false);
+    const box = ticketBoxFor(unicode);
+    const g = glyphsFor(unicode);
+    const width = ticketWidth(opts.columns ?? 80);
+    const inner = width - 4;
+    const valueWidth = inner - LABEL_WIDTH;
+    const s = data.summary;
+    const frame = paint.muted;
+    const edge = (left, fill, right) => {
+        const run = fill.repeat(Math.ceil((width - 2) / fill.length)).slice(0, width - 2);
+        return frame(left + run + right);
+    };
+    /** One content row: `raw` sets the width, `painted` is what prints. */
+    const row = (raw, painted = raw) => `${frame(box.vertical)} ${painted}${" ".repeat(Math.max(0, inner - raw.length))} ${frame(box.vertical)}`;
+    const lines = [edge(box.topLeft, box.horizontal, box.topRight)];
+    // Status and run id.
+    const status = ticketStatus(data);
+    const good = status === "passed";
+    const tone = good ? paint.success : paint.error;
+    const left = `${good ? g.success : g.failure} ${status}`;
+    const right = data.runId ? `run ${shortRunId(data.runId)}` : "";
+    const gap = inner - left.length - right.length;
+    if (right && gap >= 2) {
+        lines.push(row(left + " ".repeat(gap) + right, paint.strong(tone(left)) + " ".repeat(gap) + paint.muted(right)));
+    }
+    else {
+        lines.push(row(left, paint.strong(tone(left))));
+    }
+    const name = clip(data.workflow, inner, g.ellipsis);
+    lines.push(row(name));
+    lines.push(row(""));
+    // Fields, aligned: label column then value column; long values wrap under the value.
+    for (const [label, value] of ticketFields(s)) {
+        wrap(value, valueWidth).forEach((part, i) => {
+            const lab = (i === 0 ? label : "").padEnd(LABEL_WIDTH);
+            lines.push(row(lab + part, paint.muted(lab) + part));
+        });
+    }
+    // Tear line and stub with the policy stamp.
+    let stampRow = -1;
+    const stamp = stampWords(s);
+    if (stamp.words.length > 0) {
+        lines.push(edge(box.tearLeft, box.tear, box.tearRight));
+        let text = `[ ${stamp.words.join(` ${g.sep} `)} ]`;
+        if (text.length > inner)
+            text = clip(stamp.words.join(` ${g.sep} `), inner, g.ellipsis);
+        const padL = Math.floor((inner - text.length) / 2);
+        const raw = " ".repeat(padL) + text;
+        stampRow = lines.length;
+        if (opts.stamp === false)
+            lines.push(row(""));
+        else
+            lines.push(row(raw, " ".repeat(padL) + paint.strong((stamp.strong ? paint.brand : paint.warning)(text))));
+    }
+    lines.push(edge(box.bottomLeft, box.horizontal, box.bottomRight));
+    return { lines, stampRow };
+}
+/** The ticket as plain text (no color, Unicode): what the PR comment carries. */
+export function formatTicketText(data, columns = TICKET_MAX_WIDTH + TICKET_INDENT) {
+    return renderTicket(data, { columns }).lines.join("\n");
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/**
+ * Print the receipt. A TTY (not CI) gets the ticket, its stamp landing one
+ * frame after the card; anything else gets the plain line. Both end with a
+ * blank line.
+ */
+export async function writeReceipt(summary, opts) {
+    const env = opts.env ?? process.env;
+    const { stream } = opts;
+    const color = opts.color ?? colorEnabled(stream, env);
+    const rich = opts.rich ?? richOutput(stream, env);
+    if (!rich) {
+        stream.write(`  ${renderReceiptLine(summary, color)}\n\n`);
+        return;
+    }
+    const data = { summary, workflow: opts.workflow, runId: opts.runId, crashed: opts.crashed };
+    const base = {
+        columns: terminalColumns(stream, env),
+        unicode: opts.unicode ?? supportsUnicode(env),
+        paint: createPaint(color),
+    };
+    const pad = " ".repeat(TICKET_INDENT);
+    const full = renderTicket(data, base);
+    const animate = (opts.animate ?? true) && full.stampRow >= 0;
+    if (!animate) {
+        stream.write(full.lines.map((l) => pad + l).join("\n") + "\n\n");
+        return;
+    }
+    const blank = renderTicket(data, { ...base, stamp: false });
+    stream.write(blank.lines.map((l) => pad + l).join("\n") + "\n");
+    await sleep(STAMP_DELAY_MS);
+    // Up to the stub row, redraw it with the stamp, back down below the ticket.
+    const up = full.lines.length - full.stampRow;
+    stream.write(`\x1B[${up}A\r\x1B[2K${pad}${full.lines[full.stampRow]}\x1B[${up}B\r\n`);
+}

package/dist/cli/try.d.ts

@@ -2,8 +2,8 @@
  * `sweny try`: a zero-credential demo (#475).
  *
  * Replays a recorded explain-repo run through the REAL executor, with a replay
- * harness standing in for the agent, so the real progress line, answer block
- * (#460), receipt, policy segment and PR-comment markdown (#396) are what a
+ * harness standing in for the agent, so the real progress lines, answer block
+ * (#460), receipt ticket, policy stamp and PR comment (#396, #479) are what a
  * user sees. No agent, no model, no network, no env credentials, no files
  * written (no `.sweny/runs`, no journal). The environment handed to the
  * executor is empty by construction.
@@ -14,6 +14,7 @@
 import type { Command } from "commander";
 import type { AgentHarness } from "../harness/types.js";
 import type { Workflow } from "../types.js";
+import { type Paint } from "./style.js";
 export interface TryFixtureNode {
     /** Recorded wall-clock time of the node. */
     duration_ms: number;
@@ -64,14 +65,16 @@ export declare function createReplayHarness(fixture: TryFixture, opts: {
     paceMs: number;
 }): AgentHarness;
 export declare const TRY_BANNER_TITLE = "Recorded demo";
-/** The real commands, same as the README quickstart. */
-export declare const TRY_NEXT_COMMANDS: readonly ["npm install -g @sweny-ai/core", "sweny new --template explain-repo --yes", "sweny workflow run .sweny/workflows/explain-repo.yml"];
+/** The one command to run next: scaffolds the same workflow on the user's repo and says how to run it. */
+export declare const TRY_NEXT_COMMAND = "npx @sweny-ai/core new --template explain-repo";
 /** Appended to `sweny try --help`. */
 export declare const TRY_HELP_NOTE: string;
-export declare function formatTryBanner(fixture: TryFixture): string;
-export declare function formatTryNext(): string;
+/** The tagline, then the demo notice as one dim line. */
+export declare function formatTryBanner(fixture: TryFixture, paint?: Paint, unicode?: boolean): string;
+/** The closing line: one command. */
+export declare function formatTryNext(paint?: Paint): string;
 export interface TryOptions {
-    /** Replay instantly. */
+    /** Replay instantly (and land the stamp without the one-frame pause). */
     fast?: boolean;
     /** Milliseconds each node takes to replay. Default 1200. Ignored with `fast`. */
     paceMs?: number;
@@ -79,8 +82,12 @@ export interface TryOptions {
     commentFile?: string;
     /** Output sink. Default stdout. */
     write?: (s: string) => void;
-    /** Rewrite progress lines in place. Default: stdout is a TTY. */
+    /** Rich output: spinner, ticket, color. Default: stdout is a TTY. */
     tty?: boolean;
+    /** Draw with Unicode. Default: what the terminal supports. */
+    unicode?: boolean;
+    /** Terminal width. Default: stdout's. */
+    columns?: number;
     fixture?: TryFixture;
 }
 export declare const DEFAULT_TRY_PACE_MS = 1200;