brito-cli 0.0.0-stage → 0.3.2

package/dist/ui/dock.js

@@ -0,0 +1,616 @@
+import fs from "node:fs";
+import path from "node:path";
+import stringWidth from "string-width";
+import { c, stripAnsi, truncAnsi } from "./theme.js";
+const seg = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+const graphemes = (s) => Array.from(seg.segment(s), (x) => x.segment);
+const ANSI = /\x1b\[[0-9;]*[A-Za-z]/y;
+const MAX_INPUT_ROWS = 8;
+const MAX_MENU = 7;
+const PASTE_RE = /\[colado #(\d+): [^\]]*\]/g;
+export class Dock {
+    opts;
+    onSubmit = () => { };
+    onInterrupt = () => { };
+    onEOF = () => { };
+    onCycleMode = () => { };
+    rows = process.stdout.rows || 24;
+    cols = process.stdout.columns || 80;
+    // cursor virtual da saída (1-based) e área ocupada pelo dock
+    outRow = 1;
+    outCol = 1;
+    skipNL = false;
+    top = 1;
+    height = 0;
+    spinner = null;
+    busy = false;
+    promptOverride = null;
+    buf = [];
+    cur = 0;
+    history = [];
+    hIdx = -1;
+    draft = "";
+    pastes = new Map();
+    pasteN = 0;
+    pasting = false;
+    pasteBuf = "";
+    menuSel = 0;
+    picker = null;
+    dsr;
+    started = false;
+    onData = (d) => this.feed(d);
+    onResize = () => {
+        this.rows = process.stdout.rows || 24;
+        this.cols = process.stdout.columns || 80;
+        this.outRow = Math.min(this.outRow, this.rows);
+        process.stdout.write(this.paintSeq(false));
+    };
+    constructor(opts) {
+        this.opts = opts;
+        if (opts.historyFile) {
+            try {
+                this.history = fs.readFileSync(opts.historyFile, "utf8").split("\n").filter(Boolean).map((l) => JSON.parse(l)).slice(-500);
+            }
+            catch { /* sem histórico */ }
+        }
+    }
+    // ---------------------------------------------------------------- ciclo de vida
+    async start() {
+        process.stdin.setEncoding("utf8");
+        process.stdin.setRawMode(true);
+        process.stdin.on("data", this.onData);
+        process.stdin.resume();
+        process.stdout.on("resize", this.onResize);
+        process.on("exit", () => this.restoreTerminal());
+        process.stdout.write("\x1b[?2004h"); // bracketed paste
+        const [r, col] = await this.getCursor();
+        this.outRow = Math.min(r, this.rows);
+        this.outCol = Math.min(col, this.cols);
+        this.started = true;
+        process.stdout.write(this.paintSeq(false));
+    }
+    /** Remove o dock e deixa o cursor na linha seguinte à última saída. */
+    stop() {
+        if (!this.started)
+            return;
+        this.started = false;
+        let out = this.clearSeq();
+        out += `\x1b[${this.outRow};${this.outCol}H`;
+        if (this.outCol > 1)
+            out += "\r\n";
+        process.stdout.write(out);
+        this.restoreTerminal();
+        process.stdin.off("data", this.onData);
+        process.stdout.off("resize", this.onResize);
+        process.stdin.pause();
+    }
+    restoreTerminal() {
+        try {
+            process.stdout.write("\x1b[?2004l\x1b[?25h");
+            process.stdin.setRawMode?.(false);
+        }
+        catch { /* já fechado */ }
+    }
+    getCursor() {
+        return new Promise((resolve) => {
+            const t = setTimeout(() => { this.dsr = undefined; resolve([this.rows, 1]); }, 400);
+            this.dsr = (r, col) => { clearTimeout(t); this.dsr = undefined; resolve([r, col]); };
+            process.stdout.write("\x1b[6n");
+        });
+    }
+    // ---------------------------------------------------------------- API pública
+    /** Escreve texto acima do dock (aceita ANSI e quebras de linha). */
+    write(text) {
+        if (!this.started) {
+            process.stdout.write(text);
+            return;
+        }
+        let out = this.clearSeq();
+        if (this.skipNL && text.startsWith("\n"))
+            text = text.slice(1);
+        this.skipNL = false;
+        out += `\x1b[${this.outRow};${this.outCol}H`;
+        let row = this.outRow, col = this.outCol;
+        const down = () => { row = Math.min(row + 1, this.rows); col = 1; };
+        text = text.replace(/\r/g, "").replace(/\t/g, "  ");
+        let i = 0;
+        while (i < text.length) {
+            ANSI.lastIndex = i;
+            const m = ANSI.exec(text);
+            if (m) {
+                out += m[0];
+                i += m[0].length;
+                continue;
+            }
+            if (text[i] === "\n") {
+                out += "\r\n";
+                down();
+                i++;
+                continue;
+            }
+            // próximo grafema (até o próximo ESC ou \n)
+            let j = i;
+            while (j < text.length && text[j] !== "\n" && text[j] !== "\x1b")
+                j++;
+            if (j === i) {
+                out += text[i];
+                i++;
+                continue;
+            } // ESC solto
+            for (const g of graphemes(text.slice(i, j))) {
+                const w = stringWidth(g);
+                if (w === 0) {
+                    out += g;
+                    continue;
+                }
+                if (col + w - 1 > this.cols) {
+                    out += "\r\n";
+                    down();
+                }
+                out += g;
+                col += w;
+            }
+            i = j;
+        }
+        if (col > this.cols) {
+            out += "\r\n";
+            down();
+            this.skipNL = true;
+        }
+        this.outRow = row;
+        this.outCol = col;
+        process.stdout.write(out + this.paintSeq(true));
+    }
+    setSpinner(text) {
+        if (text === this.spinner)
+            return;
+        this.spinner = text;
+        if (this.started)
+            process.stdout.write(this.paintSeq(false));
+    }
+    setBusy(b) { this.busy = b; if (this.started)
+        process.stdout.write(this.paintSeq(false)); }
+    /** Troca o prompt (ex.: pergunta de permissão). null restaura o padrão. */
+    setPrompt(p) { this.promptOverride = p; if (this.started)
+        process.stdout.write(this.paintSeq(false)); }
+    /** Menu de escolha no lugar da caixa de entrada: ↑↓ navegam, Enter confirma, Esc/Ctrl+C cancelam. */
+    select(title, options, current = 0) {
+        return new Promise((resolve) => {
+            this.picker = { title, options, sel: Math.max(0, Math.min(current, options.length - 1)), done: resolve };
+            this.repaint();
+        });
+    }
+    closePicker(i) {
+        const p = this.picker;
+        if (!p)
+            return;
+        this.picker = null;
+        this.repaint();
+        p.done(i);
+    }
+    hasText() { return this.buf.length > 0; }
+    clearInput() { this.buf = []; this.cur = 0; this.hIdx = -1; this.menuSel = 0; this.repaint(); }
+    repaint() { if (this.started)
+        process.stdout.write(this.paintSeq(false)); }
+    // ---------------------------------------------------------------- layout e pintura
+    clearSeq() {
+        let s = "";
+        for (let r = 0; r < this.height; r++)
+            s += `\x1b[${this.top + r};1H\x1b[2K`;
+        return s;
+    }
+    promptStr() {
+        return this.promptOverride ?? (this.busy ? c.light("◉ ") : c.bold(c.light("❯ ")));
+    }
+    menuItems() {
+        const t = this.buf.join("");
+        if (!t.startsWith("/") || /\s/.test(t))
+            return [];
+        const m = this.opts.commands.filter((x) => x.name.startsWith(t.toLowerCase()));
+        return m.length === 1 && m[0].name === t ? [] : m.slice(0, MAX_MENU);
+    }
+    /** Quebra o buffer em linhas visuais e acha a posição do cursor. */
+    layoutInput(width) {
+        const lines = [""];
+        let r = 0, col = 0, curRow = 0, curCol = 0;
+        for (let i = 0; i <= this.buf.length; i++) {
+            if (i === this.cur) {
+                curRow = r;
+                curCol = col;
+            }
+            if (i === this.buf.length)
+                break;
+            const g = this.buf[i];
+            if (g === "\n") {
+                r++;
+                col = 0;
+                lines.push("");
+                continue;
+            }
+            const w = stringWidth(g);
+            if (col + w > width) {
+                r++;
+                col = 0;
+                lines.push("");
+                if (i === this.cur) {
+                    curRow = r;
+                    curCol = 0;
+                }
+            }
+            lines[r] += g;
+            col += w;
+        }
+        return { lines, curRow, curCol };
+    }
+    compose() {
+        const pStr = this.promptStr();
+        const pw = stringWidth(stripAnsi(pStr));
+        const width = Math.max(10, this.cols - pw);
+        const { lines, curRow, curCol } = this.layoutInput(width);
+        const visible = Math.min(lines.length, MAX_INPUT_ROWS);
+        let start = Math.max(0, Math.min(lines.length - visible, curRow - Math.floor(visible / 2)));
+        if (curRow < start)
+            start = curRow;
+        if (curRow >= start + visible)
+            start = curRow - visible + 1;
+        const out = [];
+        if (this.spinner)
+            out.push(this.spinner);
+        out.push(this.opts.status());
+        const rule = c.accent("─".repeat(this.cols));
+        if (this.picker) {
+            const p = this.picker;
+            out.push(rule, c.bold(c.light(" " + p.title)));
+            const w = Math.max(...p.options.map((o) => o.label.length));
+            p.options.forEach((o, k) => {
+                const row = ` ${o.label.padEnd(w)}${o.hint ? "  " + o.hint : ""}`;
+                out.push(k === p.sel ? c.bold(c.light("▸" + row)) : c.muted(" " + row));
+            });
+            out.push(c.dim(" ↑↓ escolhe · Enter confirma · Esc cancela"));
+            return { out, cursor: { row: out.length, col: 1 } };
+        }
+        out.push(rule);
+        const inputStart = out.length;
+        for (let k = 0; k < visible; k++) {
+            const idx = start + k;
+            const lead = idx === 0 ? pStr : " ".repeat(pw);
+            let text = lines[idx];
+            if (idx === 0 && this.buf.length === 0) {
+                text = c.dim(this.promptOverride ? "" : this.busy ? "digite para enfileirar · Ctrl+C interrompe" : "mensagem · / comandos · !cmd shell · Alt+Enter nova linha · ⇧Tab modo");
+            }
+            else {
+                // escrita do usuário: negrito vermelho (mesma cor de "tudo liberado"); marcadores de colagem em âmbar
+                text = text.split(/(\[colado #\d+: [^\]]*\])/).map((p, i) => (i % 2 ? c.rgb([255, 200, 120])(p) : p ? c.bold(c.err(p)) : p)).join("");
+            }
+            out.push(lead + text);
+        }
+        out.push(rule);
+        const items = this.menuItems();
+        if (items.length) {
+            this.menuSel = Math.min(this.menuSel, items.length - 1);
+            const nameW = Math.max(...items.map((x) => x.name.length));
+            items.forEach((it, k) => {
+                const row = ` ${it.name.padEnd(nameW)}  ${it.desc}`;
+                out.push(k === this.menuSel ? c.bold(c.light("▸" + row)) : c.muted(" " + row));
+            });
+        }
+        return { out, cursor: { row: inputStart + (curRow - start), col: pw + Math.min(curCol, width) + 1 } };
+    }
+    /** Sequência que (re)pinta o dock logo abaixo do cursor virtual de saída. */
+    paintSeq(alreadyCleared) {
+        let s = alreadyCleared ? "" : this.clearSeq();
+        const { out, cursor } = this.compose();
+        const h = Math.min(out.length, this.rows);
+        const visibleLines = out.slice(out.length - h);
+        let base = this.outCol > 1 ? this.outRow + 1 : this.outRow;
+        const overflow = base + h - 1 - this.rows;
+        if (overflow > 0) {
+            s += `\x1b[${this.rows};1H${"\n".repeat(overflow)}`; // rola a tela inteira
+            base -= overflow;
+            this.outRow = Math.max(1, this.outRow - overflow);
+        }
+        for (let r = 0; r < h; r++) {
+            const line = visibleLines[r];
+            s += `\x1b[${base + r};1H\x1b[2K${stripAnsi(line).length > this.cols ? truncAnsi(line, this.cols) : line}`;
+        }
+        this.top = base;
+        this.height = h;
+        const row = base + cursor.row - (out.length - h);
+        s += `\x1b[${Math.min(row, this.rows)};${Math.min(cursor.col, this.cols)}H`;
+        return s;
+    }
+    // ---------------------------------------------------------------- entrada
+    feedPicker(data) {
+        const p = this.picker;
+        const n = p.options.length;
+        if (/^\x1b\[[AB]|^\x1bO[AB]/.test(data) || data === "k" || data === "j") {
+            p.sel = (p.sel + (data.endsWith("A") || data === "k" ? -1 : 1) + n) % n;
+            this.repaint();
+        }
+        else if (data === "\r" || data === "\n")
+            this.closePicker(p.sel);
+        else if (data === "\x1b" || data === "\x03")
+            this.closePicker(null);
+    }
+    feed(data) {
+        if (this.picker) {
+            this.feedPicker(data);
+            return;
+        }
+        let i = 0;
+        while (i < data.length) {
+            if (this.pasting) {
+                const end = data.indexOf("\x1b[201~", i);
+                if (end === -1) {
+                    this.pasteBuf += data.slice(i);
+                    return;
+                }
+                this.pasteBuf += data.slice(i, end);
+                this.finishPaste();
+                this.pasting = false;
+                i = end + 6;
+                continue;
+            }
+            const rest = data.slice(i);
+            if (rest.startsWith("\x1b[200~")) {
+                this.pasting = true;
+                this.pasteBuf = "";
+                i += 6;
+                continue;
+            }
+            let m = rest.match(/^\x1b\[(\d+);(\d+)R/);
+            if (m) {
+                this.dsr?.(+m[1], +m[2]);
+                i += m[0].length;
+                continue;
+            }
+            m = rest.match(/^\x1b\[([\d;]*)([A-Za-z~])/);
+            if (m) {
+                this.csi(m[1], m[2]);
+                i += m[0].length;
+                continue;
+            }
+            m = rest.match(/^\x1bO([A-Za-z])/);
+            if (m) {
+                this.csi("", m[1]);
+                i += m[0].length;
+                continue;
+            }
+            if (rest[0] === "\x1b") {
+                if (rest.length > 1) {
+                    this.alt(rest[1]);
+                    i += 2;
+                }
+                else {
+                    this.menuSel = 0;
+                    i++;
+                }
+                continue;
+            }
+            const code = rest.charCodeAt(0);
+            if (code < 0x20 || code === 0x7f) {
+                this.ctrl(code);
+                i++;
+                continue;
+            }
+            const run = rest.match(/^[^\x00-\x1f\x7f\x1b]+/)[0];
+            this.insert(run);
+            i += run.length;
+        }
+        this.repaint();
+    }
+    insert(text) {
+        const gs = graphemes(text);
+        this.buf.splice(this.cur, 0, ...gs);
+        this.cur += gs.length;
+        this.menuSel = 0;
+        this.hIdx = -1;
+    }
+    finishPaste() {
+        const text = this.pasteBuf.replace(/\r\n?/g, "\n");
+        const lines = text.split("\n").length;
+        if (lines >= 2 || text.length > 300) {
+            const n = ++this.pasteN;
+            this.pastes.set(n, text);
+            const size = text.length >= 1000 ? `${(text.length / 1000).toFixed(1)}K` : String(text.length);
+            this.insert(`[colado #${n}: ${lines} linhas, ${size} chars]`);
+        }
+        else
+            this.insert(text);
+        this.repaint();
+    }
+    ctrl(code) {
+        switch (code) {
+            case 0x03:
+                this.onInterrupt();
+                break; // Ctrl+C
+            case 0x04:
+                if (this.buf.length === 0)
+                    this.onEOF();
+                else
+                    this.del();
+                break; // Ctrl+D
+            case 0x0d:
+                this.submit();
+                break; // Enter
+            case 0x0a:
+                this.insert("\n");
+                break; // Ctrl+J
+            case 0x7f:
+            case 0x08:
+                if (this.cur > 0) {
+                    this.buf.splice(--this.cur, 1);
+                    this.menuSel = 0;
+                }
+                break;
+            case 0x01:
+                this.cur = this.lineStart();
+                break; // Ctrl+A
+            case 0x05:
+                this.cur = this.lineEnd();
+                break; // Ctrl+E
+            case 0x0b:
+                this.buf.splice(this.cur, this.lineEnd() - this.cur);
+                break; // Ctrl+K
+            case 0x15: {
+                const s = this.lineStart();
+                this.buf.splice(s, this.cur - s);
+                this.cur = s;
+                break;
+            } // Ctrl+U
+            case 0x17:
+                this.deleteWord();
+                break; // Ctrl+W
+            case 0x09:
+                this.complete();
+                break; // Tab
+            case 0x0c:
+                this.write("");
+                break; // Ctrl+L: repinta
+        }
+    }
+    alt(ch) {
+        if (ch === "\r" || ch === "\n")
+            this.insert("\n");
+        else if (ch === "b")
+            this.cur = this.wordLeft();
+        else if (ch === "f")
+            this.cur = this.wordRight();
+        else if (ch === "\x7f")
+            this.deleteWord();
+    }
+    csi(params, final) {
+        const mod = Number(params.split(";")[1] ?? 1);
+        const ctrlOrAlt = mod === 5 || mod === 3;
+        switch (final) {
+            case "A":
+                if (this.menuItems().length)
+                    this.menuSel = Math.max(0, this.menuSel - 1);
+                else
+                    this.historyMove(-1);
+                break;
+            case "B":
+                if (this.menuItems().length)
+                    this.menuSel = Math.min(this.menuItems().length - 1, this.menuSel + 1);
+                else
+                    this.historyMove(1);
+                break;
+            case "C":
+                this.cur = ctrlOrAlt ? this.wordRight() : Math.min(this.buf.length, this.cur + 1);
+                break;
+            case "D":
+                this.cur = ctrlOrAlt ? this.wordLeft() : Math.max(0, this.cur - 1);
+                break;
+            case "Z":
+                this.onCycleMode();
+                break; // Shift+Tab
+            case "H":
+                this.cur = this.lineStart();
+                break;
+            case "F":
+                this.cur = this.lineEnd();
+                break;
+            case "~":
+                if (params.startsWith("3"))
+                    this.del();
+                else if (params.startsWith("1") || params.startsWith("7"))
+                    this.cur = this.lineStart();
+                else if (params.startsWith("4") || params.startsWith("8"))
+                    this.cur = this.lineEnd();
+                break;
+            case "u":
+                if (params.startsWith("13")) {
+                    if (mod === 1)
+                        this.submit();
+                    else
+                        this.insert("\n");
+                }
+                break; // CSI-u: Shift+Enter
+        }
+    }
+    del() { if (this.cur < this.buf.length)
+        this.buf.splice(this.cur, 1); }
+    lineStart() { let i = this.cur; while (i > 0 && this.buf[i - 1] !== "\n")
+        i--; return i; }
+    lineEnd() { let i = this.cur; while (i < this.buf.length && this.buf[i] !== "\n")
+        i++; return i; }
+    wordLeft() { let i = this.cur; while (i > 0 && /\s/.test(this.buf[i - 1]))
+        i--; while (i > 0 && !/\s/.test(this.buf[i - 1]))
+        i--; return i; }
+    wordRight() { let i = this.cur; while (i < this.buf.length && /\s/.test(this.buf[i]))
+        i++; while (i < this.buf.length && !/\s/.test(this.buf[i]))
+        i++; return i; }
+    deleteWord() { const s = this.wordLeft(); this.buf.splice(s, this.cur - s); this.cur = s; }
+    complete() {
+        const items = this.menuItems();
+        if (!items.length)
+            return;
+        const pick = items[Math.min(this.menuSel, items.length - 1)];
+        this.buf = graphemes(pick.name + " ");
+        this.cur = this.buf.length;
+        this.menuSel = 0;
+    }
+    historyMove(dir) {
+        // Em entrada multilinha, as setas movem o cursor entre linhas antes de navegar no histórico.
+        const text = this.buf.join("");
+        if (text.includes("\n")) {
+            const s = this.lineStart();
+            if (dir === -1 && s > 0) {
+                const col = this.cur - s;
+                let ps = s - 1;
+                while (ps > 0 && this.buf[ps - 1] !== "\n")
+                    ps--;
+                this.cur = Math.min(ps + col, s - 1);
+                return;
+            }
+            const e = this.lineEnd();
+            if (dir === 1 && e < this.buf.length) {
+                const col = this.cur - s;
+                let ne = e + 1;
+                while (ne < this.buf.length && this.buf[ne] !== "\n")
+                    ne++;
+                this.cur = Math.min(e + 1 + col, ne);
+                return;
+            }
+        }
+        if (!this.history.length)
+            return;
+        if (this.hIdx === -1) {
+            if (dir === 1)
+                return;
+            this.draft = text;
+            this.hIdx = this.history.length;
+        }
+        this.hIdx = Math.max(0, Math.min(this.history.length, this.hIdx + dir));
+        this.buf = graphemes(this.hIdx === this.history.length ? this.draft : this.history[this.hIdx]);
+        this.cur = this.buf.length;
+        if (this.hIdx === this.history.length)
+            this.hIdx = -1;
+    }
+    submit() {
+        // Comando parcial com o menu aberto (ex.: "/ag"): Enter completa o item selecionado antes de enviar.
+        if (this.menuItems().length)
+            this.complete();
+        const raw = this.buf.join("").trimEnd();
+        if (!raw.trim())
+            return;
+        const text = raw.replace(PASTE_RE, (_m, n) => this.pastes.get(Number(n)) ?? _m);
+        if (!this.promptOverride) {
+            this.history.push(raw);
+            if (this.opts.historyFile) {
+                try {
+                    fs.mkdirSync(path.dirname(this.opts.historyFile), { recursive: true });
+                    fs.appendFileSync(this.opts.historyFile, JSON.stringify(raw) + "\n");
+                }
+                catch { /* sem histórico */ }
+            }
+        }
+        this.buf = [];
+        this.cur = 0;
+        this.hIdx = -1;
+        this.menuSel = 0;
+        this.pastes.clear();
+        this.repaint();
+        this.onSubmit(text);
+    }
+}

package/dist/ui/theme.js

@@ -0,0 +1,63 @@
+const hex = (h) => {
+    const m = h.replace("#", "").match(/^([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i);
+    if (!m)
+        throw new Error(`cor inválida: ${h}`);
+    return [parseInt(m[1], 16), parseInt(m[2], 16), parseInt(m[3], 16)];
+};
+export const mix = (a, b, t) => a.map((v, i) => Math.round(v + (b[i] - v) * t));
+/** Cor da marca. Troque com BRITO_COLOR=#rrggbb. */
+const BASE = hex(process.env.BRITO_COLOR ?? "#8119bd");
+export const useColor = !process.env.NO_COLOR && (!!process.env.FORCE_COLOR || !!process.stdout.isTTY);
+const truecolor = /truecolor|24bit/i.test(process.env.COLORTERM ?? "");
+const to256 = ([r, g, b]) => 16 + 36 * Math.round((r / 255) * 5) + 6 * Math.round((g / 255) * 5) + Math.round((b / 255) * 5);
+const fgSeq = (c) => (truecolor ? `\x1b[38;2;${c[0]};${c[1]};${c[2]}m` : `\x1b[38;5;${to256(c)}m`);
+export const RESET = "\x1b[0m";
+const wrap = (open) => (s) => (useColor ? `${open}${s}${RESET}` : s);
+const fg = (c) => wrap(fgSeq(c));
+/** O roxo #8119bd é escuro: bordas e barras usam a cor pura; textos e rótulos usam o tom claro. */
+export const palette = {
+    accent: BASE,
+    light: mix(BASE, [255, 255, 255], 0.45),
+    soft: mix(BASE, [255, 255, 255], 0.7),
+    muted: mix(BASE, [128, 128, 128], 0.55),
+    ok: hex("#4caf50"),
+    warn: hex("#ffa726"),
+    orange: hex("#ff7043"),
+    err: hex("#ef5350"),
+};
+export const c = {
+    accent: fg(palette.accent),
+    light: fg(palette.light),
+    soft: fg(palette.soft),
+    muted: fg(palette.muted),
+    ok: fg(palette.ok),
+    warn: fg(palette.warn),
+    err: fg(palette.err),
+    bold: wrap("\x1b[1m"),
+    dim: wrap("\x1b[2m"),
+    rgb: (col) => fg(col),
+};
+/** Estilos do markdown no texto do modelo: **negrito** roxo claro, *itálico* lilás, `código` laranja. */
+export const BOLD = useColor ? `\x1b[1m${fgSeq(palette.light)}` : "";
+export const ITALIC = useColor ? `\x1b[3m${fgSeq(palette.soft)}` : "";
+export const CODE = useColor ? fgSeq(palette.orange) : "";
+export const OFF = useColor ? RESET : "";
+export const stripAnsi = (s) => s.replace(/\x1b\[[0-9;]*m/g, "");
+export const cols = () => Math.max(40, process.stdout.columns || 80);
+/** Corta uma string com ANSI para no máximo `n` colunas visíveis, preservando as cores. */
+export function truncAnsi(s, n) {
+    let out = "", vis = 0;
+    for (let i = 0; i < s.length; i++) {
+        const m = s.slice(i).match(/^\x1b\[[0-9;]*m/);
+        if (m) {
+            out += m[0];
+            i += m[0].length - 1;
+            continue;
+        }
+        if (vis >= n - 1 && stripAnsi(s).length > n)
+            return out + "…" + (useColor ? RESET : "");
+        out += s[i];
+        vis++;
+    }
+    return out;
+}