primocode 10.17.1 → 11.0.0

package/lib/placar.js

@@ -0,0 +1,173 @@
+/**
+ * placar.js — o PrimoCode aprende, por pessoa, qual modelo grátis acerta mais em cada tipo de tarefa.
+ *
+ * Tudo local (~/.primocode/placar.json): nada sai da máquina. Cada tarefa vira um TIPO (editar código,
+ * corrigir erro, app novo, design/CSS, pesquisa, escrita, vídeo/motion, documentos/slides). Cada
+ * desfecho vira um ponto pra (tipo, modelo): ganhou ou perdeu. O modelo é escolhido pela média
+ * Beta(1+ganhos, 1+perdas); só vale depois de MIN_AMOSTRAS; e em ~10% das vezes explora outro,
+ * pra o placar não travar no primeiro que acertou.
+ *
+ * Quem fixou modelo (/model) nunca é mexido. O servidor recebe a escolha como DICA (`preferido`)
+ * e só a honra se o modelo estiver na corrente do apelido; sem dica ou sem ele, nada muda.
+ *
+ * Sinais de ganho: testes passaram, diagnóstico limpo depois da edição, sem /undo logo depois,
+ * tarefa concluída. Perda: o contrário (teste falhando no fim, erro de diagnóstico sobrando,
+ * parou sem concluir, /undo).
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const TIPOS = {
+    'editar-codigo': 'editar código',
+    'corrigir-erro': 'corrigir erro',
+    'app-novo': 'app novo',
+    'design-css': 'design / CSS',
+    'pesquisa': 'pesquisa',
+    'escrita': 'escrita',
+    'video-motion': 'vídeo / motion',
+    'documentos': 'documentos / slides',
+};
+const MIN_AMOSTRAS = 5;
+const EXPLORACAO = 0.10;
+
+// Ordem importa: o mais específico primeiro.
+const REGRAS = [
+    ['video-motion', /\b(v[ií]deo|motion|anima[çc][ãa]o|animar|reel|legenda|edi[çc][ãa]o de v|lettering|trilha|cena)\b/i],
+    ['documentos', /\b(slides?|apresenta[çc][ãa]o|pptx|docx|pdf|planilha|xlsx|documento|proposta|relat[óo]rio em)\b/i],
+    ['corrigir-erro', /\b(bug|erro|quebr\w+|n[ãa]o funciona|falh\w+|corrig\w+|conserta\w*|consert\w+|crash|exception|stack ?trace|travando|n[ãa]o abre)\b/i],
+    ['design-css', /\b(css|design|layout|visual|cor(es)?|fonte|tipografia|responsiv\w+|espa[çc]amento|bonit\w+|tema|dark mode|tailwind|estilo)\b/i],
+    ['app-novo', /\b(cri(e|ar|a) (um|uma|o|a) (app|aplicativo|site|landing|p[áa]gina|jogo|sistema|api)|do zero|novo (app|projeto|site)|landing page|construa|construir)\b/i],
+    ['pesquisa', /\b(pesquis\w+|compar\w+|qual (a )?(melhor|diferen[çc]a)|o que [ée]|como funciona|explique|explica|investig\w+|estude|levantamento)\b/i],
+    ['escrita', /\b(escrev\w+|texto|post|e-?mail|copy|roteiro|artigo|resum\w+|traduz\w*|reescrev\w+|legenda de post)\b/i],
+];
+
+function classificar(texto) {
+    const t = String(texto || '').slice(0, 2000);
+    for (const [tipo, re] of REGRAS) if (re.test(t)) return tipo;
+    return 'editar-codigo';
+}
+
+const idCurto = (m) => String(m || '').replace(/^[a-z0-9]+:/i, '');   // tira o `gemini:`: o servidor conta o id limpo
+
+// ── a matemática ─────────────────────────────────────────────────────
+/** Média da Beta(1+ganhos, 1+perdas): começa em 50% e anda com os dados. */
+function pontuacao(ganhos, perdas) { return (1 + ganhos) / (2 + ganhos + perdas); }
+
+function amostras(c) { return (c && (c.ganhos || 0) + (c.perdas || 0)) || 0; }
+
+/**
+ * Escolhe o modelo do tipo entre os disponíveis. `rand` é injetável (teste).
+ * Volta { modelo, motivo } ou null (sem dica: o servidor decide como sempre).
+ */
+function escolher(dados, tipo, disponiveis, { rand = Math.random, minimo = MIN_AMOSTRAS, exploracao = EXPLORACAO } = {}) {
+    const lista = (disponiveis || []).filter(Boolean);
+    if (!lista.length) return null;
+    const celulas = (dados && dados.tipos && dados.tipos[tipo]) || {};
+    const conta = (m) => celulas[idCurto(m)] || { ganhos: 0, perdas: 0 };
+    const confiaveis = lista.filter((m) => amostras(conta(m)) >= minimo);
+    if (!confiaveis.length) return null;                       // ainda não sabe: não opina
+    if (lista.length > 1 && rand() < exploracao) {
+        const outros = lista.slice().sort((a, b) => amostras(conta(a)) - amostras(conta(b)));
+        const menos = amostras(conta(outros[0]));
+        const empatados = outros.filter((m) => amostras(conta(m)) === menos);
+        return { modelo: empatados[Math.floor(rand() * empatados.length) % empatados.length], motivo: 'explorando' };
+    }
+    let melhor = confiaveis[0];
+    for (const m of confiaveis) if (pontuacao(conta(m).ganhos, conta(m).perdas) > pontuacao(conta(melhor).ganhos, conta(melhor).perdas)) melhor = m;
+    return { modelo: melhor, motivo: 'lider' };
+}
+
+// ── o arquivo ────────────────────────────────────────────────────────
+const arquivo = (home) => path.join(home || process.env.PRIMOCODE_PLACAR_DIR || path.join(os.homedir(), '.primocode'), 'placar.json');   // PRIMOCODE_PLACAR_DIR: o teste não suja o placar de verdade
+
+function ler(home) {
+    try {
+        const j = JSON.parse(fs.readFileSync(arquivo(home), 'utf8'));
+        return j && typeof j === 'object' && j.tipos ? j : { v: 1, tipos: {} };
+    } catch { return { v: 1, tipos: {} }; }
+}
+
+function gravar(dados, home) {
+    try {
+        const f = arquivo(home);
+        fs.mkdirSync(path.dirname(f), { recursive: true });
+        fs.writeFileSync(f, JSON.stringify(dados, null, 2));
+        return true;
+    } catch { return false; }
+}
+
+let ultimo = null;   // o último desfecho gravado: o /undo logo depois vira perda
+
+function registrar(tipo, modelo, venceu, home) {
+    if (!TIPOS[tipo] || !modelo || typeof venceu !== 'boolean') return false;
+    const d = ler(home);
+    const m = idCurto(modelo);
+    const cel = ((d.tipos[tipo] = d.tipos[tipo] || {})[m] = d.tipos[tipo][m] || { ganhos: 0, perdas: 0 });
+    cel[venceu ? 'ganhos' : 'perdas']++;
+    ultimo = { tipo, modelo: m, venceu };
+    return gravar(d, home);
+}
+
+/** O /undo veio logo depois: o que contava como ganho vira perda. */
+function desfez(home) {
+    if (!ultimo || !ultimo.venceu) return false;
+    const d = ler(home);
+    const cel = d.tipos[ultimo.tipo] && d.tipos[ultimo.tipo][ultimo.modelo];
+    if (!cel || cel.ganhos < 1) return false;
+    cel.ganhos--; cel.perdas++;
+    ultimo = { ...ultimo, venceu: false };
+    return gravar(d, home);
+}
+
+function zerar(home) { ultimo = null; return gravar({ v: 1, tipos: {} }, home); }
+
+/** O desfecho de uma tarefa a partir dos sinais. true/false, ou null se não deu pra dizer. */
+function veredito(s = {}, concluiu) {
+    if (!s.modelo) return null;
+    if (s.testes === false || s.diagSujo || concluiu === false) return false;
+    if (s.testes === true || s.diagLimpo || concluiu === true) return true;
+    return null;
+}
+
+/** Fecha uma tarefa: grava o desfecho. Vem do runAct (lib/act.js). */
+function fechar(tipo, sinais, concluiu, home) {
+    const v = veredito(sinais, concluiu);
+    if (v === null) return null;
+    registrar(tipo, sinais.modelo, v, home);
+    return v;
+}
+
+// ── a tela do /placar ────────────────────────────────────────────────
+function tabela(dados) {
+    const linhas = [];
+    for (const [tipo, rotulo] of Object.entries(TIPOS)) {
+        const cel = (dados.tipos && dados.tipos[tipo]) || {};
+        for (const [modelo, c] of Object.entries(cel)) {
+            const n = amostras(c);
+            if (!n) continue;
+            const taxa = Math.round((c.ganhos / n) * 100);
+            linhas.push({ tipo: rotulo, modelo, taxa, n, firme: n >= MIN_AMOSTRAS });
+        }
+    }
+    return linhas.sort((a, b) => a.tipo.localeCompare(b.tipo) || b.taxa - a.taxa || b.n - a.n);
+}
+
+function texto(dados) {
+    const t = tabela(dados);
+    if (!t.length) return 'O placar ainda está vazio. Conforme você usa o PrimoCode, ele anota qual modelo grátis acertou mais em cada tipo de tarefa (só neste computador).';
+    const w = Math.max(...t.map((x) => x.modelo.length), 6);
+    const out = ['Qual modelo grátis acerta mais, por tipo de tarefa (só neste computador):', ''];
+    let atual = '';
+    for (const x of t) {
+        if (x.tipo !== atual) { atual = x.tipo; out.push(`  ${x.tipo}`); }
+        out.push(`    ${x.modelo.padEnd(w)}  acerta ${String(x.taxa).padStart(3)}%  em ${x.n} ${x.n === 1 ? 'tarefa' : 'tarefas'}${x.firme ? '' : '  (ainda pouco dado)'}`);
+    }
+    out.push('', `Ele só passa a escolher sozinho depois de ${MIN_AMOSTRAS} tarefas por modelo, e de vez em quando testa outro. /placar zerar apaga tudo.`);
+    return out.join('\n');
+}
+
+module.exports = { TIPOS, MIN_AMOSTRAS, EXPLORACAO, classificar, pontuacao, escolher, ler, gravar, registrar, desfez, zerar, veredito, fechar, tabela, texto, arquivo };

