primocode 10.19.0 → 11.1.0

package/lib/tool/lsp.js

@@ -0,0 +1,211 @@
+/**
+ * lsp.js — cliente mínimo de Language Server (stdio, JSON-RPC com Content-Length), sem dependência.
+ * Usado por lib/tool/diagnostico.js: depois de uma edição, abre/atualiza o arquivo no servidor de linguagem
+ * instalado e devolve os ERROS que ele publica (textDocument/publishDiagnostics). Sem servidor instalado,
+ * devolve { indisponivel: true } e o diagnostico.js cai nos verificadores simples.
+ *
+ *   .ts .tsx .js .jsx .mjs .cjs → typescript-language-server --stdio
+ *   .py → pyright-langserver --stdio · basedpyright-langserver · pylsp · ruff server
+ *   .go → gopls
+ * Procura primeiro em node_modules/.bin do projeto, depois no PATH. O servidor fica vivo entre edições
+ * (um por servidor+raiz) e é encerrado quando o processo sai. PRIMOCODE_SEM_LSP=1 desliga.
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+const { pathToFileURL } = require('url');
+
+const PRAZO_INICIO_MS = 15000;
+const PRAZO_DIAG_MS = 7000;
+const ASSENTAR_MS = 500;        // servidores mandam sintaxe e depois semântica: espera o último push assentar
+
+const SERVIDORES = {
+    ts: { ext: ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'], bins: [['typescript-language-server', ['--stdio']]],
+        lang: { '.ts': 'typescript', '.tsx': 'typescriptreact', '.js': 'javascript', '.jsx': 'javascriptreact', '.mjs': 'javascript', '.cjs': 'javascript' } },
+    py: { ext: ['.py'], bins: [['pyright-langserver', ['--stdio']], ['basedpyright-langserver', ['--stdio']], ['pylsp', []], ['ruff', ['server']]], lang: { '.py': 'python' } },
+    go: { ext: ['.go'], bins: [['gopls', []]], lang: { '.go': 'go' } },
+};
+
+function achar(nome, raiz) {
+    const dirs = [];
+    for (let d = raiz; ; d = path.dirname(d)) { dirs.push(path.join(d, 'node_modules', '.bin')); if (d === path.dirname(d)) break; }
+    dirs.push(...String(process.env.PATH || '').split(path.delimiter).filter(Boolean));
+    for (const d of dirs) {
+        for (const n of process.platform === 'win32' ? [nome + '.cmd', nome + '.exe'] : [nome]) {
+            const p = path.join(d, n);
+            try { fs.accessSync(p, fs.constants.X_OK); if (fs.statSync(p).isFile()) return p; } catch { /* próximo */ }
+        }
+    }
+    return null;
+}
+
+/** @returns {{chave:string, nome:string, cmd:string, args:string[], lang:string}|null} */
+function servidorPara(arquivo, raiz) {
+    if (process.env.PRIMOCODE_SEM_LSP === '1') return null;
+    const ext = path.extname(arquivo).toLowerCase();
+    for (const [chave, s] of Object.entries(SERVIDORES)) {
+        if (!s.ext.includes(ext)) continue;
+        for (const [nome, args] of s.bins) {
+            const cmd = achar(nome, raiz);
+            if (cmd) return { chave, nome, cmd, args, lang: s.lang[ext] };
+        }
+    }
+    return null;
+}
+
+/** O typescript-language-server pede o tsserver: do projeto, ou o que está ao lado dele (mesmo node_modules). */
+function acharTsserver(raiz, cmd) {
+    const cands = [];
+    for (let d = raiz; ; d = path.dirname(d)) { cands.push(path.join(d, 'node_modules', 'typescript', 'lib', 'tsserver.js')); if (d === path.dirname(d)) break; }
+    try { const real = fs.realpathSync(cmd); cands.push(path.join(real, '..', '..', '..', 'typescript', 'lib', 'tsserver.js'), path.join(real, '..', '..', 'node_modules', 'typescript', 'lib', 'tsserver.js')); } catch { /* */ }
+    cands.push(path.join(path.dirname(cmd), '..', 'typescript', 'lib', 'tsserver.js'));
+    return cands.map((c) => path.resolve(c)).find((c) => fs.existsSync(c)) || null;
+}
+
+class Cliente {
+    constructor(srv, raiz) {
+        this.srv = srv; this.raiz = raiz; this.id = 0; this.pend = new Map(); this.buf = Buffer.alloc(0);
+        this.diags = new Map();      // uri → { lista, quando, n }
+        this.versoes = new Map();    // uri → versão
+        this.ouvintes = [];
+        this.vivo = true;
+        this.p = spawn(srv.cmd, srv.args, { cwd: raiz, stdio: ['pipe', 'pipe', 'ignore'] });
+        this.p.on('error', () => { this.vivo = false; });
+        this.p.on('exit', () => { this.vivo = false; for (const [, r] of this.pend) r.reject(new Error('servidor saiu')); this.pend.clear(); });
+        this.p.stdin.on('error', () => { this.vivo = false; });
+        this.p.stdout.on('data', (b) => this._ler(b));
+        this.p.unref(); if (this.p.stdout.unref) this.p.stdout.unref(); if (this.p.stdin.unref) this.p.stdin.unref();
+    }
+
+    _ler(b) {
+        this.buf = Buffer.concat([this.buf, b]);
+        for (;;) {
+            const fim = this.buf.indexOf('\r\n\r\n');
+            if (fim < 0) return;
+            const m = /Content-Length:\s*(\d+)/i.exec(this.buf.slice(0, fim).toString('ascii'));
+            if (!m) { this.buf = this.buf.slice(fim + 4); continue; }
+            const n = Number(m[1]);
+            if (this.buf.length < fim + 4 + n) return;
+            const corpo = this.buf.slice(fim + 4, fim + 4 + n).toString('utf8');
+            this.buf = this.buf.slice(fim + 4 + n);
+            let msg; try { msg = JSON.parse(corpo); } catch { continue; }
+            this._msg(msg);
+        }
+    }
+
+    _msg(msg) {
+        if (msg.id != null && (msg.result !== undefined || msg.error) && this.pend.has(msg.id)) {
+            const r = this.pend.get(msg.id); this.pend.delete(msg.id);
+            return msg.error ? r.reject(new Error(msg.error.message || 'erro do servidor')) : r.resolve(msg.result);
+        }
+        if (msg.id != null && msg.method) {   // pedido do servidor: responde vazio (workspace/configuration etc.)
+            const res = msg.method === 'workspace/configuration' ? (msg.params.items || []).map(() => null) : null;
+            this._escrever({ jsonrpc: '2.0', id: msg.id, result: res });
+            return;
+        }
+        if (msg.method === 'textDocument/publishDiagnostics') {
+            const uri = msg.params.uri; const ant = this.diags.get(uri);
+            this.diags.set(uri, { lista: msg.params.diagnostics || [], quando: Date.now(), n: ((ant && ant.n) || 0) + 1 });
+            this.ouvintes.slice().forEach((f) => f(uri));
+        }
+    }
+
+    _escrever(obj) {
+        if (!this.vivo) return;
+        const s = JSON.stringify(obj);
+        try { this.p.stdin.write(`Content-Length: ${Buffer.byteLength(s)}\r\n\r\n${s}`); } catch { this.vivo = false; }
+    }
+
+    pedir(method, params, prazo = PRAZO_INICIO_MS) {
+        return new Promise((resolve, reject) => {
+            const id = ++this.id;
+            const t = setTimeout(() => { this.pend.delete(id); reject(new Error(`${method} não respondeu`)); }, prazo);
+            this.pend.set(id, { resolve: (v) => { clearTimeout(t); resolve(v); }, reject: (e) => { clearTimeout(t); reject(e); } });
+            this._escrever({ jsonrpc: '2.0', id, method, params });
+        });
+    }
+
+    avisar(method, params) { this._escrever({ jsonrpc: '2.0', method, params }); }
+
+    async iniciar() {
+        const ts = this.srv.chave === 'ts' ? acharTsserver(this.raiz, this.srv.cmd) : null;
+        await this.pedir('initialize', {
+            ...(ts ? { initializationOptions: { tsserver: { path: ts } } } : {}),
+            processId: process.pid, rootUri: pathToFileURL(this.raiz).href, workspaceFolders: [{ uri: pathToFileURL(this.raiz).href, name: path.basename(this.raiz) }],
+            capabilities: { textDocument: { publishDiagnostics: { relatedInformation: false }, synchronization: { didSave: true } }, workspace: { configuration: true, workspaceFolders: true } },
+        });
+        this.avisar('initialized', {});
+    }
+
+    /** Abre (ou atualiza) o arquivo e espera os diagnósticos assentarem. Devolve a lista (pode ser vazia). */
+    async diagnosticos(arquivo, texto, lang) {
+        const uri = pathToFileURL(arquivo).href;
+        const antes = (this.diags.get(uri) || { n: 0 }).n;
+        const v = (this.versoes.get(uri) || 0) + 1; this.versoes.set(uri, v);
+        if (v === 1) this.avisar('textDocument/didOpen', { textDocument: { uri, languageId: lang, version: v, text: texto } });
+        else { this.avisar('textDocument/didChange', { textDocument: { uri, version: v }, contentChanges: [{ text: texto }] }); this.avisar('textDocument/didSave', { textDocument: { uri }, text: texto }); }
+        return new Promise((resolve) => {
+            let assentar = null;
+            const fim = () => { clearTimeout(limite); clearTimeout(assentar); this.ouvintes = this.ouvintes.filter((f) => f !== ouve); const d = this.diags.get(uri); resolve(d && d.n > antes ? d.lista : null); };
+            const ouve = (u) => { if (u !== uri) return; clearTimeout(assentar); assentar = setTimeout(fim, ASSENTAR_MS); };
+            const limite = setTimeout(fim, PRAZO_DIAG_MS);
+            this.ouvintes.push(ouve);
+        });
+    }
+
+    encerrar() {
+        this.vivo = false;
+        try { this._escrever({ jsonrpc: '2.0', id: ++this.id, method: 'shutdown' }); this.avisar('exit'); } catch { /* */ }
+        try { this.p.kill(); } catch { /* */ }
+    }
+}
+
+const clientes = new Map();   // `${chave}|${raiz}` → Promise<Cliente>
+let gancho = false;
+function limpar() { for (const p of clientes.values()) p.then((c) => c.encerrar()).catch(() => {}); clientes.clear(); }
+
+function clienteDe(srv, raiz) {
+    const k = `${srv.nome}|${raiz}`;
+    const ja = clientes.get(k);
+    if (ja) return ja.then((c) => (c.vivo ? c : (clientes.delete(k), clienteDe(srv, raiz))));
+    const c = new Cliente(srv, raiz);
+    const p = c.iniciar().then(() => c, (e) => { c.encerrar(); clientes.delete(k); throw e; });
+    clientes.set(k, p);
+    if (!gancho) { gancho = true; process.on('exit', () => { for (const p2 of clientes.values()) p2.then((x) => { try { x.p.kill(); } catch { /* */ } }); }); }
+    return p;
+}
+
+function raizDoProjeto(arquivo, projectDir) {
+    for (let d = path.dirname(arquivo); ; d = path.dirname(d)) {
+        if (['tsconfig.json', 'package.json', 'pyproject.toml', 'go.mod', '.git'].some((f) => fs.existsSync(path.join(d, f)))) return d;
+        if (d === projectDir || d === path.dirname(d)) return projectDir;
+    }
+}
+
+function formatar(lista, arquivo) {
+    const erros = lista.filter((d) => d.severity === 1 || d.severity == null);
+    if (!erros.length) return '';
+    return erros.slice(0, 12).map((d) => `${path.basename(arquivo)}:${d.range.start.line + 1}:${d.range.start.character + 1} ${String(d.message).split('\n')[0]}${d.code != null ? ` [${d.code}]` : ''}`).join('\n')
+        + (erros.length > 12 ? `\n… e mais ${erros.length - 12} erros` : '');
+}
+
+/**
+ * @returns {Promise<{indisponivel:true}|{erros:string, verificador:string}|null>}
+ *   indisponivel = sem servidor (use o verificador simples) · null = servidor rodou e não achou erro
+ */
+async function diagnosticarLsp(arquivo, projectDir) {
+    const raiz = raizDoProjeto(arquivo, projectDir);
+    const srv = servidorPara(arquivo, raiz);
+    if (!srv) return { indisponivel: true };
+    try {
+        const c = await clienteDe(srv, raiz);
+        const lista = await c.diagnosticos(arquivo, fs.readFileSync(arquivo, 'utf-8'), srv.lang);
+        if (lista == null) return { indisponivel: true };   // o servidor não respondeu a tempo: não finge que checou
+        const erros = formatar(lista, arquivo);
+        return erros ? { erros, verificador: `LSP (${srv.nome})` } : null;
+    } catch (e) { if (process.env.PRIMOCODE_DEBUG_LSP) console.error('lsp:', e.message); return { indisponivel: true }; }
+}
+
+module.exports = { diagnosticarLsp, servidorPara, limpar, SERVIDORES };

