primocode 9.0.0 → 9.2.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/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;

package/lib/tools.js

@@ -7,6 +7,8 @@
 
 'use strict';
 
+const catalogo = require('./catalogo.js');
+
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
@@ -193,14 +195,43 @@ async function runInNewTerminal(command, cwd) {
     // mesmo tempo (osascript, cmd.exe, sh) — "command" continua livre de
     // propósito, é o próprio contrato desta tool (abrir terminal com um
     // comando de shell de verdade).
-    if (/["'`;&|$\\]/.test(pastaAlvo)) {
+    /* A CONTRABARRA NÃO PODE ENTRAR NESTA LISTA NO WINDOWS.
+       Ela estava, e com isso a tool NUNCA funcionou lá: a pasta de trabalho é
+       sempre C:\Users\<nome>\primocode\<projeto> (path.join no win32 usa "\"),
+       então TODO caminho casava e a resposta era "Pasta com caractere não
+       permitido" — culpando a pasta criada pelo próprio produto, antes de
+       tentar abrir terminal nenhum. "sobe o servidor" quebrava 100% das vezes.
+       A contrabarra só é perigosa onde ela é ESCAPE (sh, osascript); no cmd.exe
+       ela é separador de caminho e nada mais. */
+    const proibidos = p === 'win32' ? /["'`;&|%^<>\r\n]/ : /["'`;&|$\\\r\n]/;
+    if (proibidos.test(pastaAlvo)) {
         return { ok: false, error: `Pasta com caractere não permitido: ${pastaAlvo}` };
     }
     let cmd;
-    if (p === 'darwin') cmd = `osascript -e 'tell application "Terminal" to do script "cd ${pastaAlvo} && ${command}"'`;
-    else if (p === 'win32') cmd = `start cmd /k "cd /d ${pastaAlvo} && ${command}"`;
-    else cmd = `x-terminal-emulator -e "bash -c 'cd ${pastaAlvo} && ${command}; exec bash'"`;
-    const r = await runShell(cmd);
+    let pastaDoProcesso;
+    if (p === 'darwin') {
+        /* O Terminal.app é outro processo, já rodando: ele NÃO herda a pasta
+           daqui, então o `cd` tem de ir no script mesmo. O espaço é escapado
+           com contrabarra — "\\ " neste template vira "\ " dentro da string do
+           AppleScript, que é o escape que o shell entende. Sem isso, uma pasta
+           como ~/Documents/Meus Projetos virava dois argumentos e o cd falhava
+           calado: o terminal abria na pasta errada e o comando rodava no lugar
+           errado, que é pior que não abrir. */
+        cmd = `osascript -e 'tell application "Terminal" to do script "cd ${pastaAlvo.replace(/ /g, '\\\\ ')} && ${command}"'`;
+    } else if (p === 'win32') {
+        // Aspas em volta do caminho: "C:\Users\Joel Silva\..." é comum, e sem
+        // elas o cmd corta no espaço. A aspa dupla já está barrada acima, então
+        // não há como sair delas.
+        cmd = `start cmd /k "cd /d "${pastaAlvo}" && ${command}"`;
+    } else {
+        /* No Linux o terminal é filho DESTE processo e herda a pasta — então
+           o caminho não precisa entrar na string de shell nenhuma. É a solução
+           mais segura das três: o que não é interpolado não pode ser mal
+           escapado. */
+        cmd = `x-terminal-emulator -e "bash -c '${command}; exec bash'"`;
+        pastaDoProcesso = pastaAlvo;
+    }
+    const r = await runShell(cmd, 60000, pastaDoProcesso);
     return r.ok ? { ok: true, opener: cmd.split(' ')[0] } : { ok: false, error: r.stderr || 'falhou' };
 }
 
@@ -568,7 +599,25 @@ async function despachar(name, args, ctx) {
                 });
 
             default:
-                return { ok: false, error: `Tool não implementada: ${name}` };
+                /* O MODELO PRECISA CONSEGUIR SE CORRIGIR AQUI.
+                   "Tool não implementada: studio_criar" não diz o que existe,
+                   e o que acontecia era o agente desistir e responder ao
+                   usuário que a ferramenta necessária "não está disponível".
+                   Dizendo QUAIS existem — e a mais parecida — ele chama a
+                   certa na volta seguinte, na mesma tarefa.
+
+                   Isto é rede, não conserto: a causa é a lista do servidor
+                   divergir do catálogo daqui, e ela se conserta lá. Mas a rede
+                   é o que separa uma tarefa que se recupera de uma que morre
+                   com o usuário esperando. */
+                return {
+                    ok: false,
+                    error: `A ferramenta "${name}" não existe.`,
+                    parecidas: catalogo.parecidasCom(name),
+                    comoResolver: 'chame uma das ferramentas que existem de verdade — as "parecidas" '
+                        + 'acima são as de nome mais próximo. Não invente nome de ferramenta, e não '
+                        + 'desista da tarefa por causa disto.',
+                };
         }
     }
 }