package/lib/plano-previo.js

@@ -0,0 +1,53 @@
+/**
+ * plano-previo.js — o /plan: o agente mostra os passos e só começa quando a pessoa deixa.
+ *
+ *   pedidoDoPlano(pedido)            → o pedido da 1ª fase (roda no modo plano: só lê)       (puro)
+ *   extrairPassos(texto)             → ['passo', …] (3 a 5, tirados da lista numerada)        (puro)
+ *   resposta(texto, passos)          → { acao: 'comecar' | 'cancelar' | 'editar' | 'invalida', n? }   (puro)
+ *   comoPassos(pedido, passos)       → [{ titulo, pedido }] no formato do enviarPedido        (puro)
+ *
+ * Nada de planejador novo: a 1ª fase usa o modo "plano" de lib/perigo.js (recusa escrita), e a 2ª entrega os passos
+ * aprovados ao laço de passos que o enviarPedido já tem (checkpoint do pedido inteiro, fatos passados de um passo
+ * pro outro, retomada). Quem não programa não precisa saber disso: vê 3 a 5 frases e aperta Enter.
+ */
+
+'use strict';
+
+const MAX = 5;
+
+function pedidoDoPlano(pedido) {
+    return `Ainda NÃO faça nada: só planeje. Pode ler arquivos do projeto para entender, mas não mude nada.\n\n`
+        + `O pedido é: ${String(pedido || '').trim()}\n\n`
+        + `Responda SÓ com uma lista numerada de 3 a ${MAX} passos, uma frase curta por passo, em linguagem simples, `
+        + `sem jargão e sem código. Cada passo diz o que vai ficar diferente para quem usa. Sem introdução e sem despedida.`;
+}
+
+function extrairPassos(texto) {
+    const linhas = String(texto || '').split('\n');
+    const passos = [];
+    for (const l of linhas) {
+        const m = l.match(/^\s*(?:\d+[.)]|[-*•])\s+(.+?)\s*$/);
+        if (m) passos.push(m[1].replace(/\*\*/g, '').trim());
+    }
+    return passos.filter(Boolean).slice(0, MAX);
+}
+
+function resposta(texto, passos) {
+    const t = String(texto || '').trim().toLowerCase();
+    if (!t || /^(s|sim|y|yes|ok|vai|bora|começa|comeca)$/.test(t)) return { acao: 'comecar' };
+    if (/^(n|nao|não|no|cancela|cancelar|para|parar)$/.test(t)) return { acao: 'cancelar' };
+    const n = /^\d+$/.test(t) ? Number(t) : 0;
+    if (n >= 1 && n <= passos.length) return { acao: 'editar', n };
+    return { acao: 'invalida' };
+}
+
+function comoPassos(pedido, passos) {
+    const lista = passos.map((p, i) => `${i + 1}. ${p}`).join('\n');
+    return passos.map((p, i) => ({
+        titulo: `passo ${i + 1} de ${passos.length}: ${p}`.slice(0, 90),
+        pedido: `${String(pedido).trim()}\n\nO PLANO que a pessoa aprovou:\n${lista}\n\n`
+            + `Faça AGORA só o passo ${i + 1} (${p}). Não faça os outros ainda; eles vêm nos próximos passos.`,
+    }));
+}
+
+module.exports = { MAX, pedidoDoPlano, extrairPassos, resposta, comoPassos };