package/lib/tool/perguntar.js

@@ -0,0 +1,114 @@
+/**
+ * perguntar.js — a ferramenta `perguntar`: pergunta + 2 a 4 opções (+ texto livre).
+ * Só pra quando o agente está BLOQUEADO (duas saídas razoáveis, não dá pra escolher sozinho).
+ *
+ * Quem desenha na tela é o terminal (ctx.escolher, vem do bin/primocode.js). Sem terminal
+ * (primocode -p, pipe, subagente) devolve a PRIMEIRA opção e registra no log — nunca trava esperando.
+ */
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const LOG = () => path.join(process.env.PRIMOCODE_HOME || path.join(os.homedir(), '.primocode'), 'perguntas-automaticas.log');
+
+function limparOpcoes(opcoes) {
+    let o = opcoes;
+    if (typeof o === 'string') { try { o = JSON.parse(o); } catch { o = o.split(/\n|;|\|/); } }
+    if (!Array.isArray(o)) return [];
+    return o.map((x) => String(x && (x.label || x.texto || x.opcao) || x || '').trim()).filter(Boolean).slice(0, 4);
+}
+
+async function perguntar(args, ctx = {}) {
+    const pergunta = String((args && (args.pergunta || args.question)) || '').trim();
+    const opcoes = limparOpcoes(args && (args.opcoes || args.options));
+    if (!pergunta) return { ok: false, error: 'faltou "pergunta".' };
+    if (opcoes.length < 2) return { ok: false, error: 'passe de 2 a 4 "opcoes" (lista de textos curtos).', comoResolver: 'perguntar pergunta:"...", opcoes:["A","B"]. Se não está bloqueado, escolha você e siga.' };
+    const livre = args.texto_livre !== false && args.texto_livre !== 'false';
+
+    if (typeof ctx.escolher !== 'function') {
+        const escolha = opcoes[0];
+        try {
+            fs.mkdirSync(path.dirname(LOG()), { recursive: true });
+            fs.appendFileSync(LOG(), `${new Date().toISOString()}\t${pergunta}\t[${opcoes.join(' | ')}]\t=> ${escolha}\n`);
+        } catch { /* log é só rastro */ }
+        return { ok: true, escolha, indice: 0, automatico: true,
+            aviso: 'Sem terminal: ninguém pode responder, então valeu a primeira opção. Siga com ela e diga isso no fim.' };
+    }
+    const r = await ctx.escolher(pergunta, opcoes, { livre });
+    if (r == null) return { ok: true, escolha: opcoes[0], indice: 0, automatico: true, aviso: 'A pessoa não respondeu; valeu a primeira opção.' };
+    if (typeof r === 'number') return { ok: true, escolha: opcoes[r] || opcoes[0], indice: opcoes[r] ? r : 0 };
+    return { ok: true, escolha: String(r), indice: -1, texto_livre: true };
+}
+
+/** O desenho no terminal: lista numerada + "ou escreva". `ask(prompt) → Promise<string>`. Enter = opção 1. */
+async function escolherNoTerminal(ask, c, pergunta, opcoes, { livre = true } = {}) {
+    console.log('');
+    console.log('  ' + c.brand('?') + ' ' + c.bold(c.white(pergunta)));
+    opcoes.forEach((o, i) => console.log('  ' + c.brand(String(i + 1)) + c.muted(' › ') + c.white(o)));
+    console.log('  ' + c.dim(livre ? `Enter = 1 · ou escreva a sua resposta` : 'Enter = 1'));
+    const dito = String(await ask('  ' + c.brand('❯ ') + c.muted(`1-${opcoes.length} `))).trim();
+    if (!dito) return 0;
+    const n = Number(dito);
+    if (Number.isInteger(n) && n >= 1 && n <= opcoes.length) return n - 1;
+    const igual = opcoes.findIndex((o) => o.toLowerCase() === dito.toLowerCase());
+    if (igual >= 0) return igual;
+    return livre ? dito : 0;
+}
+
+/**
+ * O picker com setas: ↑/↓ (ou j/k) movem, Enter escolhe, 1-4 escolhe direto, Esc = 1ª opção.
+ * Com `livre`, a última linha é "Outra resposta…": Enter nela chama `ask` pra pessoa digitar.
+ * `io` = { stdin, stdout, suspender?, retomar? } (no terminal: process.stdin/stdout e a caixa de digitar).
+ * Devolve índice (number) ou texto livre (string). Terminal que não é TTY: use escolherNoTerminal.
+ */
+function escolherComSetas(io, c, pergunta, opcoes, { livre = true, ask } = {}) {
+    return new Promise((resolve) => {
+        const { stdin, stdout } = io;
+        const itens = livre && ask ? [...opcoes, 'Outra resposta…'] : opcoes.slice();
+        let sel = 0, desenhado = 0;
+        const linhas = () => [
+            '  ' + c.brand('?') + ' ' + c.bold(c.white(pergunta)),
+            ...itens.map((o, i) => (i === sel ? '  ' + c.brand('❯ ') + c.bold(c.white(`${i + 1}. ${o}`)) : '  ' + c.muted(`  ${i + 1}. ${o}`))),
+            '  ' + c.dim('↑↓ move · Enter escolhe · 1-' + itens.length + ' direto · Esc = 1'),
+        ];
+        const pintar = () => {
+            if (desenhado) stdout.write(`\x1b[${desenhado}A`);
+            const ls = linhas();
+            stdout.write(ls.map((l) => '\x1b[2K' + l).join('\n') + '\n');
+            desenhado = ls.length;
+        };
+        let feito = false;
+        const sair = (valor) => {
+            if (feito) return; feito = true;
+            stdin.removeListener('keypress', aoTeclar); stdin.removeListener('end', aoAcabar);
+            if (io.retomar) io.retomar();
+            resolve(valor);
+        };
+        const escolher = async (i) => {
+            if (livre && ask && i === itens.length - 1) {
+                stdin.removeListener('keypress', aoTeclar); stdin.removeListener('end', aoAcabar);
+                if (io.retomar) io.retomar();
+                feito = true;
+                const dito = String(await ask('  ' + c.brand('❯ ') + c.muted('sua resposta: '))).trim();
+                return resolve(dito || 0);
+            }
+            sair(i);
+        };
+        const aoTeclar = (ch, key = {}) => {
+            const nome = key.name;
+            if (nome === 'up' || ch === 'k') { sel = (sel + itens.length - 1) % itens.length; pintar(); }
+            else if (nome === 'down' || nome === 'tab' || ch === 'j') { sel = (sel + 1) % itens.length; pintar(); }
+            else if (nome === 'return' || nome === 'enter') escolher(sel);
+            else if (nome === 'escape' || (key.ctrl && nome === 'c')) sair(0);
+            else if (/^[1-9]$/.test(ch || '') && Number(ch) <= itens.length) { sel = Number(ch) - 1; pintar(); escolher(sel); }
+        };
+        const aoAcabar = () => sair(0);
+        if (io.suspender) io.suspender();
+        stdin.on('keypress', aoTeclar); stdin.once('end', aoAcabar);
+        pintar();
+    });
+}
+
+module.exports = { perguntar, escolherNoTerminal, escolherComSetas, limparOpcoes };