package/lib/voz.js

@@ -169,10 +169,13 @@ function instalar(py, pacotes, aoFalar = () => {}) {
  * @param {string} op.voz
  * @param {(texto:string)=>Promise<string>} op.pensar   o agente de verdade
  * @param {(texto:string)=>void} op.mostrar             o que aparece no terminal
+ * @param {boolean} op.esperando                        fica dormindo até ouvir o nome
+ * @returns {{processo, pronto: Promise}}               o processo, e a promessa do fim
  */
-function abrir({ python: py, servidor, token, voz, pensar, mostrar = () => {} }) {
-    return new Promise((resolve) => {
-        const p = spawn(py, ['-m', 'primo_voz'], {
+function abrir({ python: py, servidor, token, voz, pensar, mostrar = () => {}, esperando = false }) {
+    let p;
+    const pronto = new Promise((resolve) => {
+        p = spawn(py, ['-m', 'primo_voz'], {
             cwd: PASTA,
             env: {
                 ...process.env,
@@ -180,6 +183,8 @@ function abrir({ python: py, servidor, token, voz, pensar, mostrar = () => {} })
                 PRIMOCODE_SERVER: servidor,
                 PRIMOCODE_TOKEN: token || '',
                 PRIMOCODE_VOZ: voz || 'antonio',
+                // Dormir até ouvir o nome, em vez de já entrar ouvindo.
+                PRIMOCODE_VOZ_ESPERA: esperando ? '1' : '',
                 PYTHONUNBUFFERED: '1',
             },
         });
@@ -234,6 +239,101 @@ function abrir({ python: py, servidor, token, voz, pensar, mostrar = () => {} })
         p.on('close', () => resolve({ ok: true }));
         p.on('error', (e) => resolve({ ok: false, error: e.message }));
     });
+
+    /* O PROCESSO VOLTA JUNTO COM A PROMESSA, e não é preciosismo de API.
+       No modo de espera o /voice não bloqueia o terminal: ele sobe o ouvinte
+       e devolve o prompt. Quem chamou precisa de um jeito de ENCERRAR aquilo
+       depois (/voice parar, ou a saída do programa) — e, sem o handle, o
+       único jeito seria matar pelo nome do processo, que atropela outra
+       sessão do PrimoCode aberta na mesma máquina. */
+    return { processo: p, pronto };
+}
+
+
+/* ── O RECONHECEDOR LOCAL DO NOME ────────────────────────────────────────
+ *
+ * Duas funções, e a razão de existirem é a mesma: no modo de espera o
+ * microfone fica ABERTO o tempo todo, e há dois jeitos de saber se alguém
+ * disse "ei, primo" — mandar tudo o que ele ouve para um servidor, ou
+ * reconhecer a palavra aqui dentro.
+ *
+ * O primeiro é mais fácil de escrever e significa a conversa da casa inteira
+ * subindo para a rede o dia inteiro. O segundo custa ~31 MB de modelo, uma
+ * vez. Não é escolha difícil, e não é escolha que o programa faça sozinho:
+ * `conferirEspera` só RESPONDE o que falta; quem pergunta à pessoa é o CLI.
+ */
+function conferirEspera(py) {
+    const perguntar = `
+import json, sys
+sys.path.insert(0, ${JSON.stringify(PASTA)})
+try:
+    from primo_voz import desperta
+except Exception as e:
+    print(json.dumps({"ok": False, "error": "não consegui ler o módulo: %s" % e})); raise SystemExit
+try:
+    import vosk  # noqa: F401
+    temVosk = True
+except ImportError:
+    temVosk = False
+print(json.dumps({
+    "ok": bool(temVosk and desperta.tem_modelo()),
+    "temVosk": temVosk,
+    "temModelo": desperta.tem_modelo(),
+    "onde": str(desperta.caminho_do_modelo()),
+}))
+`;
+    try {
+        const saida = execFileSync(py, ['-c', perguntar],
+            { stdio: ['ignore', 'pipe', 'pipe'], timeout: 30000 }).toString();
+        const r = JSON.parse(saida.trim().split('\n').pop());
+        if (r.ok) return { ok: true };
+        // Falta só o modelo (ou o vosk, que o pip resolve): dá para oferecer.
+        return { ok: false, baixavel: true, temVosk: r.temVosk, onde: r.onde,
+            error: r.error || 'o reconhecedor local do nome não está instalado' };
+    } catch (e) {
+        return { ok: false, baixavel: false,
+            error: `não consegui conferir o reconhecedor: ${String(e.message || e).slice(-160)}` };
+    }
+}
+
+/** Instala o vosk (se faltar) e baixa o modelo. Uma vez, ~31 MB. */
+function baixarEspera(py) {
+    return new Promise((resolve) => {
+        const script = `
+import json, subprocess, sys
+sys.path.insert(0, ${JSON.stringify(PASTA)})
+try:
+    import vosk  # noqa: F401
+except ImportError:
+    # As mesmas estratégias do narrar.py: o pip do sistema recusa instalar
+    # em Debian/Ubuntu e no Homebrew (PEP 668), e uma tentativa só, calada,
+    # é a falha que ninguém vê.
+    for args in (["-m","pip","install","--user","--quiet","vosk"],
+                 ["-m","pip","install","--user","--quiet","--break-system-packages","vosk"],
+                 ["-m","pip","install","--quiet","vosk"],
+                 ["-m","pip","install","--quiet","--break-system-packages","vosk"]):
+        r = subprocess.run([sys.executable] + args, capture_output=True)
+        if r.returncode == 0:
+            break
+    try:
+        import vosk  # noqa: F401
+    except ImportError as e:
+        print(json.dumps({"ok": False, "error": "não consegui instalar o vosk: %s" % e}))
+        raise SystemExit
+from primo_voz import desperta
+print(json.dumps(desperta.baixar_modelo()))
+`;
+        const p = spawn(py, ['-c', script]);
+        let fora = '';
+        let erro = '';
+        p.stdout.on('data', (d) => { fora += d.toString(); });
+        p.stderr.on('data', (d) => { erro += d.toString(); });
+        p.on('close', () => {
+            try { resolve(JSON.parse(fora.trim().split('\n').pop())); }
+            catch { resolve({ ok: false, error: erro.slice(-300).trim() || 'o download não devolveu resposta' }); }
+        });
+        p.on('error', (e) => resolve({ ok: false, error: e.message }));
+    });
 }
 
-module.exports = { conferir, instalar, abrir, python, COMO_FALAR, PASTA };
+module.exports = { conferir, instalar, abrir, conferirEspera, baixarEspera, python, COMO_FALAR, PASTA };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "9.0.0",
+  "version": "9.2.0",
   "description": "PrimoCode — agente de engenharia com IA e cursor próprio. Requer conta Conecta Primo AI (Premium ou Super). Cria arquivos, roda comandos, controla navegador e desktop: abre apps, clica em botões e ícones pelo nome, digita e usa atalhos.",
   "main": "bin/primocode.js",
   "bin": {
@@ -8,7 +8,7 @@
   },
   "scripts": {
     "start": "node bin/primocode.js",
-    "test": "node test/tools.test.js && node test/ui.test.js && node test/entrada.test.js && node test/transparencia.test.js && node test/permissao.test.js && node test/skills.test.js && node test/estudio.test.js && node test/voz.test.js && node test/modo.test.js && node test/pasta.test.js && node test/catalogo.test.js && node test/desktop.test.js && node test/effort.test.js && node test/regressao.test.js && node test/memoria-conversa.test.js && node test/repeticao.test.js && node test/referencia.test.js && node test/parar.test.js && node test/continuar.test.js && node test/pipeline.test.js && node test/app.test.js && node test/aplicativo.test.js && node test/conta.test.mjs && node test/nuvem.test.js && node test/prazo.test.js && node test/primeira-vez.test.js && node test/janela.test.js && node test/pareamento.test.js && node test/fala.test.js && node test/especialistas.test.js && node test/empurrao.test.js"
+    "test": "node test/tools.test.js && node test/ui.test.js && node test/entrada.test.js && node test/transparencia.test.js && node test/permissao.test.js && node test/skills.test.js && node test/estudio.test.js && node test/voz.test.js && node test/modo.test.js && node test/pasta.test.js && node test/catalogo.test.js && node test/desktop.test.js && node test/effort.test.js && node test/regressao.test.js && node test/memoria-conversa.test.js && node test/repeticao.test.js && node test/referencia.test.js && node test/parar.test.js && node test/continuar.test.js && node test/pipeline.test.js && node test/app.test.js && node test/aplicativo.test.js && node test/conta.test.mjs && node test/nuvem.test.js && node test/prazo.test.js && node test/primeira-vez.test.js && node test/janela.test.js && node test/pareamento.test.js && node test/fala.test.js && node test/especialistas.test.js && node test/empurrao.test.js && node test/terminal-novo.test.js && node test/markdown.test.js && node test/coerencia.test.js"
   },
   "engines": {
     "node": ">=18.17.0"