@cruxy/cli 0.7.0 → 0.9.0

package/dist/render/highlight.js

@@ -0,0 +1,265 @@
+const FRESH_CARRY = { blockComment: false, stringDelim: null };
+/** A fence opener: ``` or longer, optional language word. */
+const FENCE_OPEN = /^(`{3,})([\w+#.-]*)\s*$/;
+/** A line that could still grow into a fence opener. */
+const FENCE_PLAUSIBLE = /^(?:`{1,2}|`{3,}[\w+#.-]*\s*)$/;
+/**
+ * Create the per-segment streaming highlighter. `highlightLine` is injectable
+ * for tests (e.g. to prove a throwing tokenizer degrades to plain text).
+ */
+export function createStreamHighlighter(c, highlightLine = defaultLineHighlighter(c)) {
+    let mode = "prose";
+    let atLineStart = true;
+    let lineBuf = "";
+    let lang = null;
+    let carry = FRESH_CARRY;
+    /** Highlight one completed code line; any tokenizer throw → plain text. */
+    const styleCodeLine = (line) => {
+        try {
+            const res = highlightLine(line, lang, carry);
+            carry = res.carry;
+            return res.text;
+        }
+        catch {
+            carry = FRESH_CARRY; // state is suspect after a throw; start clean
+            return line;
+        }
+    };
+    const push = (delta) => {
+        let out = "";
+        for (const ch of delta) {
+            if (mode === "prose") {
+                if (atLineStart && ch === "`") {
+                    mode = "maybe-fence";
+                    lineBuf = ch;
+                }
+                else {
+                    out += ch;
+                    atLineStart = ch === "\n";
+                }
+            }
+            else if (mode === "maybe-fence") {
+                if (ch === "\n") {
+                    const m = FENCE_OPEN.exec(lineBuf);
+                    if (m) {
+                        lang = m[2] ? m[2].toLowerCase() : null;
+                        carry = FRESH_CARRY;
+                        mode = "code";
+                        out += c.dim(lineBuf) + "\n";
+                    }
+                    else {
+                        mode = "prose";
+                        out += lineBuf + "\n";
+                    }
+                    lineBuf = "";
+                    atLineStart = true;
+                }
+                else {
+                    lineBuf += ch;
+                    if (!FENCE_PLAUSIBLE.test(lineBuf)) {
+                        // Can no longer become a fence (e.g. inline `code`) — release it.
+                        mode = "prose";
+                        out += lineBuf;
+                        lineBuf = "";
+                        atLineStart = false;
+                    }
+                }
+            }
+            else {
+                // code
+                if (ch === "\n") {
+                    if (/^`{3,}\s*$/.test(lineBuf)) {
+                        mode = "prose";
+                        out += c.dim(lineBuf) + "\n";
+                    }
+                    else {
+                        out += styleCodeLine(lineBuf) + "\n";
+                    }
+                    lineBuf = "";
+                    atLineStart = true;
+                }
+                else {
+                    lineBuf += ch;
+                }
+            }
+        }
+        return out;
+    };
+    const flush = () => {
+        // Segment ended mid-line: release the held text as-is (highlighted when we
+        // know it's code — styled *before* the language resets) and start the next
+        // segment back in prose state.
+        const out = lineBuf === "" ? "" : mode === "code" ? styleCodeLine(lineBuf) : lineBuf;
+        mode = "prose";
+        lineBuf = "";
+        atLineStart = true;
+        lang = null;
+        carry = FRESH_CARRY;
+        return out;
+    };
+    return { push, flush };
+}
+const JS_KEYWORDS = "abstract as async await break case catch class const continue debugger default delete do else enum export extends false finally for from function get if implements import in instanceof interface let new null of private protected public readonly return satisfies set static super switch this throw true try type typeof undefined var void while with yield";
+const PY_KEYWORDS = "and as assert async await break class continue def del elif else except False finally for from global if import in is lambda None nonlocal not or pass raise return True try while with yield match case self";
+const SH_KEYWORDS = "if then else elif fi for while until do done case esac function in select time coproc break continue return exit export local readonly declare set unset shift trap source alias cd echo printf read test";
+const GO_KEYWORDS = "break case chan const continue default defer else fallthrough for func go goto if import interface map nil package range return select struct switch true false type var";
+const RUST_KEYWORDS = "as async await break const continue crate dyn else enum extern false fn for if impl in let loop match mod move mut pub ref return self Self static struct super trait true type unsafe use where while";
+const words = (list) => new Set(list.split(" "));
+const JS_DEF = {
+    keywords: words(JS_KEYWORDS),
+    lineComment: "//",
+    blockComment: ["/*", "*/"],
+    quotes: ['"', "'", "`"],
+    multiline: ["`"],
+};
+const LANGS = {
+    js: JS_DEF,
+    jsx: JS_DEF,
+    ts: JS_DEF,
+    tsx: JS_DEF,
+    javascript: JS_DEF,
+    typescript: JS_DEF,
+    json: {
+        keywords: words("true false null"),
+        quotes: ['"'],
+        multiline: [],
+    },
+    py: {
+        keywords: words(PY_KEYWORDS),
+        lineComment: "#",
+        quotes: ['"', "'", '"""', "'''"],
+        multiline: ['"""', "'''"],
+    },
+    sh: {
+        keywords: words(SH_KEYWORDS),
+        lineComment: "#",
+        quotes: ['"', "'"],
+        multiline: [],
+    },
+    go: {
+        keywords: words(GO_KEYWORDS),
+        lineComment: "//",
+        blockComment: ["/*", "*/"],
+        quotes: ['"', "'", "`"],
+        multiline: ["`"],
+    },
+    rust: {
+        keywords: words(RUST_KEYWORDS),
+        lineComment: "//",
+        blockComment: ["/*", "*/"],
+        quotes: ['"'],
+        multiline: [],
+    },
+};
+// Aliases.
+LANGS.python = LANGS.py;
+LANGS.bash = LANGS.sh;
+LANGS.shell = LANGS.sh;
+LANGS.zsh = LANGS.sh;
+LANGS.golang = LANGS.go;
+LANGS.rs = LANGS.rust;
+/** Word characters for keyword/identifier scanning. */
+const WORD = /[A-Za-z0-9_$]/;
+/**
+ * Build the default per-line tokenizer over `c`. A plain left-to-right scan:
+ * comments dim, strings green, keywords magenta, numbers yellow, everything
+ * else untouched. Unknown language → identity.
+ */
+export function defaultLineHighlighter(c) {
+    return (line, lang, carry) => {
+        const def = lang ? LANGS[lang] : undefined;
+        if (!def)
+            return { text: line, carry };
+        // Longest quote first so `"""` wins over `"` in python.
+        const quotes = [...def.quotes].sort((a, b) => b.length - a.length);
+        let out = "";
+        let i = 0;
+        let next = { ...carry };
+        // Resume a multi-line construct from the previous line.
+        if (next.blockComment && def.blockComment) {
+            const close = line.indexOf(def.blockComment[1]);
+            if (close === -1)
+                return { text: c.dim(line), carry: next };
+            const end = close + def.blockComment[1].length;
+            out += c.dim(line.slice(0, end));
+            i = end;
+            next.blockComment = false;
+        }
+        else if (next.stringDelim) {
+            const close = findStringEnd(line, 0, next.stringDelim);
+            if (close === -1)
+                return { text: c.green(line), carry: next };
+            out += c.green(line.slice(0, close));
+            i = close;
+            next.stringDelim = null;
+        }
+        while (i < line.length) {
+            const rest = line.slice(i);
+            if (def.lineComment && rest.startsWith(def.lineComment)) {
+                out += c.dim(rest);
+                i = line.length;
+                break;
+            }
+            if (def.blockComment && rest.startsWith(def.blockComment[0])) {
+                const close = line.indexOf(def.blockComment[1], i + def.blockComment[0].length);
+                if (close === -1) {
+                    out += c.dim(rest);
+                    next = { ...next, blockComment: true };
+                    i = line.length;
+                    break;
+                }
+                const end = close + def.blockComment[1].length;
+                out += c.dim(line.slice(i, end));
+                i = end;
+                continue;
+            }
+            const quote = quotes.find((q) => rest.startsWith(q));
+            if (quote) {
+                const close = findStringEnd(line, i + quote.length, quote);
+                if (close === -1) {
+                    out += c.green(rest);
+                    if (def.multiline.includes(quote))
+                        next = { ...next, stringDelim: quote };
+                    i = line.length;
+                    break;
+                }
+                out += c.green(line.slice(i, close));
+                i = close;
+                continue;
+            }
+            const ch = line[i];
+            if (WORD.test(ch)) {
+                let j = i + 1;
+                while (j < line.length && WORD.test(line[j]))
+                    j++;
+                const word = line.slice(i, j);
+                if (def.keywords.has(word))
+                    out += c.magenta(word);
+                else if (/^\d/.test(word))
+                    out += c.yellow(word);
+                else
+                    out += word;
+                i = j;
+                continue;
+            }
+            out += ch;
+            i++;
+        }
+        return { text: out, carry: next };
+    };
+}
+/**
+ * Index just past the closing `delim` starting the scan at `from`, honoring
+ * backslash escapes; -1 when the string does not close on this line.
+ */
+function findStringEnd(line, from, delim) {
+    for (let i = from; i < line.length; i++) {
+        if (line[i] === "\\") {
+            i++;
+            continue;
+        }
+        if (line.startsWith(delim, i))
+            return i + delim.length;
+    }
+    return -1;
+}

package/dist/render/index.d.ts

@@ -0,0 +1,15 @@
+import type { RenderStream, StreamRenderer } from "./types.js";
+export type { ProgressState, RenderCapabilities, RenderPhase, RenderStream, StreamRenderer, TokenUsage, ToolLifecycleEvent, } from "./types.js";
+export { detectCapabilities } from "./capabilities.js";
+export { composeStatusLine, describePhase, ELAPSED_AFTER_MS, formatElapsed, formatTokens, phaseIdentity, } from "./state.js";
+export { renderActionPreview, PREVIEW_MAX_LINES, type Colors } from "./diff.js";
+export { createStreamHighlighter, defaultLineHighlighter, type HighlightCarry, type LineHighlighter, type StreamHighlighter, } from "./highlight.js";
+export { PlainRenderer } from "./plain-renderer.js";
+export { TtyRenderer } from "./tty-renderer.js";
+/**
+ * Build the renderer for the detected environment: the managed-live-region
+ * {@link TtyRenderer} when cursor control is safe, otherwise the append-only
+ * {@link PlainRenderer} (pipes, CI, `TERM=dumb`). Everything downstream talks
+ * to the {@link StreamRenderer} interface and never re-probes the terminal.
+ */
+export declare function createRenderer(out?: RenderStream, err?: RenderStream, env?: NodeJS.ProcessEnv): StreamRenderer;

package/dist/render/index.js

@@ -0,0 +1,21 @@
+import { detectCapabilities } from "./capabilities.js";
+import { PlainRenderer } from "./plain-renderer.js";
+import { TtyRenderer } from "./tty-renderer.js";
+export { detectCapabilities } from "./capabilities.js";
+export { composeStatusLine, describePhase, ELAPSED_AFTER_MS, formatElapsed, formatTokens, phaseIdentity, } from "./state.js";
+export { renderActionPreview, PREVIEW_MAX_LINES } from "./diff.js";
+export { createStreamHighlighter, defaultLineHighlighter, } from "./highlight.js";
+export { PlainRenderer } from "./plain-renderer.js";
+export { TtyRenderer } from "./tty-renderer.js";
+/**
+ * Build the renderer for the detected environment: the managed-live-region
+ * {@link TtyRenderer} when cursor control is safe, otherwise the append-only
+ * {@link PlainRenderer} (pipes, CI, `TERM=dumb`). Everything downstream talks
+ * to the {@link StreamRenderer} interface and never re-probes the terminal.
+ */
+export function createRenderer(out = process.stdout, err = process.stderr, env = process.env) {
+    const caps = detectCapabilities(out, env);
+    return caps.cursor
+        ? new TtyRenderer(caps, out)
+        : new PlainRenderer(caps, out, err);
+}

package/dist/render/plain-renderer.d.ts

@@ -0,0 +1,38 @@
+import type { ActionPreview } from "../tools/types.js";
+import type { RenderCapabilities, RenderStream, StreamRenderer, ToolLifecycleEvent } from "./types.js";
+/**
+ * The append-only renderer for pipes, CI, and cursor-less terminals. Emits no
+ * cursor-control sequences ever, and no color unless the capabilities say so
+ * (FORCE_COLOR); with color off, not a single ANSI byte leaves this class.
+ *
+ * Assistant text goes to `out` verbatim (beyond the per-turn leading-newline
+ * trim) so piped stdout stays pure model output; chrome (`note`) goes to `err`,
+ * matching the logger's stdout/stderr split. Transient `status` has no meaning
+ * in an append-only medium and is dropped — the loop reports anything durable
+ * via `note`.
+ */
+export declare class PlainRenderer implements StreamRenderer {
+    readonly caps: RenderCapabilities;
+    private readonly out;
+    private readonly err;
+    private readonly colors;
+    /** Per-turn leading-newline trim; also tells endSegment whether to newline. */
+    private print;
+    private wroteInSegment;
+    /** In-flight tool call (serial by contract) for the end-note duration. */
+    private toolStart;
+    constructor(caps: RenderCapabilities, out: RenderStream, err: RenderStream);
+    private newPrinter;
+    beginTurn(): void;
+    write(delta: string): void;
+    endSegment(): void;
+    note(text: string): void;
+    preview(preview: ActionPreview): void;
+    status(): void;
+    setPhase(): void;
+    progress(): void;
+    toolLifecycle(event: ToolLifecycleEvent): void;
+    promptResolved(): void;
+    endTurn(): void;
+    close(): void;
+}

package/dist/render/plain-renderer.js

@@ -0,0 +1,87 @@
+import pc from "picocolors";
+import { createStreamPrinter } from "../cli/stream-print.js";
+import { renderActionPreview } from "./diff.js";
+import { ELAPSED_AFTER_MS, formatElapsed } from "./state.js";
+/**
+ * The append-only renderer for pipes, CI, and cursor-less terminals. Emits no
+ * cursor-control sequences ever, and no color unless the capabilities say so
+ * (FORCE_COLOR); with color off, not a single ANSI byte leaves this class.
+ *
+ * Assistant text goes to `out` verbatim (beyond the per-turn leading-newline
+ * trim) so piped stdout stays pure model output; chrome (`note`) goes to `err`,
+ * matching the logger's stdout/stderr split. Transient `status` has no meaning
+ * in an append-only medium and is dropped — the loop reports anything durable
+ * via `note`.
+ */
+export class PlainRenderer {
+    caps;
+    out;
+    err;
+    colors;
+    /** Per-turn leading-newline trim; also tells endSegment whether to newline. */
+    print;
+    wroteInSegment = false;
+    /** In-flight tool call (serial by contract) for the end-note duration. */
+    toolStart = null;
+    constructor(caps, out, err) {
+        this.caps = caps;
+        this.out = out;
+        this.err = err;
+        this.colors = pc.createColors(caps.color);
+        this.print = this.newPrinter();
+    }
+    newPrinter() {
+        return createStreamPrinter((text) => {
+            this.wroteInSegment = true;
+            this.out.write(text);
+        });
+    }
+    beginTurn() {
+        this.print = this.newPrinter();
+        this.wroteInSegment = false;
+    }
+    write(delta) {
+        this.print(delta);
+    }
+    endSegment() {
+        if (this.wroteInSegment)
+            this.out.write("\n");
+        this.wroteInSegment = false;
+    }
+    note(text) {
+        this.err.write(this.colors.dim(text) + "\n");
+    }
+    preview(preview) {
+        const block = renderActionPreview(preview, this.colors);
+        if (block)
+            this.out.write(block + "\n");
+    }
+    status() {
+        // Append-only medium: transient state is dropped by design.
+    }
+    setPhase() {
+        // Phases are live-region state; there is no live region here (U.4).
+    }
+    progress() {
+        // The committed plan trail (C.31, via PromptIO) is the record in this
+        // medium; a live [i/n] prefix would just duplicate it line by line.
+    }
+    toolLifecycle(event) {
+        if (event.event === "start") {
+            // Silent: the end note is the single durable line per call — a start
+            // line too would double the chrome in CI logs for no information.
+            this.toolStart = { label: event.label, at: Date.now() };
+            return;
+        }
+        const started = this.toolStart?.label === event.label ? this.toolStart : null;
+        this.toolStart = null;
+        const elapsed = started === null ? 0 : Date.now() - started.at;
+        const suffix = elapsed >= ELAPSED_AFTER_MS ? ` (${formatElapsed(elapsed)})` : "";
+        this.note(`${event.ok ? "✓" : "✗"} ${event.label}${suffix}`);
+    }
+    promptResolved() {
+        // No live region to restore.
+    }
+    endTurn() { }
+    close() { }
+}

package/dist/render/state.d.ts

@@ -0,0 +1,31 @@
+import type { ProgressState, RenderPhase } from "./types.js";
+/**
+ * The U.4 state→text mapping: pure data → string, like plan/render.ts and
+ * diff.ts, so both renderers (and tests) share one composition with no
+ * terminal in sight. Color is deliberately absent — the live line is drawn
+ * dim as a whole by the TTY renderer; state text is content, not chrome.
+ */
+/**
+ * Threshold before elapsed time appears on a live state or a committed tool
+ * note. Below this, a timer is noise; above it, it's the answer to "is this
+ * stuck?".
+ */
+export declare const ELAPSED_AFTER_MS = 5000;
+/** `342`, `1.2k`, `3.4M` — token counts at status-line width. */
+export declare function formatTokens(n: number): string;
+/** `37s`, `2m08s` — durations at status-line width. */
+export declare function formatElapsed(ms: number): string;
+/** The live-line text for a phase. `awaiting-approval` never renders (the line hides). */
+export declare function describePhase(phase: RenderPhase): string;
+/**
+ * Identity key for the elapsed clock: the clock resets when the phase becomes
+ * a *different activity*, not on every payload update — a thinking phase that
+ * gains token counts keeps its start time; a new tool label starts fresh.
+ */
+export declare function phaseIdentity(phase: RenderPhase | null): string;
+/**
+ * Compose the single live line: `[2/5] title · read_file src/x.ts… (12s)`.
+ * Elapsed appears only past {@link ELAPSED_AFTER_MS} — callers pass it only
+ * when they can keep it ticking honestly (no timer → no frozen number).
+ */
+export declare function composeStatusLine(progress: ProgressState | null, phase: RenderPhase | null, elapsedMs?: number): string;

package/dist/render/state.js

@@ -0,0 +1,83 @@
+/**
+ * The U.4 state→text mapping: pure data → string, like plan/render.ts and
+ * diff.ts, so both renderers (and tests) share one composition with no
+ * terminal in sight. Color is deliberately absent — the live line is drawn
+ * dim as a whole by the TTY renderer; state text is content, not chrome.
+ */
+/**
+ * Threshold before elapsed time appears on a live state or a committed tool
+ * note. Below this, a timer is noise; above it, it's the answer to "is this
+ * stuck?".
+ */
+export const ELAPSED_AFTER_MS = 5_000;
+/** `342`, `1.2k`, `3.4M` — token counts at status-line width. */
+export function formatTokens(n) {
+    if (n < 1_000)
+        return String(n);
+    const scaled = n < 1_000_000 ? n / 1_000 : n / 1_000_000;
+    const unit = n < 1_000_000 ? "k" : "M";
+    const s = scaled.toFixed(1);
+    return (s.endsWith(".0") ? s.slice(0, -2) : s) + unit;
+}
+/** `37s`, `2m08s` — durations at status-line width. */
+export function formatElapsed(ms) {
+    const seconds = Math.floor(ms / 1000);
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    return `${minutes}m${String(seconds % 60).padStart(2, "0")}s`;
+}
+/** The live-line text for a phase. `awaiting-approval` never renders (the line hides). */
+export function describePhase(phase) {
+    switch (phase.kind) {
+        case "thinking": {
+            const t = phase.tokens;
+            // Honest numbers only: no usage yet → no figure at all.
+            return t && t.input + t.output > 0
+                ? `thinking… · tokens ↑${formatTokens(t.input)} ↓${formatTokens(t.output)}`
+                : "thinking…";
+        }
+        case "calling-tool":
+            return `${phase.label}…`;
+        case "awaiting-approval":
+            return "awaiting approval…";
+        case "executing-step":
+            return "working…";
+        case "subagent":
+            return `subagent: ${phase.label}…`;
+    }
+}
+/**
+ * Identity key for the elapsed clock: the clock resets when the phase becomes
+ * a *different activity*, not on every payload update — a thinking phase that
+ * gains token counts keeps its start time; a new tool label starts fresh.
+ */
+export function phaseIdentity(phase) {
+    if (phase === null)
+        return "";
+    switch (phase.kind) {
+        case "calling-tool":
+            return `calling-tool:${phase.label}`;
+        case "subagent":
+            return `subagent:${phase.label}`;
+        default:
+            return phase.kind;
+    }
+}
+/**
+ * Compose the single live line: `[2/5] title · read_file src/x.ts… (12s)`.
+ * Elapsed appears only past {@link ELAPSED_AFTER_MS} — callers pass it only
+ * when they can keep it ticking honestly (no timer → no frozen number).
+ */
+export function composeStatusLine(progress, phase, elapsedMs) {
+    const parts = [];
+    if (progress)
+        parts.push(`[${progress.step}/${progress.of}] ${progress.title}`);
+    if (phase)
+        parts.push(describePhase(phase));
+    const line = parts.join(" · ");
+    if (elapsedMs !== undefined && elapsedMs >= ELAPSED_AFTER_MS) {
+        return `${line} (${formatElapsed(elapsedMs)})`;
+    }
+    return line;
+}

package/dist/render/tty-renderer.d.ts

@@ -0,0 +1,83 @@
+import type { ActionPreview } from "../tools/types.js";
+import type { ProgressState, RenderCapabilities, RenderPhase, RenderStream, StreamRenderer, ToolLifecycleEvent } from "./types.js";
+/**
+ * The interactive renderer: committed content is append-only; the one transient
+ * thing on screen is a single managed status line, redrawn in place.
+ *
+ * The no-flicker discipline, concretely:
+ * - Only the status line is ever rewritten, via `\r` + erase-line — never a
+ *   screen clear, never a repaint of committed rows.
+ * - Every committed write first erases the status line, so the live region is
+ *   always the last row and committed text can never interleave with it. A
+ *   committed write *dismisses* the status (it does not redraw underneath), so
+ *   nothing re-renders per delta while text streams.
+ * - The status text is hard-truncated to the terminal width: a soft-wrapped
+ *   status would span two rows and erase-line could no longer clean it up.
+ *
+ * Fenced code blocks are highlighted incrementally (see highlight.ts): prose
+ * deltas pass straight through, code is styled line-by-line on arrival.
+ *
+ * U.4 layers semantic state onto the SAME single live line — no new screen
+ * real estate, no extra timers. Two registers compose into it:
+ * - `phase` (loop-owned; cleared by endTurn) — thinking / calling-tool / …
+ * - `progressState` (plan-executor-owned; cleared only via progress(null))
+ * A committed write still only *hides* the drawn line (registers survive);
+ * the next state transition redraws. Nothing redraws per streamed delta, so
+ * the U.2 first-chunk-immediate guarantee is untouched.
+ */
+export declare class TtyRenderer implements StreamRenderer {
+    readonly caps: RenderCapabilities;
+    private readonly out;
+    private readonly colors;
+    private print;
+    private highlighter;
+    private wroteInSegment;
+    /** Ad-hoc/legacy status text; wins over composed state when set. */
+    private rawStatus;
+    private phase;
+    private progressState;
+    /** When the current phase *identity* began — drives honest elapsed display. */
+    private phaseStartedAt;
+    /** In-flight tool call (serial by contract) for end-note duration. */
+    private toolStart;
+    /** Phase (+ its clock) displaced by an approval prompt, for promptResolved. */
+    private displaced;
+    /** Whether the live line is currently drawn on screen. */
+    private lineVisible;
+    private timer;
+    private frame;
+    private closed;
+    constructor(caps: RenderCapabilities, out: RenderStream);
+    private newPrinter;
+    /** Append committed content, erasing the status line first if one is live. */
+    private commit;
+    /**
+     * Erase the drawn live line and stop the spinner — WITHOUT clearing the
+     * state registers. Committed content takes the screen; the next state
+     * transition redraws with full context. (This is what keeps streaming
+     * zero-cost: no redraw-under per delta.)
+     */
+    private hideLine;
+    private stopTimer;
+    /**
+     * The current live-line text, composed from the registers. `null` means the
+     * line must be hidden: nothing to say, or an interactive prompt owns the
+     * terminal (`awaiting-approval` — two things can't share the last row).
+     */
+    private currentLine;
+    /** Redraw the live line from current state, or hide it when there is none. */
+    private refresh;
+    private drawLine;
+    beginTurn(): void;
+    write(delta: string): void;
+    endSegment(): void;
+    note(text: string): void;
+    preview(preview: ActionPreview): void;
+    status(text: string | null): void;
+    setPhase(phase: RenderPhase | null): void;
+    progress(state: ProgressState | null): void;
+    toolLifecycle(event: ToolLifecycleEvent): void;
+    promptResolved(): void;
+    endTurn(): void;
+    close(): void;
+}