package/lib/planos.js

@@ -93,7 +93,7 @@ function desenhar({ planos, gratis, ok }, { cores: c, atual = null, site }) {
     } else {
         linhas.push(c.dim('  (sem resposta do servidor: valores de referência, sem link de compra)'), '');
     }
-    linhas.push(c.dim('  Também em ') + c.brand(`${site}/planos`) + c.dim(' · já assinou? ') + c.brand('/account') + c.dim(' atualiza.'));
+    linhas.push(c.dim('  Também em ') + c.brand(`${site}/account plans`) + c.dim(' · já assinou? ') + c.brand('/account') + c.dim(' atualiza.'));
     linhas.push('');
     return linhas;
 }

package/lib/plugin/autoteste.js

@@ -0,0 +1,99 @@
+/**
+ * autoteste.js — o app se testa sozinho (ideia do Replit Agent). Depois de construir um app web:
+ *   1. sobe o app (lib/plugin/preview.js)
+ *   2. abre no navegador (lib/browser.js, o mesmo do agente)
+ *   3. clica nos fluxos principais (botões, links internos, submit de formulário), anotando erros do console,
+ *      erros de página e prints
+ *   4. se falhou, devolve as falhas pro agente consertar — no máximo 2 rodadas
+ *
+ * `navegador` é injetável: { open(url), evaluate(js), clickSelector(sel), screenshot(path), wait(ms) } — o padrão é lib/browser.js.
+ * Sem Chrome/Playwright no computador o passo diz isso e não finge ter testado.
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const MAX_RODADAS = 2;
+
+/** Injeta um coletor de erros na página (antes dos cliques). */
+const COLETOR = `(function(){ if (window.__primoErros) return 1; window.__primoErros = [];
+  window.addEventListener('error', function(e){ window.__primoErros.push('erro: ' + (e.message || e)); });
+  window.addEventListener('unhandledrejection', function(e){ window.__primoErros.push('promessa sem catch: ' + ((e.reason && e.reason.message) || e.reason)); });
+  var ce = console.error; console.error = function(){ window.__primoErros.push('console.error: ' + Array.prototype.slice.call(arguments).join(' ')); ce.apply(console, arguments); };
+  return 1; })()`;
+
+/** Os alvos clicáveis do fluxo principal (até `max`), como seletores estáveis. */
+const ALVOS = `(function(max){
+  var out = [], vistos = {};
+  function sel(el){ if (el.id) return '#' + CSS.escape(el.id);
+    var i = Array.prototype.indexOf.call(el.parentNode.children, el) + 1;
+    return (el.parentNode === document.body ? 'body' : sel(el.parentNode)) + ' > ' + el.tagName.toLowerCase() + ':nth-child(' + i + ')'; }
+  document.querySelectorAll('button, [role=button], input[type=submit], input[type=button], a[href]').forEach(function(el){
+    if (out.length >= max) return;
+    var r = el.getBoundingClientRect(); if (!r.width || !r.height || el.disabled) return;
+    if (el.tagName === 'A') { var h = el.getAttribute('href') || ''; if (!/^(#|\\/|\\.)/.test(h) || h === '#') return; }
+    var s = sel(el); if (vistos[s]) return; vistos[s] = 1;
+    out.push({ seletor: s, nome: (el.innerText || el.value || el.getAttribute('aria-label') || el.tagName).trim().slice(0, 40) });
+  });
+  return out; })`;
+
+/** Roda uma passada: devolve { ok, erros: [], prints: [], cliques: n }. */
+async function passada({ url, navegador, dir, max = 6, nome = 'r1' }) {
+    const erros = [], prints = [];
+    const pasta = path.join(dir, '.primocode', 'autoteste');
+    fs.mkdirSync(pasta, { recursive: true });
+    await navegador.open(url);
+    await navegador.evaluate(COLETOR);
+    const alvos = (await navegador.evaluate(`${ALVOS}(${max})`)) || [];
+    const tira = async (rotulo) => { try { const r = await navegador.screenshot(path.join(pasta, `${nome}-${rotulo}.png`)); prints.push(r.path); } catch { /* sem print */ } };
+    await tira('abertura');
+    let cliques = 0;
+    for (const a of alvos) {
+        try { await navegador.clickSelector(a.seletor); cliques++; await (navegador.wait ? navegador.wait(400) : null); }
+        catch (e) { erros.push(`não consegui clicar em "${a.nome}": ${String(e.message || e).split('\n')[0]}`); }
+        await navegador.evaluate(COLETOR);   // a página pode ter recarregado
+        const feitos = (await navegador.evaluate('(window.__primoErros || []).splice(0)').catch(() => [])) || [];
+        for (const f of feitos) erros.push(`ao clicar em "${a.nome}": ${f}`);
+        const atual = await navegador.evaluate('location.href').catch(() => url);
+        if (atual && !String(atual).startsWith(url.replace(/\/$/, ''))) { erros.push(`"${a.nome}" levou pra fora do app (${atual})`); await navegador.open(url); await navegador.evaluate(COLETOR); }
+    }
+    await tira('fim');
+    const finais = (await navegador.evaluate('(window.__primoErros || []).splice(0)').catch(() => [])) || [];
+    erros.push(...finais);
+    return { ok: !erros.length, erros: [...new Set(erros)], prints, cliques, alvos: alvos.length };
+}
+
+/**
+ * O laço completo. `consertar(falhas)` é chamado quando há erro (devolve uma Promise): é o agente corrigindo.
+ * Devolve { ok, rodadas, relatorio: [passada...], erro? }.
+ */
+async function testar({ dir, navegador, subir, consertar, rodadasMax = MAX_RODADAS, log = () => {} }) {
+    subir = subir || ((d) => require('./preview.js').subir(d));
+    if (!navegador) { try { navegador = require('../browser.js'); } catch (e) { return { ok: false, rodadas: 0, relatorio: [], erro: 'sem navegador: ' + e.message }; } }
+    const app = await subir(dir);
+    if (!app.ok) return { ok: false, rodadas: 0, relatorio: [], erro: `não consegui subir o app: ${app.erro}` };
+    log(`app no ar em ${app.url}`);
+    const relatorio = [];
+    try {
+        for (let r = 0; r <= rodadasMax; r++) {
+            let p;
+            try { p = await passada({ url: app.url, navegador, dir, nome: `r${r + 1}` }); }
+            catch (e) { return { ok: false, rodadas: r, relatorio, erro: `o navegador não abriu (${String(e.message || e).split('\n')[0]}) — não testei` }; }
+            relatorio.push(p);
+            log(p.ok ? `rodada ${r + 1}: ${p.cliques} cliques, sem erros` : `rodada ${r + 1}: ${p.erros.length} problema(s)`);
+            if (p.ok) return { ok: true, rodadas: r, relatorio };
+            if (r === rodadasMax || !consertar) break;
+            await consertar(p.erros, p.prints);       // até 2 consertos
+        }
+        return { ok: false, rodadas: Math.min(relatorio.length - 1, rodadasMax), relatorio, erro: 'ainda com erros depois dos consertos' };
+    } finally { try { app.parar(); } catch { /* */ } }
+}
+
+/** O pedido que volta pro agente com as falhas. */
+function pedidoDeConserto(erros, prints = []) {
+    return `Testei o app abrindo e clicando nos fluxos principais e deu problema:\n${erros.map((e) => '- ' + e).join('\n')}\n`
+        + (prints.length ? `Prints: ${prints.join(', ')}\n` : '') + 'Conserte a causa de cada um e não mude o resto.';
+}
+
+module.exports = { testar, passada, pedidoDeConserto, COLETOR, MAX_RODADAS };