package/lib/tool/reparar-entrada.js

@@ -0,0 +1,66 @@
+/**
+ * reparar-entrada.js — conserta o argumento da ferramenta que o modelo grátis mandou com o TIPO errado.
+ *
+ * Modelo pequeno manda {"limit":"20"}, {"replace_all":"false"}, {"edits":"[...]"} ou {"offset":null}.
+ * Sem reparo, a ferramenta recusa e o modelo gasta uma volta inteira só pra trocar aspas.
+ * Ideia e regras portadas do ToolInputRepairPlugin do OpenCode (MIT, ver LICENSES/opencode-MIT.txt);
+ * código reescrito em JS, sobre um schema simples ({ campo: 'number'|'boolean'|'array'|'object'|'string' }).
+ *
+ * Regra de ouro (a mesma do casar.js): só repara quando o schema deixa claro. Na dúvida, devolve como veio.
+ *
+ *   reparar(args, schema)  → novo objeto (puro, não muda o original)
+ *   SCHEMAS                → tipos dos campos das ferramentas do agente
+ */
+
+'use strict';
+
+const SCHEMAS = {
+    read_file: { offset: 'number', limit: 'number' },
+    edit_file: { replace_all: 'boolean' },
+    multi_edit: { edits: 'array' },
+    write_todos: { todos: 'array' },
+    glob: { limit: 'number' },
+    run_shell: { timeout_ms: 'number', em_segundo_plano: 'boolean' },
+    perguntar: { opcoes: 'array', texto_livre: 'boolean' },
+    buscar_web: { limite: 'number' },
+    ler_url: { max_chars: 'number', desde: 'number' },
+    grep: { limit: 'number', context: 'number', ignore_case: 'boolean' },
+};
+
+function jsonOuNada(s) {
+    try { return { ok: true, v: JSON.parse(s) }; } catch { return { ok: false }; }
+}
+
+function converter(valor, tipo) {
+    if (valor === null) return undefined; // opcional com null → como se não tivesse vindo
+    if (typeof valor === 'string') {
+        const t = valor.trim();
+        if (tipo === 'number' && /^-?\d+(\.\d+)?$/.test(t)) return Number(t);
+        if (tipo === 'boolean' && /^(true|false)$/i.test(t)) return t.toLowerCase() === 'true';
+        if (tipo === 'array' || tipo === 'object') {
+            const j = jsonOuNada(t);
+            if (j.ok && (tipo === 'array' ? Array.isArray(j.v) : j.v && typeof j.v === 'object' && !Array.isArray(j.v))) return j.v;
+        }
+    }
+    return valor;
+}
+
+function reparar(args, schema) {
+    let a = args;
+    if (typeof a === 'string') { // objeto inteiro virou texto: '{"limit":"20"}'
+        const j = jsonOuNada(a);
+        if (!j.ok || !j.v || typeof j.v !== 'object' || Array.isArray(j.v)) return args;
+        a = j.v;
+    }
+    if (!a || typeof a !== 'object' || !schema) return a;
+    const out = { ...a };
+    for (const [campo, tipo] of Object.entries(schema)) {
+        if (!(campo in out)) continue;
+        const v = converter(out[campo], tipo);
+        if (v === undefined) delete out[campo];
+        else out[campo] = v;
+    }
+    return out;
+}
+
+module.exports = { reparar, SCHEMAS };