brito-cli 0.0.0-stage → 0.3.2

package/dist/ui/ui.js

@@ -0,0 +1,426 @@
+import { BOLD, CODE, ITALIC, OFF, c, cols, palette, useColor } from "./theme.js";
+import { renderBanner } from "./banner.js";
+import stringWidth from "string-width";
+export const NAME = "Brito";
+const isTTY = !!process.stdout.isTTY;
+const FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const FACES = ["(｡•́︿•̀｡)", "(⊙_⊙)", "(•̀ᴗ•́)و", "(¬‿¬)", "ʕ•ᴥ•ʔ", "(◕‿◕)", "(・・?)", "(｀･ω･´)"];
+const VERBS = ["pensando", "ponderando", "investigando", "mapeando o grafo", "conectando os pontos", "analisando", "rastreando chamadas", "ruminando", "fazendo hipóteses"];
+const DONE = ["(•̀ᴗ•́)و", "ヽ(´▽`)/", "(◕‿◕)"];
+const EMOJI = {
+    read_file: "📄", write_file: "📝", edit_file: "📝", glob: "📁", grep: "🔍", bash: "💻",
+    remember: "🧠", recall: "🧠", delegate: "🤖", skill_load: "🎓", skill_save: "🎓", skill_delete: "🎓",
+};
+const emojiOf = (name) => EMOJI[name] ?? (name.startsWith("graph_") ? "🔗" : "🔧");
+const fmtMs = (ms) => (ms < 1000 ? `${(ms / 1000).toFixed(1)}s` : ms < 60_000 ? `${(ms / 1000).toFixed(1)}s` : `${Math.floor(ms / 60_000)}m${Math.round((ms % 60_000) / 1000)}s`);
+/** Duração acumulada: 45.2s · 12m03s · 1h02m. */
+export const fmtDur = (ms) => {
+    const s = Math.round(ms / 1000);
+    if (ms < 60_000)
+        return `${(ms / 1000).toFixed(1)}s`;
+    if (s < 3600)
+        return `${Math.floor(s / 60)}m${String(s % 60).padStart(2, "0")}s`;
+    return `${Math.floor(s / 3600)}h${String(Math.floor((s % 3600) / 60)).padStart(2, "0")}m`;
+};
+export const fmtTokens = (n) => (n >= 1_000_000 ? `${(n / 1e6).toFixed(1).replace(/\.0$/, "")}M` : n >= 1000 ? `${(n / 1000).toFixed(1).replace(/\.0$/, "")}K` : String(n));
+/** Primeiro argumento "legível" da chamada, para a linha da tool. */
+function preview(input) {
+    if (!input || typeof input !== "object")
+        return "";
+    const v = Object.values(input).find((x) => typeof x === "string" && x.length > 0);
+    return v ? v.replace(/\s+/g, " ").slice(0, 60) : "";
+}
+const skillName = (input) => {
+    const n = input?.name;
+    return typeof n === "string" ? n : "";
+};
+/** Quebra uma linha por palavra em no máximo `w` colunas (palavra maior que `w` fica inteira). */
+function wrapLine(line, w) {
+    if (stringWidth(line) <= w)
+        return [line];
+    const out = [];
+    let cur = "";
+    for (const word of line.split(/\s+/).filter(Boolean)) {
+        if (cur && stringWidth(cur) + 1 + stringWidth(word) > w) {
+            out.push(cur);
+            cur = word;
+        }
+        else
+            cur = cur ? `${cur} ${word}` : word;
+    }
+    if (cur)
+        out.push(cur);
+    return out;
+}
+class UI {
+    busy = false;
+    paused = false;
+    visible = false; // spinner desenhado agora
+    timer;
+    t0 = 0;
+    frame = 0;
+    running = new Map();
+    textOpen = false;
+    lineStart = true;
+    seed = Math.floor(Math.random() * FACES.length);
+    dock = null;
+    /** soma do tempo de todos os turnos da sessão */
+    totalMs = 0;
+    /** skill carregada no turno atual (aparece na barra de status) */
+    activeSkill = "";
+    /** `/reasoning show|hide|full|clamp` */
+    reasoning = { show: true, full: false };
+    /** Com dock, toda saída vai para cima dele e o spinner mora na linha própria do dock. */
+    attachDock(d) { this.dock = d; }
+    /** Menu com setas + Enter (Esc cancela). Sem dock devolve null. */
+    select(title, options, current = 0) {
+        return this.dock ? this.dock.select(title, options, current) : Promise.resolve(null);
+    }
+    get canSelect() { return this.dock !== null; }
+    out(s) { if (this.dock)
+        this.dock.write(s);
+    else
+        process.stdout.write(s); }
+    // ---------- baixo nível ----------
+    clear() {
+        if (this.dock) {
+            this.dock.setSpinner(null);
+            return;
+        }
+        if (this.visible && isTTY) {
+            process.stdout.write("\r\x1b[2K");
+            this.visible = false;
+        }
+    }
+    spinnerLabel() {
+        const secs = (Date.now() - this.t0) / 1000;
+        const f = c.light(FRAMES[this.frame % FRAMES.length]);
+        if (this.running.size > 0) {
+            const names = [...new Set([...this.running.values()].map((r) => (r.name === "skill_load" && skillName(r.input) ? `skill ${skillName(r.input)}` : r.name)))];
+            const what = this.running.size === 1 ? names[0] : `${this.running.size} ferramentas`;
+            return `${f} ${c.muted(`executando ${what}…`)} ${c.dim(`(${secs.toFixed(1)}s)`)}`;
+        }
+        const face = FACES[(this.seed + Math.floor(secs / 2)) % FACES.length];
+        const verb = VERBS[(this.seed + Math.floor(secs / 3)) % VERBS.length];
+        return `${f} ${c.soft(face)} ${c.muted(`${verb}…`)} ${c.dim(`(${secs.toFixed(1)}s)`)}`;
+    }
+    draw() {
+        if (!isTTY)
+            return;
+        const show = this.busy && !this.paused && !this.textOpen;
+        if (this.dock) {
+            this.dock.setSpinner(show ? this.spinnerLabel() : null);
+            return;
+        }
+        if (!show)
+            return;
+        process.stdout.write(`\r\x1b[2K${this.spinnerLabel()}`);
+        this.visible = true;
+    }
+    /** Imprime uma linha sem quebrar o spinner. */
+    print(line = "") {
+        this.clear();
+        this.out(line + "\n");
+        this.draw();
+    }
+    // ---------- ciclo do turno ----------
+    turnStart() {
+        this.busy = true;
+        this.t0 = Date.now();
+        this.frame = 0;
+        if (isTTY)
+            this.timer = setInterval(() => { this.frame++; this.draw(); }, 90);
+        this.draw();
+    }
+    turnEnd(ok = true) {
+        this.textEnd();
+        this.busy = false;
+        this.running.clear();
+        this.activeSkill = "";
+        if (this.timer)
+            clearInterval(this.timer);
+        this.clear();
+        const ms = this.t0 ? Date.now() - this.t0 : 0;
+        this.t0 = 0;
+        this.totalMs += ms;
+        if (ok && ms)
+            this.print(c.dim(`${DONE[this.seed % DONE.length]} pronto! (${(ms / 1000).toFixed(1)}s · total ${fmtDur(this.totalMs)})`));
+    }
+    /** Libera o terminal para um prompt interativo (permissão). */
+    suspend() { this.paused = true; this.clear(); }
+    resume() { this.paused = false; this.draw(); }
+    // ---------- resposta do modelo ----------
+    lineW = 0;
+    word = "";
+    // markdown em streaming: b=**negrito**, i=*itálico*, k=`código`, fence=bloco ```
+    st = { b: false, i: false, k: false, fence: false };
+    wordStart = ""; // estilo ativo quando a palavra em andamento começou
+    run = { ch: "", n: 0, bol: false }; // sequência pendente de * ou ` (decidida pelo próximo caractere)
+    skip = false; // descarta o resto da linha do ``` (nome da linguagem)
+    bol = true; // só espaços até agora nesta linha
+    prev = " "; // último caractere resolvido
+    seq() {
+        const { b, i, k, fence } = this.st;
+        return k || fence ? CODE : (i ? ITALIC : "") + (b ? BOLD : "");
+    }
+    active() { const s = this.st; return s.b || s.i || s.k || s.fence; }
+    /** Aplica a mudança de estilo: no meio da palavra vira código ANSI; entre palavras vira o estilo inicial da próxima. */
+    restyle() {
+        if (this.word)
+            this.word += OFF + this.seq();
+        else
+            this.wordStart = this.seq();
+    }
+    resetStyle() {
+        this.st = { b: false, i: false, k: false, fence: false };
+        this.run = { ch: "", n: 0, bol: false };
+        this.wordStart = "";
+        this.skip = false;
+        this.bol = true;
+        this.prev = " ";
+    }
+    /** Descarrega a palavra em andamento, quebrando a linha antes dela se não couber. */
+    emitWord() {
+        if (!this.word)
+            return;
+        const w = stringWidth(this.word);
+        const room = cols() - 2;
+        if (this.lineW > 0 && this.lineW + w > room) {
+            this.out("\n");
+            this.lineStart = true;
+            this.lineW = 0;
+        }
+        if (this.lineStart) {
+            this.out(c.accent("│ "));
+            this.lineStart = false;
+        }
+        // o estilo é reaplicado por palavra: a borda e os espaços não herdam a cor
+        this.out(this.wordStart + this.word + (this.active() ? OFF : ""));
+        this.lineW += w;
+        this.word = "";
+        this.wordStart = this.seq();
+    }
+    /** Decide o que fazer com a sequência pendente de `*`/`` ` `` olhando o próximo caractere. */
+    resolve(next) {
+        const { ch, n, bol } = this.run;
+        this.run = { ch: "", n: 0, bol: false };
+        const s = this.st;
+        const lit = () => { for (let j = 0; j < n; j++)
+            this.put(ch); };
+        if (ch === "`") {
+            if (n >= 3 && bol) {
+                s.fence = !s.fence;
+                this.restyle();
+                this.skip = true;
+                return;
+            }
+            if (n <= 2 && !s.fence) {
+                s.k = !s.k;
+                this.restyle();
+                return;
+            }
+            return lit();
+        }
+        if (n > 3)
+            return lit();
+        const keys = n === 1 ? ["i"] : n === 2 ? ["b"] : ["b", "i"];
+        const nextWs = /\s/.test(next), prevWs = /\s/.test(this.prev);
+        if (keys.every((x) => s[x]) && !prevWs) {
+            keys.forEach((x) => (s[x] = false));
+            this.restyle();
+        }
+        else if (keys.every((x) => !s[x]) && !nextWs && !/[\p{L}\p{N}]/u.test(this.prev)) {
+            keys.forEach((x) => (s[x] = true));
+            this.restyle();
+        }
+        else
+            lit(); // `2 ** 3`, `a*b`, marcador solto: fica literal
+    }
+    feed(ch) {
+        if (ch === this.run.ch) {
+            this.run.n++;
+            return;
+        }
+        if (this.run.n)
+            this.resolve(ch);
+        if (this.skip) {
+            if (ch === "\n")
+                this.skip = false;
+            return;
+        }
+        const s = this.st;
+        const tick = ch === "`" && (!s.fence || this.bol);
+        const star = ch === "*" && !s.k && !s.fence;
+        if (tick || star) {
+            this.run = { ch, n: 1, bol: this.bol };
+            return;
+        }
+        this.put(ch);
+    }
+    put(ch) {
+        const blank = this.prev === "\n";
+        this.prev = ch;
+        if (ch === "\n") {
+            this.emitWord();
+            this.bol = true;
+            this.st.k = false; // código inline não atravessa linhas
+            if (blank && !this.st.fence) {
+                this.st.b = false;
+                this.st.i = false;
+            } // linha em branco encerra ênfase aberta
+            this.wordStart = this.seq();
+            this.out((this.lineStart ? c.accent("│") : "") + "\n");
+            this.lineStart = true;
+            this.lineW = 0;
+        }
+        else if (ch === " ") {
+            this.emitWord();
+            if (this.lineStart) {
+                this.out(c.accent("│ "));
+                this.lineStart = false;
+            }
+            if (this.lineW + 1 > cols() - 2) {
+                this.out("\n");
+                this.lineStart = true;
+                this.lineW = 0;
+            }
+            else {
+                this.out(" ");
+                this.lineW++;
+            }
+        }
+        else {
+            this.word += ch;
+            this.bol = false;
+        }
+    }
+    /** Texto do modelo em streaming, dentro da caixa, com quebra por palavra e borda em todas as linhas. */
+    text(chunk) {
+        if (!this.textOpen) {
+            this.clear();
+            const label = ` ${NAME} `;
+            this.out(c.accent("╭─") + c.bold(c.light(label)) + c.accent("─".repeat(Math.max(2, cols() - label.length - 2))) + "\n");
+            this.textOpen = true;
+            this.lineStart = true;
+            this.lineW = 0;
+            this.word = "";
+            this.resetStyle();
+        }
+        for (const ch of chunk)
+            this.feed(ch);
+    }
+    textEnd() {
+        if (!this.textOpen)
+            return;
+        if (this.run.n)
+            this.resolve("\n"); // marcador no fim da resposta: fecha se havia abertura, senão fica literal
+        this.emitWord();
+        this.resetStyle();
+        if (!this.lineStart)
+            this.out("\n");
+        this.out(c.accent("╰" + "─".repeat(cols() - 1)) + "\n");
+        this.textOpen = false;
+        this.draw();
+    }
+    // ---------- ferramentas ----------
+    toolStart(id, name, input) {
+        this.running.set(id, { name, input, t0: Date.now() });
+        if (name === "skill_load" && skillName(input))
+            this.activeSkill = skillName(input);
+        this.draw();
+    }
+    toolEnd(id, isError) {
+        const r = this.running.get(id);
+        if (!r)
+            return;
+        this.running.delete(id);
+        this.textEnd();
+        this.print(this.toolLine(r.name, r.input, Date.now() - r.t0, isError));
+    }
+    /** Só o prefixo + emoji + nome, sem argumento nem tempo. */
+    toolLabel(name) { return `${c.accent("┊")} ${emojiOf(name)} ${c.soft(name)}`; }
+    toolLine(name, input, ms, isError, indent = "") {
+        const arg = preview(input);
+        const mark = isError ? c.err("✗") : "";
+        return `${indent}${c.accent("┊")} ${emojiOf(name)} ${isError ? c.err(name) : c.soft(name)}${arg ? " " + c.muted(arg) : ""} ${c.dim(`(${fmtMs(ms)})`)} ${mark}`.trimEnd();
+    }
+    /** Linha de progresso de um subagente (indentada, com o rótulo dele). */
+    sub(label, text) { this.textEnd(); this.print(`  ${c.accent("┊")} ${c.light(`[${label}]`)} ${text}`); }
+    /** Raciocínio do modelo (`/reasoning show`): caixa tênue; recorta em 10 linhas, salvo `/reasoning full`. */
+    thinking(text) {
+        if (!this.reasoning.show)
+            return;
+        const body = text.trim();
+        if (!body)
+            return;
+        this.textEnd();
+        const w = cols();
+        const wrapped = body.split("\n").flatMap((l) => wrapLine(l.trimEnd(), w - 4));
+        const MAX = 10;
+        const cut = !this.reasoning.full && wrapped.length > MAX;
+        const lines = cut ? wrapped.slice(0, MAX) : wrapped;
+        const label = " raciocínio ";
+        this.print(c.dim(`┌─${label}${"─".repeat(Math.max(0, w - 3 - label.length))}┐`));
+        for (const l of lines)
+            this.print(c.dim(`│ ${l}`));
+        if (cut)
+            this.print(c.dim(`│ … +${wrapped.length - MAX} linhas (/reasoning full mostra tudo)`));
+        this.print(c.dim(`└${"─".repeat(w - 2)}┘`));
+    }
+    info(msg) { this.textEnd(); this.print(c.muted(msg)); }
+    warn(msg) { this.textEnd(); this.print(c.rgb(palette.warn)(msg)); }
+    error(msg) { this.textEnd(); this.print(c.err(msg)); }
+    // ---------- estrutura fixa ----------
+    rule() { return c.accent("─".repeat(cols())); }
+    /**
+     * Barra de status: cada indicador tem um rótulo para quem não conhece os números.
+     * Se não couber na largura do terminal, descarta primeiro os de menor prioridade (tempo, extra, tokens…).
+     */
+    statusLine(s) {
+        const pct = Math.min(100, Math.round((s.ctxTokens / s.ctxWindow) * 100));
+        const slots = 8, filled = Math.round((pct / 100) * slots);
+        const colour = pct >= 95 ? c.err : pct >= 80 ? c.rgb(palette.orange) : pct >= 50 ? c.warn : c.ok;
+        const bar = colour("█".repeat(filled)) + c.dim("░".repeat(slots - filled));
+        const mins = Math.floor((Date.now() - s.startedAt) / 60_000);
+        const active = this.totalMs + (this.busy && this.t0 ? Date.now() - this.t0 : 0);
+        const label = (t) => c.dim(t + " ");
+        // Taxa de acerto do cache de prompt (quanto mais alta, mais barato): só aparece quando há dado, como no Hermes.
+        const hit = s.cacheRead && s.input > 0 ? Math.min(100, (s.cacheRead / s.input) * 100) : undefined;
+        const hitColour = hit === undefined ? c.muted : hit >= 70 ? c.ok : hit >= 40 ? c.warn : c.err;
+        // [prioridade (maior = descarta primeiro), texto]
+        const segs = [
+            ...(s.mode ? [[0, s.mode]] : []),
+            [0, c.light("⬢ ") + c.bold(c.soft(s.model))],
+            [0, label("contexto") + c.muted(`${fmtTokens(s.ctxTokens)}/${fmtTokens(s.ctxWindow)}`) + ` [${bar}] ${colour(`${pct}%`)}`],
+            ...(hit !== undefined ? [[2, label("cache") + hitColour(`◎ ${Math.round(hit)}%`)]] : []),
+            [3, label("tokens") + c.muted(`↑${fmtTokens(s.input)} ↓${fmtTokens(s.output)}`)],
+            ...(s.cost !== undefined ? [[1, label("custo") + c.muted(`$${s.cost.toFixed(2)}`)]] : []),
+            ...(this.activeSkill ? [[1, c.light("🎓 ") + label("skill") + c.bold(c.soft(this.activeSkill))]] : []),
+            [4, label("tempo") + c.muted(mins < 1 ? "<1m" : `${mins}m`) + (active >= 1000 ? c.dim(` (ativo ${fmtDur(active)})`) : "")],
+            ...(s.extra ? [[5, c.muted(s.extra)]] : []),
+        ];
+        const sep = c.accent(" │ ");
+        const render = () => segs.map(([, t]) => t).join(sep);
+        while (segs.length > 2 && stringWidth(render()) > cols()) {
+            const worst = segs.reduce((w, x, i) => (x[0] > segs[w][0] ? i : w), 0);
+            if (segs[worst][0] === 0)
+                break;
+            segs.splice(worst, 1);
+        }
+        return render();
+    }
+    /** Legenda dos indicadores (comando /indicadores). */
+    statusLegend() {
+        return [
+            ["contexto", "tokens que o modelo está lendo agora / tamanho máximo da janela. Perto de 100% a conversa precisa ser compactada."],
+            ["cache", "% do prompt reaproveitado do cache (◎). Alto (verde) = respostas mais rápidas e baratas. Some enquanto não há dado."],
+            ["tokens", "total da sessão: ↑ enviados ao modelo (inclui cache) · ↓ gerados por ele."],
+            ["custo", "gasto estimado da sessão em dólares."],
+            ["tempo", "há quanto tempo a sessão está aberta · (ativo) soma do tempo gasto em todos os turnos."],
+            ["skill", "skill carregada (skill_load) no turno em andamento."],
+        ].map(([k, v]) => `  ${c.soft(k.padEnd(9))} ${c.muted(v)}`);
+    }
+    banner(info) { this.out(renderBanner(info) + "\n"); }
+}
+export const ui = new UI();
+export { c, useColor };