package/lib/plugin/edicao-visual.js

@@ -0,0 +1,133 @@
+/**
+ * edicao-visual.js — editar clicando (ideia do Lovable/v0). No preview local, um overlay injetado deixa a pessoa
+ * apontar um elemento da página; o PrimoCode captura:
+ *   seletor CSS + outerHTML (cortado) + texto + palpite do arquivo-fonte
+ * pergunta "o que mudar?" (na própria página) e manda o pedido pro agente.
+ *
+ *   injetar(html)                      → html com o overlay antes de </body>
+ *   palpiteArquivo(dir, captura)       → [{ arquivo, pontos }]  (id, classes e texto procurados no código)
+ *   montarPedido(captura, mudanca, p)  → o texto que vai pro agente
+ *   tratar(dir, aoEditar)              → `extra(req,res)` pro servidor do preview: recebe o POST /__primo/editar
+ *   proxiar(alvo, porta, opcoes)       → servidor que repassa um dev server e injeta o overlay no HTML
+ *
+ * O palpite é só isso: um palpite (grep), dito como tal no pedido. O agente confere no arquivo.
+ */
+'use strict';
+
+const fs = require('fs');
+const http = require('http');
+const path = require('path');
+
+const ROTA = '/__primo/editar';
+const MARCA = 'data-primo-overlay';
+
+const OVERLAY = `(function(){
+  if (window.__primoOverlay) return; window.__primoOverlay = 1;
+  var ligado = false, cx = document.createElement('div');
+  cx.setAttribute('${MARCA}', '1');
+  cx.style.cssText = 'position:fixed;pointer-events:none;border:2px solid #7c5cff;background:rgba(124,92,255,.12);z-index:2147483646;display:none;border-radius:3px';
+  var bt = document.createElement('button'); bt.setAttribute('${MARCA}', '1'); bt.textContent = '✎ Editar';
+  bt.style.cssText = 'position:fixed;right:16px;bottom:16px;z-index:2147483647;padding:10px 14px;border:0;border-radius:999px;background:#7c5cff;color:#fff;font:600 13px system-ui;cursor:pointer;box-shadow:0 4px 16px rgba(0,0,0,.3)';
+  document.body.appendChild(cx); document.body.appendChild(bt);
+  function ehNosso(el){ return el && el.closest && el.closest('[${MARCA}]'); }
+  function seletor(el){
+    if (el.id) return '#' + CSS.escape(el.id);
+    if (el === document.body) return 'body';
+    var i = Array.prototype.indexOf.call(el.parentNode.children, el) + 1;
+    return seletor(el.parentNode) + ' > ' + el.tagName.toLowerCase() + ':nth-child(' + i + ')';
+  }
+  bt.addEventListener('click', function(e){ e.stopPropagation(); ligado = !ligado; bt.textContent = ligado ? '✕ Sair da edição' : '✎ Editar'; cx.style.display = 'none'; document.body.style.cursor = ligado ? 'crosshair' : ''; });
+  document.addEventListener('mouseover', function(e){ if (!ligado || ehNosso(e.target)) return; var r = e.target.getBoundingClientRect();
+    cx.style.display = 'block'; cx.style.left = r.left + 'px'; cx.style.top = r.top + 'px'; cx.style.width = r.width + 'px'; cx.style.height = r.height + 'px'; }, true);
+  document.addEventListener('click', function(e){
+    if (!ligado || ehNosso(e.target)) return;
+    e.preventDefault(); e.stopPropagation();
+    var el = e.target, cap = { url: location.pathname, seletor: seletor(el), html: el.outerHTML.slice(0, 2000), texto: (el.innerText || '').trim().slice(0, 200), tag: el.tagName.toLowerCase(), id: el.id || '', classes: (el.getAttribute('class') || '') };
+    var mud = window.prompt('O que mudar neste elemento?\\n' + cap.seletor);
+    if (!mud) return;
+    cap.mudanca = mud;
+    fetch('${ROTA}', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(cap) })
+      .then(function(r){ return r.json(); }).then(function(j){ bt.textContent = j && j.ok ? '✓ Enviado ao PrimoCode' : '! Falhou'; setTimeout(function(){ bt.textContent = ligado ? '✕ Sair da edição' : '✎ Editar'; }, 2500); })
+      .catch(function(){ bt.textContent = '! Falhou'; });
+  }, true);
+})();`;
+
+function injetar(html) {
+    if (String(html).includes('__primoOverlay')) return html;
+    const tag = `<script ${MARCA}="1">${OVERLAY}</script>`;
+    return /<\/body>/i.test(html) ? html.replace(/<\/body>/i, () => tag + '</body>') : html + tag;
+}
+
+const PULA = new Set(['node_modules', '.git', 'dist', 'build', '.next', '.primocode', 'pesquisas']);
+const EXTS = new Set(['.html', '.htm', '.js', '.jsx', '.ts', '.tsx', '.vue', '.svelte', '.css', '.scss', '.astro', '.md']);
+
+function* arquivos(dir, prof = 0) {
+    if (prof > 6) return;
+    let ents = []; try { ents = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
+    for (const e of ents) {
+        if (PULA.has(e.name) || e.name.startsWith('.')) continue;
+        const p = path.join(dir, e.name);
+        if (e.isDirectory()) yield* arquivos(p, prof + 1);
+        else if (EXTS.has(path.extname(e.name).toLowerCase())) yield p;
+    }
+}
+
+/** Procura no código o id, as classes e o texto do elemento. Mais pontos = mais provável. */
+function palpiteArquivo(dir, cap, max = 3) {
+    const classes = String(cap.classes || '').split(/\s+/).filter((c) => c.length > 2);
+    const texto = String(cap.texto || '').split('\n')[0].trim().slice(0, 60);
+    const achados = [];
+    for (const p of arquivos(dir)) {
+        let s; try { const st = fs.statSync(p); if (st.size > 400 * 1024) continue; s = fs.readFileSync(p, 'utf8'); } catch { continue; }
+        let pontos = 0;
+        if (cap.id && (s.includes(`id="${cap.id}"`) || s.includes(`id='${cap.id}'`) || s.includes(`#${cap.id}`))) pontos += 4;
+        for (const c of classes) if (s.includes(c)) pontos += 1;
+        if (texto.length > 3 && s.includes(texto)) pontos += 3;
+        if (pontos) achados.push({ arquivo: path.relative(dir, p), pontos });
+    }
+    return achados.sort((a, b) => b.pontos - a.pontos).slice(0, max);
+}
+
+function montarPedido(cap, mudanca, palpites = []) {
+    return [`Edição visual: na página ${cap.url || '/'}, o usuário clicou num elemento e quer: ${mudanca}`, '',
+        `Seletor: ${cap.seletor}`, `Texto: ${cap.texto || '(sem texto)'}`, 'HTML do elemento:', '```html', cap.html || '', '```',
+        palpites.length ? `Palpite de arquivo (grep, confira): ${palpites.map((p) => p.arquivo).join(', ')}` : 'Não achei o arquivo-fonte por grep: procure pelo texto/classes.',
+        'Faça só essa mudança e não mexa no resto da página.'].join('\n');
+}
+
+/** Handler pro servidor do preview: true se tratou a requisição. `aoEditar(pedido, cap)` é quem manda pro agente. */
+function tratar(dir, aoEditar) {
+    return (req, res) => {
+        if (req.method !== 'POST' || !(req.url || '').startsWith(ROTA)) return false;
+        let corpo = ''; req.on('data', (b) => { corpo += b; if (corpo.length > 200000) req.destroy(); });
+        req.on('end', async () => {
+            let cap; try { cap = JSON.parse(corpo); } catch { res.writeHead(400); return res.end('{"ok":false}'); }
+            if (!cap || !cap.seletor || !cap.mudanca) { res.writeHead(400); return res.end('{"ok":false}'); }
+            const pedido = montarPedido(cap, String(cap.mudanca).slice(0, 500), palpiteArquivo(dir, cap));
+            try { await aoEditar(pedido, cap); res.writeHead(200, { 'content-type': 'application/json' }); res.end('{"ok":true}'); }
+            catch { res.writeHead(500); res.end('{"ok":false}'); }
+        });
+        return true;
+    };
+}
+
+/** Repassa um dev server (alvo = 'http://localhost:5173') injetando o overlay no HTML. */
+function proxiar(alvo, porta, { dir, aoEditar }) {
+    const u = new URL(alvo);
+    const meu = tratar(dir, aoEditar);
+    const srv = http.createServer((req, res) => {
+        if (meu(req, res)) return;
+        const headers = { ...req.headers, host: u.host, 'accept-encoding': 'identity' };
+        const pr = http.request({ host: u.hostname, port: u.port, path: req.url, method: req.method, headers }, (r) => {
+            const html = /text\/html/.test(r.headers['content-type'] || '');
+            if (!html) { res.writeHead(r.statusCode, r.headers); return r.pipe(res); }
+            let b = ''; r.setEncoding('utf8'); r.on('data', (x) => { b += x; });
+            r.on('end', () => { const h = { ...r.headers }; const corpo = injetar(b); delete h['content-length']; res.writeHead(r.statusCode, h); res.end(corpo); });
+        });
+        pr.on('error', () => { res.writeHead(502); res.end('o app não respondeu'); });
+        req.pipe(pr);
+    });
+    return new Promise((ok) => srv.listen(porta, '127.0.0.1', () => ok(srv)));
+}
+
+module.exports = { OVERLAY, ROTA, injetar, palpiteArquivo, montarPedido, tratar, proxiar };

package/lib/plugin/pesquisar.js

@@ -0,0 +1,92 @@
+/**
+ * pesquisar.js — `/pesquisar <tema>`: pesquisa profunda com fontes.
+ *   1. o modelo quebra o tema em 3-5 sub-perguntas (JSON)
+ *   2. cada uma passa por `buscar` (a ferramenta buscar_web, lib/tool/web.js;
+ *      aqui só a interface `buscar(consulta) -> [{titulo, url, trecho}]`. Sem ela, o relatório diz que não buscou)
+ *   3. as melhores URLs são lidas (lib/web-pagina.js)
+ *   4. o modelo escreve o relatório em markdown citando [1], [2]… e só as fontes lidas entram na lista
+ *   5. grava em pesquisas/<tema>.md
+ * Nada é inventado: sem fonte lida, a seção diz "sem fonte" em vez de afirmar.
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { acharJson, perguntarPadrao, slug } = require('../cli/util.js');
+
+const MAX_PERGUNTAS = 5, URLS_POR_PERGUNTA = 2;
+
+async function buscarPadrao() {
+    const { buscarWeb } = require('../tool/web.js');   // a ferramenta buscar_web de verdade
+    return async (consulta) => {
+        const r = await buscarWeb({ consulta, limite: URLS_POR_PERGUNTA + 2 });
+        if (!r.ok) throw new Error(r.error || 'buscar_web não achou nada');
+        return r.resultados;
+    };
+}
+
+/** O plano: sub-perguntas. Se o modelo não devolver JSON, usa o próprio tema. */
+async function planejar(tema, perguntar) {
+    const bruto = await perguntar(null, 'Quebre o tema em 3 a 5 sub-perguntas de pesquisa, curtas e distintas. Devolva SÓ um JSON: {"perguntas":["..."]}.', `Tema: ${tema}`);
+    const j = acharJson(bruto);
+    const l = (j && (Array.isArray(j) ? j : j.perguntas)) || [];
+    const ps = l.filter((x) => typeof x === 'string' && x.trim()).map((x) => x.trim()).slice(0, MAX_PERGUNTAS);
+    return ps.length ? ps : [tema];
+}
+
+async function pesquisar({ tema, dir = process.cwd(), perguntar, buscar, ler, log = () => {}, agora = () => new Date() }) {
+    tema = String(tema || '').trim();
+    if (!tema) return { ok: false, erro: 'Faltou o tema. Exemplo: /pesquisar como funciona cache no edge' };
+    perguntar = perguntar || perguntarPadrao;
+    ler = ler || (async (url) => { const r = await require('../web-pagina.js').baixar(url); return r.ok ? { titulo: r.titulo, texto: r.texto } : null; });
+    const avisos = [];
+    try { buscar = buscar || await buscarPadrao(); } catch (e) { buscar = null; avisos.push(e.message); }
+
+    const perguntas = await planejar(tema, perguntar);
+    log(`${perguntas.length} sub-pergunta(s)`);
+    const fontes = [], porPergunta = [];
+    for (const p of perguntas) {
+        const achadas = [];
+        if (buscar) {
+            let rs = [];
+            try { rs = (await buscar(p)) || []; } catch (e) { avisos.push(`busca "${p}": ${e.message}`); }
+            for (const r of rs.slice(0, URLS_POR_PERGUNTA)) {
+                if (!r || !r.url) continue;
+                let f = fontes.find((x) => x.url === r.url);
+                if (!f) {
+                    let lido = null;
+                    try { lido = await ler(r.url); } catch { /* segue sem */ }
+                    if (!lido || !lido.texto) { avisos.push(`não consegui ler ${r.url}`); continue; }
+                    f = { n: fontes.length + 1, url: r.url, titulo: r.titulo || lido.titulo || r.url, texto: String(lido.texto).slice(0, 6000) };
+                    fontes.push(f);
+                }
+                achadas.push(f);
+            }
+        }
+        porPergunta.push({ pergunta: p, fontes: achadas });
+        log(`"${p}" → ${achadas.length} fonte(s) lida(s)`);
+    }
+
+    let corpo;
+    if (!fontes.length) {
+        corpo = perguntas.map((p) => `## ${p}\n\nSem fonte: não consegui buscar nem ler nada pra esta pergunta.\n`).join('\n');
+    } else {
+        const material = porPergunta.map((x) => `### ${x.pergunta}\n` + (x.fontes.length ? x.fontes.map((f) => `[${f.n}] ${f.titulo} (${f.url})\n${f.texto}`).join('\n\n') : '(sem fonte)')).join('\n\n');
+        corpo = await perguntar(null, 'Escreva um relatório em markdown (PT-BR), uma seção "## pergunta" por sub-pergunta. Use SÓ o material dado; cite cada afirmação com [n]. Pergunta sem fonte: escreva "Sem fonte." Não invente.', `Tema: ${tema}\n\n${material}`);
+    }
+    const md = [`# ${tema}`, '', `_Pesquisa de ${agora().toISOString().slice(0, 10)} · ${fontes.length} fonte(s) lida(s)_`, '',
+        ...(avisos.length ? ['> Avisos: ' + [...new Set(avisos)].join(' · '), ''] : []), String(corpo).trim(), '',
+        '## Fontes', '', ...(fontes.length ? fontes.map((f) => `${f.n}. [${f.titulo}](${f.url})`) : ['_nenhuma_']), ''].join('\n');
+    const arquivo = path.join(dir, 'pesquisas', slug(tema) + '.md');
+    fs.mkdirSync(path.dirname(arquivo), { recursive: true });
+    fs.writeFileSync(arquivo, md);
+    return { ok: true, arquivo, fontes: fontes.length, avisos, perguntas };
+}
+
+async function main(args) {
+    const r = await pesquisar({ tema: args.filter((a) => !a.startsWith('-')).join(' '), log: (l) => console.log('  ' + l) });
+    console.log(r.ok ? `  Relatório: ${r.arquivo}${r.avisos.length ? '\n  Avisos: ' + r.avisos.join(' · ') : ''}` : '  ' + r.erro);
+    return r.ok ? 0 : 1;
+}
+
+module.exports = { pesquisar, planejar, main };

package/lib/plugin/preview-cli.js

@@ -0,0 +1,38 @@
+/**
+ * preview-cli.js — `primocode preview [pasta] [--visual] [--tunel]`
+ * Sobe o app, imprime a URL local. --visual liga a edição por clique; --tunel pede link público (só com cloudflared).
+ */
+'use strict';
+
+const path = require('path');
+const P = require('./preview.js');
+
+async function main(args, deps = {}) {
+    const dir = path.resolve(args.find((a) => !a.startsWith('-')) || process.cwd());
+    const visual = args.includes('--visual'), tunel = args.includes('--tunel');
+    const { sh } = require('../cli/util.js');
+    const bin = path.join(__dirname, '..', '..', 'bin', 'primocode.js');
+    const V = visual ? require('./edicao-visual.js') : null;
+    const aoEditar = deps.aoEditar || (async (pedido) => { console.log('  ✎ edição recebida, mandando pro agente…'); sh(process.execPath, [bin, '-p', pedido], { cwd: dir }); console.log('  pronto, recarregue a página.'); });
+    const app = await (deps.subir || P.subir)(dir, visual ? { estatico: { transformar: V.injetar, extra: V.tratar(dir, aoEditar) } } : {});
+    if (!app.ok) { console.log('  ' + app.erro); return 1; }
+    let url = app.url, parar = app.parar;
+    if (visual && app.tipo === 'script') {
+        const porta = await P.portaLivre();
+        const px = await V.proxiar(app.url, porta, { dir, aoEditar });
+        url = `http://localhost:${porta}`; const antes = parar; parar = () => { px.close(); antes(); };
+    }
+    console.log(`  Preview: ${url}${visual ? '  (botão "Editar" no canto da página)' : ''}`);
+    let t = null;
+    if (tunel) {
+        t = await require('./tunel.js').abrir(url, deps.tunel || {});
+        console.log(t.ok ? `  Link público: ${t.url}  (quem tem o link vê o app enquanto isto estiver rodando)` : `  Sem link público: ${t.motivo}`);
+    }
+    if (deps.sair) { parar(); if (t && t.ok) t.parar(); return 0; }
+    console.log('  Ctrl+C encerra.');
+    await new Promise((r) => process.on('SIGINT', r));
+    parar(); if (t && t.ok) t.parar();
+    return 0;
+}
+
+module.exports = { main };