primocode 8.42.2 → 9.1.0

package/lib/markdown.js

@@ -0,0 +1,376 @@
+/**
+ * markdown.js — a resposta do modelo, desenhada no terminal.
+ *
+ * ── POR QUE ISTO PRECISOU EXISTIR ────────────────────────────────────────
+ * O modelo escreve em Markdown; é o que ele sabe fazer, e é o que o prompt
+ * pede. Só que a resposta saía CRUA na tela: `**importante**` aparecia com os
+ * asteriscos, a tabela virava um monte de barras verticais desalinhadas, e o
+ * bloco de código vinha com as três crases à mostra. Quem lê recebe o material
+ * bruto e faz a formatação de cabeça — que é justamente o trabalho que a
+ * ferramenta deveria poupar.
+ *
+ * ── O QUE ESTE ARQUIVO NÃO É ─────────────────────────────────────────────
+ * Não é um parser de Markdown. Markdown completo tem aninhamento, HTML embutido
+ * e ambiguidade de sobra, e nada disso aparece numa resposta de terminal. Aqui
+ * é linha a linha, com três exceções que PRECISAM de bloco: a cerca de código,
+ * a tabela e a lista que continua na linha seguinte. O resto é uma passada de
+ * expressões regulares sobre o texto da linha.
+ *
+ * A vantagem prática é o FLUXO: como quase tudo se resolve por linha, a
+ * resposta pode ser desenhada enquanto chega, sem esperar terminar. Quem usa
+ * vê o texto aparecendo, e não uma tela parada que de repente enche.
+ *
+ * ── A REGRA DE OURO DO ALINHAMENTO ───────────────────────────────────────
+ * Código de cor NÃO ocupa coluna. Toda conta de largura (tabela, régua, quebra)
+ * usa `visibleWidth`, nunca `.length` — senão a tabela com uma célula colorida
+ * sai torta, e ninguém entende por quê.
+ */
+
+'use strict';
+
+const { c, visibleWidth, stripAnsi } = require('./ui.js');
+
+/* Zero dependências, então as cores que faltam no ui.js nascem aqui. O
+   itálico e o sublinhado não estão lá porque nada mais no programa usa. */
+const ANSI = (n) => (t) => `\x1b[${n}m${t}\x1b[0m`;
+const italico = ANSI(3);
+const riscado = ANSI(9);
+const inverso = ANSI(7);
+
+// ── o que se reconhece numa linha ────────────────────────────────────────
+
+const CERCA = /^\s{0,3}(```|~~~)\s*([a-zA-Z0-9+#._-]*)\s*$/;
+const TITULO = /^\s{0,3}(#{1,6})\s+(.*)$/;
+const MARCADOR = /^(\s*)([-*+])\s+(.*)$/;
+const NUMERADA = /^(\s*)(\d{1,3})([.)])\s+(.*)$/;
+const TAREFA = /^(\s*)[-*+]\s+\[([ xX])\]\s+(.*)$/;
+const CITACAO = /^\s{0,3}>\s?(.*)$/;
+const REGUA = /^\s{0,3}([-*_])\s*(?:\1\s*){2,}$/;
+const LINHA_TABELA = /^\s*\|.*\|\s*$/;
+const SEPARADOR_TABELA = /^\s*\|(?:\s*:?-{2,}:?\s*\|)+\s*$/;
+
+/**
+ * As marcas DENTRO de uma linha: negrito, itálico, código, link, riscado.
+ *
+ * O código inline é resolvido PRIMEIRO e sai de cena: um `**` dentro de
+ * `código` é código, não negrito, e resolver na ordem errada come as marcas do
+ * próprio trecho literal. Os pedaços saem, o resto é formatado, e eles voltam.
+ */
+function inline(texto) {
+    const guardados = [];
+    let t = String(texto)
+        .replace(/`([^`\n]+)`/g, (_, codigo) => {
+            guardados.push(inverso(' ' + codigo + ' '));
+            return `\u0000${guardados.length - 1}\u0000`;
+        });
+
+    t = t
+        // Link: o texto fica, o endereço vai junto em cinza — num terminal
+        // ninguém clica no texto, então esconder a URL é esconder a fonte.
+        .replace(/\[([^\]\n]+)\]\(([^)\s]+)[^)]*\)/g, (_, rotulo, url) => c.white(rotulo) + ' ' + c.dim(`(${url})`))
+        .replace(/(\*\*\*|___)([^\s].*?[^\s]|\S)\1/g, (_, __, x) => c.bold(italico(x)))
+        .replace(/(\*\*|__)([^\s].*?[^\s]|\S)\1/g, (_, __, x) => c.bold(c.white(x)))
+        .replace(/~~([^\s].*?[^\s]|\S)~~/g, (_, x) => riscado(x))
+        // Itálico com UM asterisco/sublinhado. O sublinhado só conta entre
+        // limites de palavra: nome_de_variavel_assim não é itálico, e tratá-lo
+        // como itálico embaralha todo texto sobre código.
+        .replace(/(^|[^*\w])\*([^\s*][^*]*?)\*(?![*\w])/g, (_, antes, x) => antes + italico(x))
+        .replace(/(^|[^_\w])_([^\s_][^_]*?)_(?![_\w])/g, (_, antes, x) => antes + italico(x));
+
+    return t.replace(/\u0000(\d+)\u0000/g, (_, i) => guardados[Number(i)]);
+}
+
+// ── blocos ───────────────────────────────────────────────────────────────
+
+/* As palavras que ganham cor dentro de um bloco de código. Não é um
+   analisador de sintaxe: é a lista das palavras que aparecem em quase toda
+   linguagem, mais os literais. Colorir demais fica pior que não colorir, e
+   inventar um parser por linguagem é trabalho sem fim para ganho pequeno. */
+const PALAVRAS = new RegExp('\\b(' + [
+    'function', 'return', 'const', 'let', 'var', 'class', 'extends', 'new', 'this',
+    'if', 'else', 'for', 'while', 'switch', 'case', 'break', 'continue', 'try', 'catch',
+    'finally', 'throw', 'async', 'await', 'import', 'from', 'export', 'default',
+    'def', 'elif', 'lambda', 'pass', 'with', 'as', 'in', 'is', 'not', 'and', 'or',
+    'self', 'None', 'True', 'False', 'null', 'undefined', 'true', 'false',
+    'public', 'private', 'static', 'void', 'int', 'string', 'bool', 'struct', 'type',
+    'func', 'package', 'interface', 'require', 'module',
+].join('|') + ')\\b', 'g');
+
+/* UMA passada só, com alternância — e isso não é preciosismo.
+   Na primeira versão eram três `replace` em sequência, e o terceiro (números)
+   pintava os dígitos DENTRO dos códigos de cor que os dois primeiros tinham
+   acabado de inserir: o "38;5;214" de um escape virava três números coloridos,
+   o escape se desmanchava e o terminal cuspia "[38;5;45m" como texto. Com uma
+   expressão só, cada pedaço da linha é consumido uma vez e nada pinta o que já
+   foi pintado. */
+const CODIGO = new RegExp([
+    '(["\'`])(?:\\\\.|(?!\\1)[^\\\\])*\\1',   // texto entre aspas
+    '(?://|#|--)[^\\n]*$',                     // comentário até o fim da linha
+    PALAVRAS.source,                        // palavra-chave
+    '\\b\\d+(?:\\.\\d+)?\\b',                 // número
+].join('|'), 'g');
+
+function pintarCodigo(linha) {
+    return String(linha).replace(CODIGO, (achado) => {
+        if (/^["'`]/.test(achado)) return c.ok(achado);
+        if (/^(\/\/|#|--)/.test(achado)) return c.dim(achado);
+        if (/^\d/.test(achado)) return c.cyan(achado);
+        return c.magenta(achado);
+    });
+}
+
+/** O bloco de código, com a linguagem no canto e uma barra à esquerda. */
+function blocoDeCodigo(linhas, linguagem, largura) {
+    const fora = [];
+    const barra = c.dim('│');
+    if (linguagem) fora.push('  ' + c.dim(linguagem));
+    for (const l of linhas) {
+        // Corta o que passa da largura em vez de deixar quebrar sozinho: uma
+        // linha de código quebrada no meio pela borda do terminal engana quem
+        // lê sobre onde ela termina.
+        const util = Math.max(20, largura - 4);
+        const corpo = visibleWidth(l) > util ? l.slice(0, util - 1) + '…' : l;
+        fora.push('  ' + barra + ' ' + pintarCodigo(corpo));
+    }
+    return fora;
+}
+
+/**
+ * A tabela, com as colunas alinhadas.
+ *
+ * A largura de cada coluna é a do conteúdo VISÍVEL mais largo — e por isso a
+ * conta é com `visibleWidth`: a célula em negrito tem código ANSI dentro, e
+ * medir por `.length` faz a coluna crescer sem motivo e desalinhar as outras.
+ */
+function tabela(linhas, largura) {
+    const celulas = linhas.map((l) => l.trim().replace(/^\||\|$/g, '').split('|').map((x) => x.trim()));
+    const alinhamentos = [];
+    let corpo = celulas;
+    if (celulas.length > 1 && SEPARADOR_TABELA.test(linhas[1])) {
+        for (const s of celulas[1]) {
+            alinhamentos.push(/^:.*:$/.test(s) ? 'centro' : /:$/.test(s) ? 'direita' : 'esquerda');
+        }
+        corpo = [celulas[0], ...celulas.slice(2)];
+    }
+    const formatadas = corpo.map((linha) => linha.map(inline));
+    const colunas = Math.max(...formatadas.map((l) => l.length));
+    const larguras = [];
+    for (let i = 0; i < colunas; i++) {
+        larguras.push(Math.max(...formatadas.map((l) => visibleWidth(l[i] || ''))));
+    }
+
+    // Tabela mais larga que o terminal: encolhe a coluna maior até caber. É
+    // melhor que deixar a linha quebrar — quebrada, a tabela deixa de ser
+    // tabela e vira um monte de texto solto.
+    const gasto = () => larguras.reduce((s, w) => s + w + 3, 1);
+    while (gasto() > largura - 2 && Math.max(...larguras) > 6) {
+        larguras[larguras.indexOf(Math.max(...larguras))] -= 1;
+    }
+
+    const encaixar = (txt, w, alinhamento) => {
+        let t = txt;
+        if (visibleWidth(t) > w) {
+            // Corta contando só o que é visível, para não decepar um código de
+            // cor no meio e vazar o escape para a tela.
+            const cru = stripAnsi(t).slice(0, Math.max(1, w - 1)) + '…';
+            t = cru;
+        }
+        const falta = w - visibleWidth(t);
+        if (alinhamento === 'direita') return ' '.repeat(falta) + t;
+        if (alinhamento === 'centro') {
+            const e = Math.floor(falta / 2);
+            return ' '.repeat(e) + t + ' '.repeat(falta - e);
+        }
+        return t + ' '.repeat(falta);
+    };
+
+    const risco = (e, meio, d) => c.dim(e + larguras.map((w) => '─'.repeat(w + 2)).join(meio) + d);
+    const fora = [risco('╭', '┬', '╮')];
+    formatadas.forEach((linha, i) => {
+        const cel = larguras.map((w, j) => encaixar(
+            i === 0 ? c.bold(c.white(stripAnsi(linha[j] || ''))) : (linha[j] || ''),
+            w, alinhamentos[j] || 'esquerda'));
+        fora.push(c.dim('│') + ' ' + cel.join(' ' + c.dim('│') + ' ') + ' ' + c.dim('│'));
+        if (i === 0) fora.push(risco('├', '┼', '┤'));
+    });
+    fora.push(risco('╰', '┴', '╯'));
+    return fora;
+}
+
+/** Quebra um parágrafo na largura, sem partir palavra e sem contar cor. */
+function dobrar(texto, largura, recuo = '') {
+    const palavras = String(texto).split(/\s+/).filter(Boolean);
+    if (!palavras.length) return [''];
+    const fora = [];
+    let linha = '';
+    for (const p of palavras) {
+        const teste = linha ? linha + ' ' + p : p;
+        if (visibleWidth(teste) + visibleWidth(recuo) > largura && linha) {
+            fora.push(linha);
+            linha = p;
+        } else {
+            linha = teste;
+        }
+    }
+    if (linha) fora.push(linha);
+    return fora;
+}
+
+/**
+ * O texto inteiro, pronto para a tela.
+ *
+ * @param {string} texto      o Markdown
+ * @param {number} largura    colunas úteis
+ * @returns {string[]}        as linhas, já com cor
+ */
+function renderizar(texto, largura = 80) {
+    const w = Math.max(24, Number(largura) || 80);
+    const linhas = String(texto == null ? '' : texto).split('\n');
+    const fora = [];
+
+    let i = 0;
+    while (i < linhas.length) {
+        const linha = linhas[i];
+
+        const cerca = linha.match(CERCA);
+        if (cerca) {
+            const fim = cerca[1];
+            const dentro = [];
+            i++;
+            while (i < linhas.length && !linhas[i].trim().startsWith(fim)) { dentro.push(linhas[i]); i++; }
+            i++;                                     // pula a cerca de baixo
+            fora.push(...blocoDeCodigo(dentro, cerca[2], w));
+            continue;
+        }
+
+        if (LINHA_TABELA.test(linha)) {
+            const bloco = [];
+            while (i < linhas.length && LINHA_TABELA.test(linhas[i])) { bloco.push(linhas[i]); i++; }
+            // Uma linha só entre barras não é tabela: é texto com barra.
+            if (bloco.length >= 2) { fora.push(...tabela(bloco, w)); continue; }
+            fora.push(inline(bloco[0]));
+            continue;
+        }
+
+        if (REGUA.test(linha)) { fora.push(c.dim('─'.repeat(Math.min(w, 60)))); i++; continue; }
+
+        const titulo = linha.match(TITULO);
+        if (titulo) {
+            const nivel = titulo[1].length;
+            const texto1 = stripAnsi(inline(titulo[2]));
+            fora.push('');
+            fora.push(nivel === 1 ? c.bold(c.brand(texto1.toUpperCase())) : c.bold(c.white(texto1)));
+            if (nivel === 1) fora.push(c.dim('─'.repeat(Math.min(w, visibleWidth(texto1)))));
+            i++;
+            continue;
+        }
+
+        const tarefa = linha.match(TAREFA);
+        if (tarefa) {
+            const marca = /[xX]/.test(tarefa[2]) ? c.ok('✔') : c.dim('○');
+            fora.push(...dobrarItem(tarefa[1] + marca + ' ', inline(tarefa[3]), w));
+            i++;
+            continue;
+        }
+
+        const numerada = linha.match(NUMERADA);
+        if (numerada) {
+            fora.push(...dobrarItem(numerada[1] + c.brand(numerada[2] + '.') + ' ', inline(numerada[4]), w));
+            i++;
+            continue;
+        }
+
+        const marcador = linha.match(MARCADOR);
+        if (marcador) {
+            // O ponto acompanha o nível: subitem não pode ter a mesma marca do
+            // item de cima, ou a hierarquia some.
+            const nivel = Math.floor(marcador[1].length / 2);
+            const ponto = [c.brand('•'), c.brand('◦'), c.brand('▪')][Math.min(nivel, 2)];
+            fora.push(...dobrarItem(marcador[1] + ponto + ' ', inline(marcador[3]), w));
+            i++;
+            continue;
+        }
+
+        const citacao = linha.match(CITACAO);
+        if (citacao) {
+            for (const l of dobrar(inline(citacao[1]), w - 4)) fora.push(c.dim('▏ ') + c.muted(l));
+            i++;
+            continue;
+        }
+
+        if (!linha.trim()) { fora.push(''); i++; continue; }
+
+        for (const l of dobrar(inline(linha), w)) fora.push(l);
+        i++;
+    }
+
+    // Linha em branco no fim é espaço morto no terminal.
+    while (fora.length && !fora[fora.length - 1].trim()) fora.pop();
+    return fora;
+}
+
+/** Item de lista: a primeira linha leva a marca, as seguintes se alinham a ela. */
+function dobrarItem(marca, conteudo, largura) {
+    const recuo = ' '.repeat(visibleWidth(marca));
+    const partes = dobrar(conteudo, largura - visibleWidth(marca));
+    return partes.map((p, i) => (i === 0 ? marca : recuo) + p);
+}
+
+/**
+ * O desenhador de FLUXO: recebe a resposta em pedaços e devolve o que já dá
+ * para mostrar.
+ *
+ * A resposta do chat chega em dezenas de pedaços, e esperar o fim para
+ * formatar deixaria a tela parada até tudo chegar. Quase tudo aqui se resolve
+ * por linha, então a linha é a unidade: fechou, sai formatada.
+ *
+ * As exceções são os blocos que só fazem sentido inteiros — a cerca de código
+ * e a tabela. Enquanto um deles está aberto, as linhas ficam retidas; elas
+ * saem juntas quando ele fecha. É o comportamento certo: meia tabela na tela
+ * é pior que a tabela um segundo depois.
+ */
+function fluxo(largura = 80) {
+    let resto = '';
+    let retido = [];
+    let dentroDaCerca = false;
+    let fimDaCerca = '';
+
+    const soltar = () => {
+        if (!retido.length) return [];
+        const saida = renderizar(retido.join('\n'), largura);
+        retido = [];
+        return saida;
+    };
+
+    return {
+        /** Devolve as linhas prontas para escrever agora. */
+        pedaco(texto) {
+            resto += String(texto == null ? '' : texto);
+            const partes = resto.split('\n');
+            resto = partes.pop();                 // a última fica para a próxima
+            const fora = [];
+            for (const linha of partes) {
+                const cerca = linha.match(CERCA);
+                if (dentroDaCerca) {
+                    retido.push(linha);
+                    if (linha.trim().startsWith(fimDaCerca)) { dentroDaCerca = false; fora.push(...soltar()); }
+                    continue;
+                }
+                if (cerca) { dentroDaCerca = true; fimDaCerca = cerca[1]; retido.push(linha); continue; }
+                if (LINHA_TABELA.test(linha)) { retido.push(linha); continue; }
+                // Saiu da tabela: agora ela está inteira.
+                if (retido.length) fora.push(...soltar());
+                fora.push(...renderizar(linha, largura));
+            }
+            return fora;
+        },
+        /** O que sobrou quando a resposta terminou. */
+        fim() {
+            const pendente = [...retido, ...(resto ? [resto] : [])];
+            retido = []; resto = ''; dentroDaCerca = false;
+            return pendente.length ? renderizar(pendente.join('\n'), largura) : [];
+        },
+    };
+}
+
+module.exports = { renderizar, fluxo, inline, tabela, dobrar, pintarCodigo, blocoDeCodigo };

package/lib/marketplace.js

@@ -0,0 +1,189 @@
+/**
+ * marketplace.js — a tela das skills, navegável pelas setas.
+ *
+ *   "/marketplace abre uma tela navegável no terminal, com navegação pelas
+ *    setas, seções (uma delas é a seção de Skills) e rolagem para baixo. O
+ *    usuário navega, ativa e instala skills ali. Dentro do marketplace existe
+ *    a opção 'New Skill': seleciona com as setas, dá Enter, e o terminal pede
+ *    em sequência o nome e o conteúdo da skill."
+ *
+ * ── O DESENHO É FUNÇÃO PURA, DE NOVO ─────────────────────────────────────
+ * `montar()` recebe um estado e devolve linhas. `andar()` recebe uma tecla e
+ * devolve o estado seguinte. Nenhuma das duas toca no terminal nem no disco.
+ *
+ * É o mesmo desenho do `/effort` e da caixa de digitar, e pelo mesmo motivo:
+ * uma tela de terminal que só existe enquanto alguém aperta seta é uma tela
+ * que ninguém consegue testar. Assim o teste percorre a lista inteira, abre e
+ * fecha seção, rola até o fim e confere o que apareceu — sem nada na tela.
+ *
+ * ── POR QUE A LISTA É PLANA POR DENTRO ───────────────────────────────────
+ * A tela tem seções, mas a navegação é UMA lista: título de seção é item que
+ * não se escolhe, e a seta pula por cima dele. Tentar navegar em árvore (seta
+ * para entrar, outra para sair) é o tipo de coisa que exige explicação — e
+ * uma tela que precisa de manual não serve para quem abriu o terminal para
+ * fazer outra coisa.
+ *
+ * ── O QUE ESTE MARKETPLACE NÃO É ─────────────────────────────────────────
+ * Não há loja na internet. O catálogo é o que vem no produto mais o que
+ * estiver instalado na máquina, e é isso que a tela mostra — sem inventar um
+ * "1.248 skills disponíveis" que não existe. O dia em que existir um índice
+ * remoto, ele entra como mais uma seção.
+ */
+
+'use strict';
+
+const { c, truncate, padRight, visibleWidth } = require('./ui.js');
+
+// ── o estado ─────────────────────────────────────────────────────────────
+
+/**
+ * @param {Array} skills  o que `skills.listar()` devolveu
+ */
+function novo(skills) {
+    // A seleção nasce no primeiro item ESCOLHÍVEL, não no zero — o zero é um
+    // título de seção, e uma tela que abre sem nada marcado parece travada.
+    const base = { skills: skills || [], sel: 0, topo: 0, saiu: null };
+    const lista = itens(base);
+    base.sel = escolhivel(lista[0]) ? 0 : proximo(lista, 0, 1);
+    return base;
+}
+
+/**
+ * A lista plana: cabeçalhos de seção e itens, na ordem em que aparecem.
+ *
+ * Cada item diz o que é e o que fazer com ele. A tela e as teclas leem daqui,
+ * então não existe a chance de uma delas achar que o terceiro item é outro.
+ */
+function itens(estado) {
+    const lista = [];
+    const ligadas = estado.skills.filter((s) => s.ligada);
+    const desligadas = estado.skills.filter((s) => !s.ligada);
+
+    lista.push({ tipo: 'secao', texto: 'Skills ativas', conta: ligadas.length });
+    if (!ligadas.length) lista.push({ tipo: 'vazio', texto: 'nenhuma ativa' });
+    for (const s of ligadas) lista.push({ tipo: 'skill', skill: s });
+
+    lista.push({ tipo: 'secao', texto: 'Desligadas', conta: desligadas.length });
+    if (!desligadas.length) lista.push({ tipo: 'vazio', texto: 'nenhuma desligada' });
+    for (const s of desligadas) lista.push({ tipo: 'skill', skill: s });
+
+    lista.push({ tipo: 'secao', texto: 'Criar' });
+    lista.push({ tipo: 'nova', texto: 'New Skill', detalhe: 'escreva a sua — o nome e o prompt' });
+    lista.push({ tipo: 'instalar', texto: 'Instalar de um arquivo', detalhe: 'um SKILL.md que você tem no disco' });
+
+    return lista;
+}
+
+/** Dá para parar em cima deste item? Título de seção e vazio, não. */
+const escolhivel = (item) => item && item.tipo !== 'secao' && item.tipo !== 'vazio';
+
+/** O primeiro item escolhível a partir de `de`, andando em `passo`. */
+function proximo(lista, de, passo) {
+    let i = de;
+    for (let n = 0; n < lista.length; n++) {
+        i += passo;
+        if (i < 0) i = lista.length - 1;
+        if (i >= lista.length) i = 0;
+        if (escolhivel(lista[i])) return i;
+    }
+    return de;
+}
+
+/**
+ * Uma tecla → o estado seguinte.
+ *
+ * Devolve `{ estado, acao }`. A ação é o que o mundo lá fora precisa fazer —
+ * ligar uma skill, abrir o diálogo de criar, sair. Este módulo não faz nada
+ * disso: ele não sabe gravar arquivo nem perguntar nada.
+ */
+function andar(estado, tecla, { altura = 14 } = {}) {
+    const lista = itens(estado);
+    const e = { ...estado };
+
+    // O primeiro pouso: se a seleção caiu num título, desce até um item.
+    if (!escolhivel(lista[e.sel])) e.sel = proximo(lista, e.sel, 1);
+
+    const nome = (tecla && tecla.name) || '';
+
+    if (nome === 'down' || nome === 'j') e.sel = proximo(lista, e.sel, 1);
+    else if (nome === 'up' || nome === 'k') e.sel = proximo(lista, e.sel, -1);
+    else if (nome === 'pagedown') { for (let i = 0; i < 5; i++) e.sel = proximo(lista, e.sel, 1); }
+    else if (nome === 'pageup') { for (let i = 0; i < 5; i++) e.sel = proximo(lista, e.sel, -1); }
+    else if (nome === 'home') { e.sel = proximo(lista, lista.length - 1, 1); }
+    else if (nome === 'end') { e.sel = proximo(lista, 0, -1); }
+    else if (nome === 'escape' || nome === 'q') return { estado: { ...e, saiu: 'fechar' }, acao: { tipo: 'fechar' } };
+    else if (nome === 'return' || nome === 'enter' || (tecla && tecla.sequence === ' ')) {
+        const item = lista[e.sel];
+        if (!item) return { estado: e, acao: null };
+        if (item.tipo === 'skill') {
+            return { estado: e, acao: { tipo: 'alternar', skill: item.skill } };
+        }
+        if (item.tipo === 'nova') return { estado: { ...e, saiu: 'nova' }, acao: { tipo: 'nova' } };
+        if (item.tipo === 'instalar') return { estado: { ...e, saiu: 'instalar' }, acao: { tipo: 'instalar' } };
+    }
+
+    // A janela acompanha a seleção: sem isto, descer faz o item escolhido
+    // sumir embaixo e a seta parece ter parado de funcionar.
+    const visiveis = Math.max(4, altura);
+    if (e.sel < e.topo) e.topo = e.sel;
+    if (e.sel >= e.topo + visiveis) e.topo = e.sel - visiveis + 1;
+    e.topo = Math.max(0, Math.min(e.topo, Math.max(0, lista.length - visiveis)));
+
+    return { estado: e, acao: null };
+}
+
+// ── o desenho ────────────────────────────────────────────────────────────
+
+function montar(estado, { colunas = 80, altura = 14 } = {}) {
+    const larg = Math.max(40, Math.min(colunas - 1, 110));
+    const lista = itens(estado);
+    const visiveis = Math.max(4, altura);
+    const topo = Math.max(0, Math.min(estado.topo || 0, Math.max(0, lista.length - visiveis)));
+
+    const out = [];
+    out.push('');
+    out.push('  ' + c.bold(c.brand('Marketplace')) + c.dim('  ·  as skills do Primo Code'));
+    out.push('  ' + c.dim('─'.repeat(larg - 4)));
+
+    for (let i = topo; i < Math.min(lista.length, topo + visiveis); i++) {
+        const item = lista[i];
+        const escolhido = i === estado.sel;
+        const seta = escolhido ? c.brand('❯ ') : '  ';
+
+        if (item.tipo === 'secao') {
+            // Linha em branco antes da seção, menos na primeira: é o que
+            // separa os grupos sem precisar de moldura.
+            if (out.length > 3) out.push('');
+            out.push('  ' + c.bold(c.white(item.texto))
+                + (item.conta != null ? c.dim(`  ${item.conta}`) : ''));
+            continue;
+        }
+        if (item.tipo === 'vazio') { out.push('    ' + c.dim(item.texto)); continue; }
+
+        if (item.tipo === 'skill') {
+            const s = item.skill;
+            const marca = s.ligada ? c.ok('●') : c.dim('○');
+            const titulo = escolhido ? c.bold(c.white(s.titulo)) : c.white(s.titulo);
+            const selo = s.doProduto ? c.dim('  do produto') : c.brandDim('  sua');
+            out.push('  ' + seta + marca + ' ' + truncate(titulo + selo, larg - 8));
+            // A descrição só aparece no que está selecionado: com ela em
+            // todas, a lista dobra de altura e ninguém lê nenhuma.
+            if (escolhido && s.descricao) {
+                out.push('      ' + c.dim(truncate(s.descricao, larg - 8)));
+            }
+            continue;
+        }
+
+        const titulo = escolhido ? c.bold(c.brand(item.texto)) : c.brandDim(item.texto);
+        out.push('  ' + seta + titulo);
+        if (escolhido && item.detalhe) out.push('      ' + c.dim(item.detalhe));
+    }
+
+    out.push('');
+    out.push('  ' + c.dim('─'.repeat(larg - 4)));
+    out.push('  ' + c.dim('↑↓ navega · Enter liga e desliga · Esc fecha'));
+    out.push('');
+    return out.join('\n');
+}
+
+module.exports = { novo, itens, andar, montar, escolhivel, proximo };

package/lib/pasta.js

@@ -64,16 +64,27 @@ function detectarPasta(texto) {
     const s = String(texto || '');
     if (!s.trim()) return null;
 
-    // 1. Caminho explícito — `~/...` ou absoluto com pelo menos dois segmentos.
-    //    Um `/algo` solto não conta: seria confundido com comando (`/dir`).
-    const explicito = s.match(new RegExp(`(?:^|\\s)(~[${CARACTERES_DE_CAMINHO}]*|/[${CARACTERES_DE_CAMINHO}]+/[${CARACTERES_DE_CAMINHO}]*)`));
+    /* 1. Caminho explícito — `~/...`, absoluto unix com pelo menos dois
+          segmentos, ou o caminho do Windows com letra de unidade.
+          Um `/algo` solto não conta: seria confundido com comando (`/dir`).
+
+          O ramo do Windows (`C:\\Users\\joel\\loja`) não existia, e o dois-pontos
+          NÃO pode entrar em CARACTERES_DE_CAMINHO para resolver isso: ali ele
+          estragaria outros casamentos, como "veja isto: src/app", onde o
+          dois-pontos é pontuação da frase e não faz parte do caminho. Por isso
+          a unidade é um padrão à parte, ancorado na forma "letra + : + barra". */
+    const DRIVE_WIN = `[A-Za-z]:[\\\\/][${CARACTERES_DE_CAMINHO}]*`;
+    const explicito = s.match(new RegExp(`(?:^|\\s)(${DRIVE_WIN}|~[${CARACTERES_DE_CAMINHO}]*|/[${CARACTERES_DE_CAMINHO}]+/[${CARACTERES_DE_CAMINHO}]*)`));
     if (explicito) {
         const bruto = limpar(explicito[1]);
         if (bruto && !TEM_EXTENSAO.test(bruto)) return bruto;
     }
 
     // 2. Marca explícita de pasta.
-    const marcado = s.match(new RegExp(`\\b(?:pasta|diret[óo]rio|dir)\\s+(?:d[eoa]s?\\s+|no\\s+|na\\s+|em\\s+)?["'\`]?([${CARACTERES_DE_CAMINHO}]+)["'\`]?`, 'i'));
+    // A unidade do Windows entra aqui também: sem ela, "abre a pasta
+    // C:\\Users\\joel\\loja" casava só o "C" e o agente ia trabalhar numa pasta
+    // chamada "C".
+    const marcado = s.match(new RegExp(`\\b(?:pasta|diret[óo]rio|dir)\\s+(?:d[eoa]s?\\s+|no\\s+|na\\s+|em\\s+)?["'\`]?(${DRIVE_WIN}|[${CARACTERES_DE_CAMINHO}]+)["'\`]?`, 'i'));
     if (marcado) {
         const bruto = limpar(marcado[1]);
         if (bruto && !TEM_EXTENSAO.test(bruto) && !NAO_E_NOME.has(bruto.toLowerCase())) return bruto;