package/dist/ui/web-art.js

@@ -0,0 +1,131 @@
+import { RESET, c, mix, palette } from "./theme.js";
+/**
+ * A identidade visual do Brito: uma teia (raios + anéis em polígono, com nós nos cruzamentos), meio grafo, com o nome
+ * por cima. É gerada em vez de desenhada à mão para servir a qualquer tamanho de janela e os traços ficarem alinhados.
+ * Só usa tons derivados do roxo da marca (BRITO_COLOR): claro no centro, escurecendo até a borda.
+ */
+export const LOGO = [
+    "████  ████  █████ █████  ███ ",
+    "█   █ █   █   █     █   █   █",
+    "████  ████    █     █   █   █",
+    "█   █ █  █    █     █   █   █",
+    "████  █   █ █████   █    ███ ",
+];
+/** Tamanho da teia do banner compacto. */
+export const WEB_W = 33;
+export const WEB_H = 13;
+const blank = () => ({ ch: " ", kind: "empty" });
+const paintOf = (col) => c.rgb(col);
+/** Caractere de um segmento inteiro, pelo ângulo visual (a célula tem ~2x mais altura que largura): evita ─╱╲ misturados. */
+function strand(x0, y0, x1, y1) {
+    const dx = Math.abs(x1 - x0), dy = Math.abs(y1 - y0) * 2;
+    const angle = (Math.atan2(dy, dx) * 180) / Math.PI;
+    if (angle < 25)
+        return "─";
+    if (angle > 65)
+        return "│";
+    return (x1 - x0) * (y1 - y0) > 0 ? "╲" : "╱";
+}
+/** Traço de a até b (Bresenham) com um caractere só; só preenche célula vazia, então o que veio antes prevalece. */
+function line(grid, x0, y0, x1, y1, ch, paintAt) {
+    const dx = Math.abs(x1 - x0), dy = Math.abs(y1 - y0);
+    const sx = x0 < x1 ? 1 : -1, sy = y0 < y1 ? 1 : -1;
+    let err = dx - dy, x = x0, y = y0;
+    while (x !== x1 || y !== y1) {
+        const e2 = 2 * err;
+        if (e2 > -dy) {
+            err -= dy;
+            x += sx;
+        }
+        if (e2 < dx) {
+            err += dx;
+            y += sy;
+        }
+        if (grid[y]?.[x]?.kind === "empty")
+            grid[y][x] = { ch, kind: "strand", paint: paintAt(x, y) };
+    }
+}
+/** A teia crua de w x h células, centrada: anéis sólidos, raios pontilhados e nós nos cruzamentos. */
+export function webCanvas(w, h, { rings, spokes }) {
+    const grid = Array.from({ length: h }, () => Array.from({ length: w }, blank));
+    const cx = (w - 1) / 2, cy = (h - 1) / 2;
+    const vertex = (k, f) => {
+        const a = (2 * Math.PI * k) / spokes;
+        return [Math.round(cx + cx * f * Math.cos(a)), Math.round(cy + cy * f * Math.sin(a))];
+    };
+    /** 0 no centro, 1 na borda. */
+    const dist = (x, y) => Math.min(1, Math.hypot((x - cx) / Math.max(1, cx), (y - cy) / Math.max(1, cy)));
+    const ringPaint = (x, y) => paintOf(mix(palette.light, palette.accent, Math.pow(dist(x, y), 0.8)));
+    const spokePaint = (x, y) => paintOf(mix(palette.soft, palette.accent, 0.35 + 0.65 * dist(x, y)));
+    for (let i = 1; i <= rings; i++) {
+        const f = i / rings;
+        for (let k = 0; k < spokes; k++) {
+            const [x0, y0] = vertex(k, f), [x1, y1] = vertex((k + 1) % spokes, f);
+            line(grid, x0, y0, x1, y1, strand(x0, y0, x1, y1), ringPaint);
+        }
+    }
+    for (let k = 0; k < spokes; k++) {
+        const [x, y] = vertex(k, 1);
+        line(grid, Math.round(cx), Math.round(cy), x, y, "·", spokePaint);
+    }
+    for (let i = 1; i <= rings; i++) {
+        for (let k = 0; k < spokes; k++) {
+            const [x, y] = vertex(k, i / rings);
+            grid[y][x] = { ch: i === rings ? "◉" : "○", kind: "node", paint: paintOf(mix(palette.soft, palette.accent, 0.15 + 0.7 * dist(x, y))) };
+        }
+    }
+    grid[Math.round(cy)][Math.round(cx)] = { ch: "◉", kind: "node", paint: paintOf(palette.soft) };
+    return grid;
+}
+/** O nome por cima da teia. Na faixa das letras os traços somem (só os nós aparecem pelos vãos): o nome fica nítido. */
+export function stampLogo(grid, left, top) {
+    LOGO.forEach((l, r) => {
+        const row = grid[top + r];
+        if (!row)
+            return;
+        const first = l.search(/\S/), last = l.search(/\s*$/) - 1;
+        for (let x = first - 1; x <= last + 1; x++)
+            if (row[left + x]?.kind === "strand")
+                row[left + x] = blank();
+        for (let x = 0; x < l.length; x++) {
+            if (l[x] !== " " && row[left + x])
+                row[left + x] = { ch: l[x], kind: "text", paint: paintOf(mix(palette.accent, palette.soft, r / (LOGO.length - 1))) };
+        }
+    });
+}
+/** Uma linha já colorida (ANSI) vira células: o que a cor não alcança fica sem pintura. */
+function ansiCells(s) {
+    const out = [];
+    let prefix = "";
+    for (const part of s.split(/(\x1b\[[0-9;]*m)/)) {
+        if (!part)
+            continue;
+        if (part.startsWith("\x1b[")) {
+            prefix = part === RESET ? "" : prefix + part;
+            continue;
+        }
+        const p = prefix;
+        for (const ch of part)
+            out.push({ ch, kind: "text", paint: p ? (t) => p + t + RESET : undefined });
+    }
+    return out;
+}
+/** Escreve texto sobre a teia; a faixa da linha (mais 1 coluna de cada lado) é limpa para o texto ler bem. */
+export function overlayText(grid, x, y, ansi) {
+    const row = grid[y];
+    if (!row)
+        return;
+    const cells = ansiCells(ansi);
+    for (let k = -1; k <= cells.length; k++)
+        if (row[x + k])
+            row[x + k] = blank();
+    cells.forEach((cell, k) => { if (row[x + k])
+        row[x + k] = cell; });
+}
+export const serialize = (grid) => grid.map((row) => row.map((cell) => (cell.paint ? cell.paint(cell.ch) : cell.ch)).join(""));
+/** O logotipo do banner compacto: BRITO sobre uma teia pequena. */
+export function webLogo() {
+    const grid = webCanvas(WEB_W, WEB_H, { rings: 3, spokes: 8 });
+    stampLogo(grid, Math.floor((WEB_W - LOGO[0].length) / 2), Math.round((WEB_H - 1) / 2) - Math.floor(LOGO.length / 2));
+    return serialize(grid);
+}

package/dist/util/diff.js

@@ -0,0 +1,36 @@
+/** Diff de linhas (LCS) com contexto curto, para mostrar ao usuário o que muda numa skill. */
+export function lineDiff(before, after, context = 2) {
+    const a = before.split("\n"), b = after.split("\n");
+    const lcs = Array.from({ length: a.length + 1 }, () => new Array(b.length + 1).fill(0));
+    for (let i = a.length - 1; i >= 0; i--)
+        for (let j = b.length - 1; j >= 0; j--)
+            lcs[i][j] = a[i] === b[j] ? lcs[i + 1][j + 1] + 1 : Math.max(lcs[i + 1][j], lcs[i][j + 1]);
+    const ops = [];
+    let i = 0, j = 0;
+    while (i < a.length && j < b.length) {
+        if (a[i] === b[j]) {
+            ops.push({ t: " ", s: a[i] });
+            i++;
+            j++;
+        }
+        else if (lcs[i + 1][j] >= lcs[i][j + 1])
+            ops.push({ t: "-", s: a[i++] });
+        else
+            ops.push({ t: "+", s: b[j++] });
+    }
+    while (i < a.length)
+        ops.push({ t: "-", s: a[i++] });
+    while (j < b.length)
+        ops.push({ t: "+", s: b[j++] });
+    if (ops.every((o) => o.t === " "))
+        return [];
+    const keep = ops.map((o, k) => o.t !== " " || ops.slice(Math.max(0, k - context), k + context + 1).some((x) => x.t !== " "));
+    const out = [];
+    ops.forEach((o, k) => {
+        if (keep[k])
+            out.push(`${o.t} ${o.s}`);
+        else if (out[out.length - 1] !== "  …")
+            out.push("  …");
+    });
+    return out;
+}

package/dist/util/frontmatter.js

@@ -0,0 +1,16 @@
+export function parseFrontmatter(text) {
+    const m = text.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+    if (!m)
+        return null;
+    const meta = {};
+    for (const line of m[1].split(/\r?\n/)) {
+        const kv = line.match(/^([\w-]+):\s*(.*)$/);
+        if (kv)
+            meta[kv[1]] = kv[2].trim();
+    }
+    return { meta, body: m[2] };
+}
+export function stringifyFrontmatter(meta, body) {
+    const head = Object.entries(meta).map(([k, v]) => `${k}: ${String(v).replace(/\s*\n\s*/g, " ")}`).join("\n");
+    return `---\n${head}\n---\n${body.trim()}\n`;
+}

package/package.json

@@ -1,6 +1,68 @@
 {
   "name": "brito-cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.3.2",
+  "description": "Coding-agent CLI with a code knowledge graph, memory and reviewable skills / CLI de agente de código com grafo de conhecimento, memória e skills revisáveis",
+  "type": "module",
+  "bin": {
+    "brito": "dist/cli.js"
+  },
+  "scripts": {
+    "dev": "tsx src/cli.ts",
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "test": "tsx --test test/*.test.ts",
+    "eval:learn": "tsx test/eval-learn.ts",
+    "prepare": "tsc",
+    "prepublishOnly": "npm run typecheck && npm test"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.131.0",
+    "@modelcontextprotocol/sdk": "^1.32.0",
+    "commander": "latest",
+    "fast-glob": "latest",
+    "kuzu": "latest",
+    "string-width": "^8.3.0",
+    "tree-sitter-wasms": "latest",
+    "web-tree-sitter": "0.24.7",
+    "zod": "latest"
+  },
+  "devDependencies": {
+    "@types/node": "latest",
+    "tsx": "latest",
+    "typescript": "latest"
+  },
+  "license": "PolyForm-Noncommercial-1.0.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/wilsonbrito/brito.git"
+  },
+  "homepage": "https://github.com/wilsonbrito/brito#readme",
+  "bugs": {
+    "url": "https://github.com/wilsonbrito/brito/issues"
+  },
+  "author": "Wilson Brito",
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "dist",
+    ".brito/agents",
+    "README.md",
+    "README.pt-BR.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "cli",
+    "agent",
+    "coding-agent",
+    "llm",
+    "knowledge-graph",
+    "code-graph",
+    "mcp",
+    "claude",
+    "tree-sitter",
+    "svelte",
+    "typescript",
+    "python"
+  ]
+}