brito-cli 0.3.2 → 0.5.0

package/dist/skills/store.js

@@ -22,14 +22,18 @@ function parse(text, scope) {
         updated: meta.updated ?? today(),
         lastUsed: meta.lastUsed ?? meta.updated ?? today(),
         refs: (meta.refs ?? "").split(",").map((r) => r.trim()).filter(Boolean),
+        status: meta.status === "trial" ? "trial" : "active",
+        origin: meta.origin === "auto" ? "auto" : "manual",
+        wins: Number(meta.wins) || 0,
+        losses: Number(meta.losses) || 0,
         body: body.trim(),
         scope,
     };
 }
-function write(root, s) {
+export function writeSkill(root, s) {
     const file = fileOf(root, s.scope, s.name);
     fs.mkdirSync(path.dirname(file), { recursive: true });
-    fs.writeFileSync(file, stringifyFrontmatter({ name: s.name, description: s.description, version: s.version, uses: s.uses, created: s.created, updated: s.updated, lastUsed: s.lastUsed, refs: s.refs.join(", ") }, s.body));
+    fs.writeFileSync(file, stringifyFrontmatter({ name: s.name, description: s.description, version: s.version, uses: s.uses, created: s.created, updated: s.updated, lastUsed: s.lastUsed, refs: s.refs.join(", "), status: s.status, origin: s.origin, wins: s.wins, losses: s.losses }, s.body));
 }
 /** Lê uma skill de um escopo específico. */
 export function getSkillIn(root, name, scope) {
@@ -131,8 +135,12 @@ export function validate(input) {
 export function targetScope(root, name, scope) {
     return scope ?? getSkill(root, name)?.scope ?? "project";
 }
-/** Cria ou atualiza. A versão anterior vai para `history/vN.md`. */
-export function saveSkill(root, input, scope) {
+/**
+ * Cria ou atualiza. A versão anterior vai para `history/vN.md`.
+ * `opts.auto` = gravação sem revisão humana (reflexão autônoma): skill nova nasce em teste; atualizar mantém a origem, e
+ * uma skill em teste zera o placar (conteúdo novo = hipótese nova). Sem `auto`, um humano aprovou: vira ativa e manual.
+ */
+export function saveSkill(root, input, scope, opts = {}) {
     validate(input);
     const target = targetScope(root, input.name, scope);
     const prev = getSkillIn(root, input.name, target);
@@ -150,10 +158,14 @@ export function saveSkill(root, input, scope) {
         updated: today(),
         lastUsed: prev?.lastUsed ?? today(),
         refs: input.refs ?? prev?.refs ?? [],
+        status: opts.auto ? (prev?.status ?? "trial") : "active",
+        origin: opts.auto ? (prev?.origin ?? "auto") : "manual",
+        wins: opts.auto && prev?.status === "trial" ? 0 : prev?.wins ?? 0,
+        losses: opts.auto && prev?.status === "trial" ? 0 : prev?.losses ?? 0,
         body: input.body.trim(),
         scope: target,
     };
-    write(root, skill);
+    writeSkill(root, skill);
     return { created: !prev, version: skill.version, scope: target };
 }
 /** Propostas aguardando revisão (modo bypass): ficam fora do índice, pois `listScope` ignora diretórios com ponto. */
@@ -204,7 +216,7 @@ export function rejectPending(root, name) {
 export function bumpUses(root, name) {
     const s = getSkill(root, name);
     if (s)
-        write(root, { ...s, uses: s.uses + 1, lastUsed: today() });
+        writeSkill(root, { ...s, uses: s.uses + 1, lastUsed: today() });
 }
 /** Move para `.trash` do próprio escopo em vez de apagar. */
 export function deleteSkill(root, name, scope) {
@@ -230,5 +242,5 @@ export function promoteSkill(root, name) {
 /** Índice compacto para o system prompt (divulgação progressiva: o corpo só entra via skill_load). */
 export function skillsIndex(root, max = 40, now = Date.now()) {
     const all = listSkills(root, now).slice(0, max);
-    return all.length ? all.map((s) => `- ${s.name}${s.scope === "global" ? " (global)" : ""}${staleRefs(root, s).length ? " [refs obsoletas]" : ""}: ${s.description}`).join("\n") : "";
+    return all.length ? all.map((s) => `- ${s.name}${s.scope === "global" ? " (global)" : ""}${s.status === "trial" ? " (em teste)" : ""}${staleRefs(root, s).length ? " [refs obsoletas]" : ""}: ${s.description}`).join("\n") : "";
 }

package/dist/skills/trial.js

@@ -0,0 +1,71 @@
+import { daysSince, deleteSkill, getSkill, lintSkill, listSkills, savePending, saveSkill, writeSkill } from "./store.js";
+export const skillsMode = () => (process.env.BRITO_SKILLS === "ask" || process.env.BRITO_SKILLS === "off" ? process.env.BRITO_SKILLS : "auto");
+/** Usos bem-sucedidos para promover (com no máximo 1 tropeço a cada 3 sucessos). */
+export const PROMOTE_WINS = 3;
+/** Falhas que arquivam uma skill em teste sem mais vitórias que falhas. */
+export const ARCHIVE_LOSSES = 2;
+/** Skill em teste que ninguém carregou neste prazo é arquivada. */
+export const TRIAL_DAYS = 21;
+/** Teto de skills novas criadas sozinhas por dia (contido: cada uma vira instrução para o agente). */
+export const DAILY_LIMIT = 3;
+/** Registra o resultado de um turno que usou a skill. Devolve um aviso se ela foi promovida ou arquivada. */
+export function recordOutcome(root, name, win) {
+    const s = getSkill(root, name);
+    if (!s)
+        return null;
+    const next = { ...s, wins: s.wins + (win ? 1 : 0), losses: s.losses + (win ? 0 : 1) };
+    if (s.origin === "auto") {
+        if (s.status === "trial") {
+            if (next.wins >= PROMOTE_WINS && next.wins >= 3 * next.losses) {
+                writeSkill(root, { ...next, status: "active" });
+                return `skill ${name} promovida: ${next.wins} usos bem-sucedidos, ${next.losses} com tropeço`;
+            }
+            if (next.losses >= ARCHIVE_LOSSES && next.losses >= next.wins) {
+                deleteSkill(root, name, s.scope);
+                return `skill ${name} arquivada: ${next.losses} usos com tropeço e ${next.wins} bem-sucedidos (recupere em .brito/skills/.trash)`;
+            }
+        }
+        else if (next.losses >= 3 && next.losses > next.wins) {
+            deleteSkill(root, name, s.scope);
+            return `skill ${name} arquivada: passou a falhar (${next.losses} tropeços, ${next.wins} sucessos)`;
+        }
+    }
+    writeSkill(root, next);
+    return null;
+}
+/** Arquiva as skills em teste que ninguém usou no prazo. */
+export function expireTrials(root, now = Date.now()) {
+    const out = [];
+    for (const s of listSkills(root, now)) {
+        if (s.origin === "auto" && s.status === "trial" && daysSince(s.lastUsed, now) > TRIAL_DAYS && deleteSkill(root, s.name, s.scope)) {
+            out.push(`skill ${s.name} arquivada: em teste há mais de ${TRIAL_DAYS} dias sem uso`);
+        }
+    }
+    return out;
+}
+/**
+ * Grava uma skill proposta pela reflexão sem perguntar ao usuário, mas só quando é seguro:
+ * - sempre escopo do projeto (global exige decisão humana);
+ * - skill de origem manual nunca é reescrita sozinha: a mudança vira proposta pendente;
+ * - conteúdo com comando destrutivo também vai para a fila de revisão;
+ * - nova skill respeita o teto diário.
+ */
+export function saveAuto(root, input, now = Date.now()) {
+    const prev = getSkill(root, input.name);
+    if (prev && prev.origin === "manual") {
+        const scope = savePending(root, input, prev.scope);
+        return { saved: false, msg: `skill ${input.name} (${scope}) é revisada por você: mudança proposta em /skills approve ${input.name}` };
+    }
+    if (lintSkill(input).warnings.some((w) => w.startsWith("comando destrutivo"))) {
+        const scope = savePending(root, input, "project");
+        return { saved: false, msg: `skill ${input.name} (${scope}) tem comando destrutivo: aguardando /skills approve ${input.name}` };
+    }
+    if (!prev) {
+        const today = new Date(now).toISOString().slice(0, 10);
+        const created = listSkills(root, now).filter((s) => s.origin === "auto" && s.created === today).length;
+        if (created >= DAILY_LIMIT)
+            return { saved: false, msg: `skill ${input.name} não criada: teto de ${DAILY_LIMIT} skills automáticas por dia` };
+    }
+    const r = saveSkill(root, input, prev?.scope ?? "project", { auto: true });
+    return { saved: true, msg: r.created ? `skill ${input.name} criada em teste (project, v1)` : `skill ${input.name} atualizada (${r.scope}, v${r.version})` };
+}

package/dist/tools/bash.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { exec } from "node:child_process";
 import { defineTool } from "./registry.js";
+import { shellFor } from "../util/platform.js";
 defineTool({
     name: "bash",
     description: "Executa um comando shell na raiz do projeto (timeout padrão 120s).",
@@ -9,7 +10,7 @@ defineTool({
     mutates: true,
     describe: (i) => i.command,
     run: ({ command, timeout_ms = 120_000 }, { root }) => new Promise((resolve) => {
-        exec(command, { cwd: root, timeout: timeout_ms, maxBuffer: 10 * 1024 * 1024 }, (err, stdout, stderr) => {
+        exec(command, { cwd: root, shell: shellFor(), timeout: timeout_ms, maxBuffer: 10 * 1024 * 1024 }, (err, stdout, stderr) => {
             const out = (stdout + (stderr ? `\n[stderr]\n${stderr}` : "")).trim();
             resolve(`${err ? `[exit ${err.code ?? "?"}] ` : ""}${out.slice(-30_000) || "(sem saída)"}`);
         });

package/dist/tools/fs.js

@@ -1,11 +1,14 @@
 import { z } from "zod";
 import fs from "node:fs";
 import path from "node:path";
-import fg from "fast-glob";
+import { glob as fg } from "tinyglobby";
 import { defineTool } from "./registry.js";
 const abs = (root, p) => {
     const full = path.resolve(root, p);
-    if (!full.startsWith(path.resolve(root)))
+    // path.relative cobre dois defeitos do startsWith: irmão com mesmo prefixo (/proj vs /proj-x) e, no Windows,
+    // diferença de caixa na letra da unidade ou nos diretórios (C:\ vs c:\), que fazia caminhos válidos serem recusados.
+    const rel = path.relative(path.resolve(root), full);
+    if (rel === ".." || rel.startsWith(".." + path.sep) || path.isAbsolute(rel))
         throw new Error("Caminho fora do projeto.");
     return full;
 };

package/dist/ui/dock.js

@@ -1,3 +1,4 @@
+import { droppedImages } from "../util/images.js";
 import fs from "node:fs";
 import path from "node:path";
 import stringWidth from "string-width";
@@ -7,7 +8,7 @@ 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;
+const PASTE_RE = /\[(?:colado|imagem) #(\d+): [^\]]*\]/g;
 export class Dock {
     opts;
     onSubmit = () => { };
@@ -409,7 +410,14 @@ export class Dock {
     finishPaste() {
         const text = this.pasteBuf.replace(/\r\n?/g, "\n");
         const lines = text.split("\n").length;
-        if (lines >= 2 || text.length > 300) {
+        // Arrastar uma imagem para o terminal cola o caminho dela: vira um marcador curto que volta a ser o caminho no envio.
+        const imgs = droppedImages(text);
+        if (imgs.length) {
+            const n = ++this.pasteN;
+            this.pastes.set(n, imgs.map((i) => (/\s/.test(i.path) ? `"${i.path}"` : i.path)).join(" "));
+            this.insert(`[imagem #${n}: ${imgs.length === 1 ? imgs[0].name : `${imgs.length} imagens`}] `);
+        }
+        else 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);

package/dist/util/images.js

@@ -0,0 +1,75 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const TYPES = { png: "image/png", jpg: "image/jpeg", jpeg: "image/jpeg", gif: "image/gif", webp: "image/webp" };
+const IMG_EXT = /\.(png|jpe?g|gif|webp)$/i;
+/** Limite da API por imagem (5 MB) e teto de anexos por mensagem. */
+export const MAX_IMAGE_BYTES = 5 * 1024 * 1024;
+export const MAX_IMAGES = 5;
+/** Divide o texto em tokens, respeitando aspas e (fora do Windows) `\ ` como espaço do nome do arquivo. */
+function tokens(text) {
+    const win = process.platform === "win32";
+    const re = win ? /'([^']*)'|"([^"]*)"|(\S+)/g : /'([^']*)'|"([^"]*)"|((?:\\.|\S)+)/g;
+    return [...text.matchAll(re)].map((m) => {
+        if (m[1] !== undefined)
+            return m[1];
+        if (m[2] !== undefined)
+            return m[2];
+        return win ? m[3] : m[3].replace(/\\(.)/g, "$1");
+    });
+}
+function toPath(token, root) {
+    let t = token.trim();
+    if (/^file:\/\//i.test(t)) {
+        try {
+            t = fileURLToPath(t);
+        }
+        catch {
+            return t;
+        }
+    }
+    if (t === "~" || t.startsWith("~/"))
+        t = path.join(os.homedir(), t.slice(1));
+    return path.resolve(root, t);
+}
+/** Imagens existentes citadas no texto (caminhos soltos, entre aspas, escapados ou file://). Sem duplicatas; para em MAX_IMAGES. */
+export function findImages(text, root = process.cwd()) {
+    const seen = new Set();
+    const out = [];
+    for (const tok of tokens(text)) {
+        if (!IMG_EXT.test(tok))
+            continue;
+        const p = toPath(tok, root);
+        if (seen.has(p))
+            continue;
+        try {
+            const st = fs.statSync(p);
+            if (!st.isFile())
+                continue;
+            seen.add(p);
+            out.push({ path: p, name: path.basename(p), mediaType: TYPES[path.extname(p).slice(1).toLowerCase()], bytes: st.size });
+        }
+        catch { /* não existe: era só texto parecido com caminho */ }
+        if (out.length >= MAX_IMAGES)
+            break;
+    }
+    return out;
+}
+/** O texto inteiro é só caminhos de imagem (o que um arrastar-e-soltar produz)? Devolve as imagens, ou [] se tem mais coisa. */
+export function droppedImages(text, root = process.cwd()) {
+    const toks = tokens(text);
+    if (!toks.length || !toks.every((t) => IMG_EXT.test(t)))
+        return [];
+    const imgs = findImages(text, root);
+    return imgs.length === toks.length ? imgs : [];
+}
+export const fmtBytes = (n) => (n >= 1_048_576 ? `${(n / 1_048_576).toFixed(1)} MB` : `${Math.max(1, Math.round(n / 1024))} kB`);
+/** Separa o que dá para enviar do que passa do limite da API. */
+export function splitOversize(imgs) {
+    return { ok: imgs.filter((i) => i.bytes <= MAX_IMAGE_BYTES), tooBig: imgs.filter((i) => i.bytes > MAX_IMAGE_BYTES) };
+}
+/** Bloco `image` da API da Anthropic, com o arquivo em base64. */
+export function imageBlock(img) {
+    return { type: "image", source: { type: "base64", media_type: img.mediaType, data: fs.readFileSync(img.path).toString("base64") } };
+}

package/dist/util/platform.js

@@ -0,0 +1,57 @@
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+let claudeCache;
+/** Alvo real de um shim npm (`claude.cmd`): `"%dp0%\caminho\cli.js"` ou `...\claude.exe`. */
+export function resolveCmdShim(shimPath, content) {
+    const target = content.match(/"%dp0%\\([^"]+)"/)?.[1];
+    if (!target)
+        return null;
+    const file = path.win32.join(path.win32.dirname(shimPath), target);
+    if (/\.exe$/i.test(file))
+        return { command: file, prefix: [] };
+    if (/\.(c|m)?js$/i.test(file))
+        return { command: process.execPath, prefix: [file] };
+    return null;
+}
+function findClaude() {
+    const found = spawnSync("where", ["claude"], { encoding: "utf8" }).stdout?.split(/\r?\n/).map((l) => l.trim()).filter(Boolean) ?? [];
+    const exe = found.find((f) => /\.exe$/i.test(f));
+    if (exe)
+        return { command: exe, prefix: [] };
+    for (const f of found.filter((x) => /\.cmd$/i.test(x))) {
+        try {
+            const r = resolveCmdShim(f, fs.readFileSync(f, "utf8"));
+            if (r && fs.existsSync(r.prefix[0] ?? r.command))
+                return r;
+        }
+        catch { /* shim ilegível: tenta o próximo */ }
+    }
+    return { command: "claude", prefix: [] };
+}
+/** Comando e argumentos para executar o `claude` com segurança em qualquer sistema. */
+export function claudeCommand(args) {
+    if (process.platform !== "win32")
+        return { command: "claude", args };
+    claudeCache ??= findClaude();
+    return { command: claudeCache.command, args: [...claudeCache.prefix, ...args] };
+}
+let shellCache = null;
+/** Shell para `exec`: `BRITO_SHELL` > Git Bash (só no Windows) > padrão do sistema (undefined). */
+export function shellFor() {
+    if (process.env.BRITO_SHELL)
+        return process.env.BRITO_SHELL;
+    if (process.platform !== "win32")
+        return undefined;
+    if (shellCache !== null)
+        return shellCache;
+    const roots = [process.env.ProgramFiles, process.env["ProgramFiles(x86)"], process.env.LOCALAPPDATA && path.join(process.env.LOCALAPPDATA, "Programs")].filter((r) => !!r);
+    shellCache = roots.map((r) => path.join(r, "Git", "bin", "bash.exe")).find((p) => fs.existsSync(p));
+    return shellCache;
+}
+/** Linha para o system prompt dizendo qual shell o comando `bash` usa de fato (só no Windows; nos outros é bash/sh). */
+export function shellNote() {
+    if (process.platform !== "win32")
+        return "";
+    return shellFor() ? "\nShell dos comandos: Git Bash (sintaxe bash)." : "\nShell dos comandos: cmd.exe do Windows (não há bash): use dir/type/findstr e sintaxe do cmd, não ls/cat/grep.";
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brito-cli",
-  "version": "0.3.2",
+  "version": "0.5.0",
   "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": {
@@ -13,21 +13,26 @@
     "test": "tsx --test test/*.test.ts",
     "eval:learn": "tsx test/eval-learn.ts",
     "prepare": "tsc",
-    "prepublishOnly": "npm run typecheck && npm test"
+    "prepublishOnly": "npm run typecheck && npm test",
+    "desktop": "npm run build && npm run bundle && npm --prefix desktop install --no-audit --no-fund && npm --prefix desktop start",
+    "bundle": "node build-bundle.mjs",
+    "desktop:app": "npm run build && npm run bundle && npm --prefix desktop install --no-audit --no-fund && node desktop/package.mjs --install",
+    "desktop:dmg": "npm run build && npm run bundle && npm --prefix desktop install --no-audit --no-fund && node desktop/package.mjs --dmg"
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.131.0",
     "@modelcontextprotocol/sdk": "^1.32.0",
     "commander": "latest",
-    "fast-glob": "latest",
     "kuzu": "latest",
     "string-width": "^8.3.0",
+    "tinyglobby": "^0.2.17",
     "tree-sitter-wasms": "latest",
     "web-tree-sitter": "0.24.7",
     "zod": "latest"
   },
   "devDependencies": {
     "@types/node": "latest",
+    "esbuild": "^0.28.2",
     "tsx": "latest",
     "typescript": "latest"
   },
@@ -46,6 +51,7 @@
   },
   "files": [
     "dist",
+    "!dist/cli.bundle.mjs",
     ".brito/agents",
     "README.md",
     "README.pt-BR.md",
@@ -64,5 +70,8 @@
     "svelte",
     "typescript",
     "python"
-  ]
+  ],
+  "overrides": {
+    "tar": "^7.5.22"
+  }
 }