primocode 10.17.1 → 11.0.0

package/lib/plugin/preview.js

@@ -0,0 +1,89 @@
+/**
+ * preview.js — sobe o app web da pasta e devolve uma URL local.
+ *   - package.json com script "dev" (ou "start"): roda o script com PORT livre e espera responder
+ *   - senão, index.html: um servidor estático pequeno (node, sem dependência)
+ * Usado pelo autoteste (lib/plugin/autoteste.js), pelo `primocode preview` e pela edição visual.
+ * Não instala nada: sem node_modules num projeto que precisa, avisa em vez de rodar `npm install` sozinho.
+ */
+'use strict';
+
+const fs = require('fs');
+const http = require('http');
+const net = require('net');
+const path = require('path');
+const { spawn } = require('child_process');
+
+const TIPOS = { '.html': 'text/html; charset=utf-8', '.js': 'text/javascript', '.mjs': 'text/javascript', '.css': 'text/css', '.json': 'application/json', '.svg': 'image/svg+xml', '.png': 'image/png', '.jpg': 'image/jpeg', '.ico': 'image/x-icon', '.txt': 'text/plain' };
+
+function portaLivre() {
+    return new Promise((res, rej) => { const s = net.createServer(); s.listen(0, '127.0.0.1', () => { const p = s.address().port; s.close(() => res(p)); }); s.on('error', rej); });
+}
+
+/** Como subir esta pasta: { tipo: 'script'|'estatico', script? } ou { tipo: null, motivo }. */
+function detectar(dir) {
+    try {
+        const p = JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf8'));
+        const s = p.scripts || {};
+        const nome = s.dev ? 'dev' : s.start ? 'start' : null;
+        if (nome) {
+            if (!fs.existsSync(path.join(dir, 'node_modules')) && (p.dependencies || p.devDependencies)) return { tipo: null, motivo: 'faltam as dependências: rode `npm install` (não instalo sozinho)' };
+            return { tipo: 'script', script: nome };
+        }
+    } catch { /* sem package.json */ }
+    if (fs.existsSync(path.join(dir, 'index.html'))) return { tipo: 'estatico' };
+    return { tipo: null, motivo: 'não achei script dev/start nem index.html' };
+}
+
+/** Servidor estático. `transformar(html, req)` deixa injetar algo nas páginas; `extra(req,res)` devolve true se tratou. */
+function servirEstatico(dir, porta, { transformar, extra } = {}) {
+    const raiz = path.resolve(dir);
+    const srv = http.createServer((req, res) => {
+        if (extra && extra(req, res)) return;
+        let rel = decodeURIComponent((req.url || '/').split('?')[0]);
+        if (rel.endsWith('/')) rel += 'index.html';
+        const p = path.resolve(raiz, '.' + rel);
+        if (p !== raiz && !p.startsWith(raiz + path.sep)) { res.writeHead(403); return res.end('fora da pasta'); }
+        fs.readFile(p, (err, buf) => {
+            if (err) { res.writeHead(404); return res.end('não achei'); }
+            const tipo = TIPOS[path.extname(p).toLowerCase()] || 'application/octet-stream';
+            if (tipo.startsWith('text/html') && transformar) buf = Buffer.from(transformar(buf.toString('utf8'), req));
+            res.writeHead(200, { 'content-type': tipo }); res.end(buf);
+        });
+    });
+    return new Promise((res) => srv.listen(porta, '127.0.0.1', () => res(srv)));
+}
+
+function responde(url, ms = 800) {
+    return new Promise((res) => { const r = http.get(url, (x) => { x.resume(); res(true); }); r.on('error', () => res(false)); r.setTimeout(ms, () => { r.destroy(); res(false); }); });
+}
+
+/**
+ * Sobe e espera responder. Devolve { ok, url, parar(), log() } ou { ok: false, erro }.
+ * `opcoes.estatico` = { transformar, extra } passa pro servidor estático.
+ */
+async function subir(dir, { espera = 30000, estatico } = {}) {
+    const d = detectar(dir);
+    if (!d.tipo) return { ok: false, erro: d.motivo };
+    if (d.tipo === 'estatico') {
+        const porta = await portaLivre();
+        const srv = await servirEstatico(dir, porta, estatico);
+        return { ok: true, url: `http://localhost:${porta}`, tipo: 'estatico', parar: () => srv.close(), log: () => '' };
+    }
+    const porta = await portaLivre();
+    let saida = '';
+    const filho = spawn('npm', ['run', d.script], { cwd: dir, env: { ...process.env, PORT: String(porta), BROWSER: 'none', FORCE_COLOR: '0' }, stdio: ['ignore', 'pipe', 'pipe'], detached: true });
+    filho.stdout.on('data', (b) => { saida += b; }); filho.stderr.on('data', (b) => { saida += b; });
+    let morreu = false; filho.on('exit', () => { morreu = true; });
+    const parar = () => { try { process.kill(-filho.pid); } catch { try { filho.kill(); } catch { /* */ } } };
+    const fim = Date.now() + espera;
+    while (Date.now() < fim && !morreu) {
+        const m = saida.match(/https?:\/\/(?:localhost|127\.0\.0\.1|\[::1\]|0\.0\.0\.0):(\d+)/);
+        const url = `http://localhost:${m ? m[1] : porta}`;
+        if (await responde(url)) return { ok: true, url, tipo: 'script', parar, log: () => saida };
+        await new Promise((r) => setTimeout(r, 300));
+    }
+    parar();
+    return { ok: false, erro: morreu ? 'o servidor do app fechou sozinho' : `o app não respondeu em ${Math.round(espera / 1000)}s`, log: saida.slice(-600) };
+}
+
+module.exports = { detectar, subir, servirEstatico, portaLivre, responde };

package/lib/plugin/tunel.js

@@ -0,0 +1,27 @@
+/**
+ * tunel.js — link público opcional pro preview. SÓ se o `cloudflared` já estiver instalado e a pessoa pediu (--tunel).
+ * Nunca instala nada: sem ele, diz como instalar e segue só com o link local.
+ */
+'use strict';
+
+const { spawn } = require('child_process');
+const { temComando } = require('../cli/util.js');
+
+const RE_URL = /https:\/\/[a-z0-9-]+\.trycloudflare\.com/;
+
+/** Devolve { ok, url, parar() } ou { ok: false, motivo }. `temFerramenta` e `iniciar` são injetáveis. */
+async function abrir(urlLocal, { temFerramenta = () => temComando('cloudflared'), iniciar = (u) => spawn('cloudflared', ['tunnel', '--url', u], { stdio: ['ignore', 'pipe', 'pipe'] }), espera = 20000 } = {}) {
+    if (!temFerramenta()) return { ok: false, motivo: 'o cloudflared não está instalado, então fico só com o link local (não instalo sozinho; no Mac: brew install cloudflared)' };
+    const filho = iniciar(urlLocal);
+    return new Promise((res) => {
+        let buf = '';
+        const parar = () => { try { filho.kill(); } catch { /* */ } };
+        const t = setTimeout(() => { parar(); res({ ok: false, motivo: 'o túnel não devolveu um link em ' + Math.round(espera / 1000) + 's' }); }, espera);
+        const le = (b) => { buf += b; const m = buf.match(RE_URL); if (m) { clearTimeout(t); res({ ok: true, url: m[0], parar }); } };
+        filho.stdout && filho.stdout.on('data', le); filho.stderr && filho.stderr.on('data', le);
+        filho.on('error', (e) => { clearTimeout(t); res({ ok: false, motivo: e.message }); });
+        filho.on('exit', () => { clearTimeout(t); res({ ok: false, motivo: 'o cloudflared fechou antes de dar o link' }); });
+    });
+}
+
+module.exports = { abrir, RE_URL };

package/lib/porta.js

@@ -0,0 +1,147 @@
+/**
+ * porta.js — o /porta: "o app não abre" por causa da porta, dito em português.
+ *
+ *   declaradas(projectDir)          → [{ porta, de }]           (o que o projeto diz que usa; só lê, sem modelo)
+ *   olhar(portas, { tempo })        → Promise<[{ porta, titulo }]>  (as que respondem em localhost, e o <title>)
+ *   diagnostico(projectDir)         → Promise<{ declaradas, abertas, linhas, url }>
+ *   frase({ declaradas, abertas, rodar }) → { linhas, url }       (puro)
+ *
+ * Fórum do Replit, abril de 2026: o preview não carrega porque o servidor está numa porta e a configuração aponta outra
+ * (replit.discourse.group/t/8734 e /9515). O iniciante não sabe o que é porta: ele só vê "não abre". Aqui a gente lê o
+ * que o projeto declara (package.json, vite.config, PORT= do .env — só essa linha, nada mais sai do .env), bate em
+ * 127.0.0.1 e ::1 com um connect curto e diz qual endereço abrir. O <title> da página que responde mostra se é o SEU app
+ * ou outro programa que pegou a porta.
+ *
+ * O /open (lib/comandos-extra.js, acharAlvoAbrir) só abre a primeira porta viva e, sem nenhuma, diz "não achei". O /porta
+ * é o porquê: ele usa as mesmas portas do /open e mais as escritas no vite.config, no .env e no server.js.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const net = require('net');
+const http = require('http');
+const path = require('path');
+
+// a porta que cada ferramenta usa quando ninguém diz nada
+const PADRAO = [[/\bvite\b/, 5173, 'o Vite'], [/\bnext\b/, 3000, 'o Next'], [/react-scripts/, 3000, 'o React'], [/\bastro\b/, 4321, 'o Astro'],
+    [/\bng\s+serve\b/, 4200, 'o Angular'], [/\bflask\b/, 5000, 'o Flask'], [/http\.server/, 8000, 'o servidor do Python'], [/\bserve\b/, 3000, 'o serve']];
+const COMUNS = [3000, 5173, 8080, 8000, 5000, 4321, 4200, 3001, 5174];
+const ler = (f) => { try { return fs.readFileSync(f, 'utf8'); } catch { return ''; } };
+
+function declaradas(projectDir) {
+    const out = [];
+    const poe = (porta, de) => { const n = Number(porta); if (n > 0 && n < 65536 && !out.some((d) => d.porta === n)) out.push({ porta: n, de }); };
+    let pkg = null;
+    try { pkg = JSON.parse(ler(path.join(projectDir, 'package.json'))); } catch { /* sem package.json */ }
+    const scripts = (pkg && pkg.scripts) || {};
+    for (const nome of ['dev', 'start', 'serve', 'preview']) {
+        const s = scripts[nome];
+        if (!s) continue;
+        const m = s.match(/(?:--port[= ]|-p\s+|PORT=)(\d{2,5})/);
+        if (m) poe(m[1], `o "npm run ${nome}"`);
+    }
+    for (const f of ['vite.config.js', 'vite.config.ts', 'vite.config.mjs']) {
+        const m = ler(path.join(projectDir, f)).match(/\bport\s*:\s*(\d{2,5})/);
+        if (m) poe(m[1], f);
+    }
+    const env = ler(path.join(projectDir, '.env')).match(/^\s*PORT\s*=\s*["']?(\d{2,5})/m);   // só a linha da porta
+    if (env) poe(env[1], 'o PORT do .env');
+    for (const f of ['server.js', 'app.js', 'index.js', 'main.py', 'app.py']) {
+        const m = ler(path.join(projectDir, f)).match(/\b(?:listen\(\s*|port\s*=\s*|PORT\s*\|\|\s*)(\d{2,5})/);
+        if (m) poe(m[1], f);
+    }
+    for (const nome of ['dev', 'start']) {
+        const s = scripts[nome];
+        if (!s) continue;
+        const p = PADRAO.find(([re]) => re.test(s));
+        if (p) poe(p[1], p[2]);   // sem porta escrita: a de sempre da ferramenta
+    }
+    // e as que o /open já procura (lib/comandos-extra.js): o /porta nunca olha menos que ele
+    for (const n of require('./comandos-extra.js').portasDoProjeto(projectDir)) poe(n, 'o padrão das ferramentas do projeto');
+    return out;
+}
+
+function responde(porta, host, tempo) {
+    return new Promise((resolve) => {
+        const s = net.connect({ port: porta, host });
+        const fim = (ok) => { s.destroy(); resolve(ok); };
+        s.setTimeout(tempo, () => fim(false));
+        s.once('connect', () => fim(true));
+        s.once('error', () => fim(false));
+    });
+}
+
+// quem responde e não é app de ninguém: o cabeçalho Server entrega
+const PROGRAMAS = [[/AirTunes/i, 'o AirPlay do Mac']];
+
+function pagina(porta, tempo) {
+    return new Promise((resolve) => {
+        const req = http.get({ host: 'localhost', port: porta, path: '/', timeout: tempo }, (res) => {
+            const prog = PROGRAMAS.find(([re]) => re.test(String(res.headers.server || '')));
+            let corpo = '';
+            res.setEncoding('utf8');
+            res.on('data', (d) => { corpo += d; if (corpo.length > 64 * 1024) res.destroy(); });
+            res.on('close', () => resolve({ titulo: ((corpo.match(/<title[^>]*>([^<]{1,80})<\/title>/i) || [])[1] || '').trim() || null, programa: prog ? prog[1] : null }));
+        });
+        req.on('timeout', () => { req.destroy(); resolve({ titulo: null, programa: null }); });
+        req.on('error', () => resolve({ titulo: null, programa: null }));
+    });
+}
+
+async function olhar(portas, { tempo = 300 } = {}) {
+    const lista = [...new Set(portas)];
+    // o Node 18+ e o Vite às vezes escutam só no ::1 (o "localhost" do IPv6): olha os dois
+    const vivas = await Promise.all(lista.map(async (p) => (await responde(p, '127.0.0.1', tempo)) || (await responde(p, '::1', tempo)) ? p : null));
+    return Promise.all(vivas.filter(Boolean).map(async (p) => ({ porta: p, ...(await pagina(p, tempo * 3)) })));
+}
+
+function frase({ declaradas: dec, abertas, rodar }) {
+    const url = (p) => `http://localhost:${p}`;
+    const nome = (a) => (a.titulo ? ` ("${a.titulo}")` : '');
+    const maiuscula = (s) => s[0].toUpperCase() + s.slice(1);
+    const linhas = [];
+    const esperada = dec[0];
+    const doMac = abertas.filter((a) => a.programa);
+    const apps = abertas.filter((a) => !a.programa);
+    const ocupada = esperada && doMac.find((a) => a.porta === esperada.porta);
+    if (ocupada) {
+        // o caso do Flask no Mac: a 5000 é do AirPlay desde o Monterey, e o app "não abre" com um 403 vazio
+        linhas.push(`A ${ocupada.porta}, que ${esperada.de} diz, é ${ocupada.programa}, não o seu app.`,
+            `Rode o app em outra porta (por exemplo a ${ocupada.porta + 1}), ou desligue em Ajustes do Sistema › Geral › AirDrop e Handoff › Receptor AirPlay.`);
+        return { linhas, url: null };
+    }
+    const viva = esperada && apps.find((a) => a.porta === esperada.porta);
+    if (viva) {
+        linhas.push(`Está rodando na ${viva.porta}${nome(viva)}, a porta que ${esperada.de} diz.`, `Abra: ${url(viva.porta)}`);
+        return { linhas, url: url(viva.porta) };
+    }
+    if (esperada && apps.length) {
+        const outra = apps[0];
+        linhas.push(`${maiuscula(esperada.de)} diz que o app usa a ${esperada.porta}, mas a ${esperada.porta} está vazia.`,
+            `A ${outra.porta} está respondendo${nome(outra)}. Se for o seu app, abra: ${url(outra.porta)}`,
+            'Se não for, outro programa está nessa porta: feche ele, ou rode o seu app de novo.');
+        return { linhas, url: url(outra.porta) };
+    }
+    if (apps.length) {
+        linhas.push('O projeto não diz qual porta usa. Estas estão respondendo agora:');
+        for (const a of apps.slice(0, 4)) linhas.push(`  ${url(a.porta)}${nome(a)}`);
+        return { linhas, url: url(apps[0].porta) };
+    }
+    linhas.push(esperada ? `Nada está rodando na ${esperada.porta} (a porta que ${esperada.de} diz), nem nas portas comuns.` : 'Nada está rodando nas portas comuns.');
+    if (doMac.length) linhas.push(`(A ${doMac.map((a) => a.porta).join(' e a ')} responde, mas é ${doMac[0].programa}: não é app seu.)`);
+    linhas.push(rodar ? `Abra o app primeiro: ${rodar}, e deixe aquela janela aberta. Depois, /port de novo.` : 'Este projeto pode não ter servidor: se é uma página, /open index.html abre direto.');
+    return { linhas, url: null };
+}
+
+async function diagnostico(projectDir, { tempo } = {}) {
+    const dec = declaradas(projectDir);
+    const abertas = await olhar([...dec.map((d) => d.porta), ...COMUNS], { tempo });
+    const passo = require('./como-rodar.js').passos(projectDir).find((p) => p.comando && /run dev|start|python3/.test(p.comando));
+    return { declaradas: dec, abertas, ...frase({ declaradas: dec, abertas, rodar: passo && passo.comando }) };
+}
+
+// o pedido que talvez seja de porta: só SUGERE ao modelo rodar `primocode porta` (lib/act.js); quem decide é ele
+const PEDE_PORTA = /n[ãa]o (abre|carrega|aparece|funciona)|tela (branca|em branco)|localhost|\bporta\b|servidor/i;
+
+module.exports = { declaradas, olhar, frase, diagnostico, COMUNS, PEDE_PORTA };

package/lib/publicar.js

@@ -0,0 +1,112 @@
+/**
+ * publicar.js — o /ship de verdade: coloca o projeto no ar e entrega o link.
+ *
+ *   detectar(dir)                 → { tipo: 'estatico'|'next'|'node'|'outro', pasta, quem }
+ *   publicar(dir, deps)           → { ok, url } | { ok:false, erro } | { recusou:true } | { guiado:true }
+ *   arquivosDoEnvio(dir)          → { total, bytes }   (o que subiria; sem .env, sem node_modules)
+ *
+ * Vale para site estático, Next e app Node simples. Escolhe UM host grátis: a Vercel, pelo `vercel` (ou `npx vercel`
+ * quando o npx existe). Antes de subir qualquer coisa pergunta (`confirmar`) e protege chave: `.env` entra no
+ * .vercelignore. O que só a pessoa faz (entrar na conta) vira UMA linha. Projeto de outro tipo (Python, etc.) devolve
+ * `guiado` e o bin cai no texto antigo (comandos/ship.md), que guia passo a passo.
+ * Os testes trocam `run` e `confirmar`: nada de rede.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const protecao = require('./protecao.js');
+
+const SERVIDORES = /^(express|fastify|koa|hono|@hono\/node-server|restify|hapi|@hapi\/hapi)$/;
+const PULAR = new Set(['node_modules', '.git', '.vercel', '.next', '.primocode']);
+
+function lerPkg(dir) { try { return JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf8')); } catch { return null; } }
+
+function detectar(dir) {
+    const pkg = lerPkg(dir);
+    const deps = pkg ? { ...pkg.dependencies, ...pkg.devDependencies } : {};
+    if (deps.next) return { tipo: 'next', pasta: '.', quem: 'um site feito com Next' };
+    if (Object.keys(deps).some((d) => SERVIDORES.test(d)) && pkg.scripts && pkg.scripts.start) return { tipo: 'node', pasta: '.', quem: 'um app Node com servidor' };
+    if (pkg && pkg.scripts && pkg.scripts.build && (deps.vite || deps['react-scripts'] || deps.astro)) {
+        return { tipo: 'estatico', pasta: '.', quem: 'um site que se monta com `npm run build`' };
+    }
+    if (fs.existsSync(path.join(dir, 'index.html'))) return { tipo: 'estatico', pasta: '.', quem: 'um site estático (HTML, CSS e JS)' };
+    return { tipo: 'outro', pasta: '.', quem: 'um projeto que não consigo publicar sozinho' };
+}
+
+/** Quantos arquivos e bytes subiriam (sem o que a lib/protecao.js chama de segredo). */
+function arquivosDoEnvio(dir) {
+    let total = 0, bytes = 0;
+    const andar = (d) => {
+        let itens = [];
+        try { itens = fs.readdirSync(d, { withFileTypes: true }); } catch { return; }
+        for (const it of itens) {
+            if (it.isDirectory()) { if (!PULAR.has(it.name)) andar(path.join(d, it.name)); continue; }
+            if (protecao.nomeDeSegredo(it.name)) continue;
+            total++;
+            try { bytes += fs.statSync(path.join(d, it.name)).size; } catch { /* sumiu no meio */ }
+        }
+    };
+    andar(dir);
+    return { total, bytes };
+}
+
+const tamanho = (b) => (b >= 1048576 ? `${(b / 1048576).toFixed(1)} MB` : `${Math.max(1, Math.round(b / 1024))} KB`);
+
+/** .env e companhia fora do envio. Devolve true se mexeu. */
+function protegerEnvio(dir) {
+    const temSegredo = fs.readdirSync(dir).some((n) => protecao.nomeDeSegredo(n));
+    if (!temSegredo) return false;
+    const f = path.join(dir, '.vercelignore');
+    const atual = fs.existsSync(f) ? fs.readFileSync(f, 'utf8') : '';
+    if (/^\.env/m.test(atual)) return false;
+    fs.writeFileSync(f, atual + (atual && !atual.endsWith('\n') ? '\n' : '') + '.env\n.env.*\n*.pem\n*.key\n');
+    return true;
+}
+
+function rodar(cmd, args, { cwd } = {}) {
+    const r = spawnSync(cmd, args, { cwd, encoding: 'utf8', timeout: 10 * 60 * 1000, stdio: ['ignore', 'pipe', 'pipe'] });
+    return { status: r.error ? 127 : r.status, stdout: r.stdout || '', stderr: (r.stderr || '') + (r.error ? String(r.error.message) : '') };
+}
+
+/** Qual comando da Vercel existe aqui: `vercel`, ou `npx --yes vercel`. null = nenhum. */
+function ferramenta(run, dir) {
+    if (run('vercel', ['--version'], { cwd: dir }).status === 0) return ['vercel'];
+    if (run('npx', ['--version'], { cwd: dir }).status === 0) return ['npx', '--yes', 'vercel'];
+    return null;
+}
+
+async function publicar(dir, { run = rodar, confirmar = async () => false, log = () => {} } = {}) {
+    const d = detectar(dir);
+    if (d.tipo === 'outro') return { guiado: true };
+    log(`Isto parece ${d.quem}. Recomendo a Vercel: é grátis e dá um link público.`);
+    if (d.tipo === 'node') log('App com servidor roda na Vercel como função. Se o link abrir com erro, me diga que eu ajusto.');
+
+    const ferr = ferramenta(run, dir);
+    if (!ferr) return { ok: false, erro: 'Falta o Node com npm neste computador (https://nodejs.org). Depois rode /ship de novo.' };
+    const vercel = (...a) => run(ferr[0], [...ferr.slice(1), ...a], { cwd: dir });
+    if (vercel('whoami').status !== 0) {
+        return { ok: false, erro: `Falta entrar na Vercel: rode \`${ferr.join(' ')} login\` no terminal (a conta é grátis, com e-mail ou GitHub) e depois /ship de novo.` };
+    }
+
+    const { total, bytes } = arquivosDoEnvio(dir);
+    if (!total) return { ok: false, erro: 'A pasta está vazia: não tem nada para publicar.' };
+    if (protegerEnvio(dir)) log('Achei um arquivo de chave (.env) e pus no .vercelignore: ele não sobe.');
+    if (!(await confirmar(`Vou enviar ${total} ${total === 1 ? 'arquivo' : 'arquivos'} (${tamanho(bytes)}) para a Vercel. O endereço fica público, qualquer pessoa com o link abre. Posso enviar?`))) {
+        return { recusou: true };
+    }
+
+    log('Enviando… isso leva de 30 segundos a alguns minutos.');
+    const r = vercel('deploy', '--prod', '--yes');
+    // a Vercel escreve o endereço de produção na saída; o texto de progresso (Inspect, Production…) vai pro erro
+    const url = ((r.stdout || '').match(/https:\/\/[^\s]+/) || (r.stderr || '').match(/Production: (https:\/\/[^\s]+)/) || []).slice(-1)[0];
+    if (r.status !== 0 || !url) {
+        const motivo = (r.stderr || r.stdout || '').trim().split('\n').filter(Boolean).pop() || 'sem explicação';
+        return { ok: false, erro: `A Vercel não terminou o envio: ${motivo.slice(0, 160)}` };
+    }
+    return { ok: true, url };
+}
+
+module.exports = { detectar, publicar, arquivosDoEnvio, protegerEnvio, ferramenta, tamanho };

package/lib/registro.js

@@ -36,7 +36,7 @@ const { c, truncate, padRight } = require('./ui.js');
 
 /* Comando que é teste. Deliberadamente restrito: `npm run build` não é
    teste, e chamar de teste o que não é seria pior que não contar nada. */
-const EH_TESTE = /(^|\s|&&|\|\|)(npm\s+(run\s+)?tests?\b|npm\s+t\b|yarn\s+tests?\b|pnpm\s+tests?\b|pytest\b|python\s+-m\s+pytest\b|jest\b|vitest\b|mocha\b|go\s+test\b|cargo\s+test\b|mvn\s+test\b|rspec\b|phpunit\b)/i;
+const EH_TESTE = /(^|\s|&&|\|\|)(npm\s+(run\s+)?tests?\b|npm\s+t\b|yarn\s+tests?\b|pnpm\s+(run\s+)?tests?\b|bun\s+(run\s+)?test\b|node\s+--test\b|pytest\b|python\s+-m\s+pytest\b|jest\b|vitest\b|mocha\b|go\s+test\b|cargo\s+test\b|mvn\s+test\b|rspec\b|phpunit\b)/i;
 
 /* As contagens que os corredores de teste escrevem. Nenhuma é obrigatória:
    quando nada casa, vale o código de saída, que é o que não mente. */
@@ -72,8 +72,8 @@ function resumoDeTeste(saida) {
     const falhou = (texto.match(CONTAGENS[1]) || [])[1];
     if (!passou && !falhou) return '';
     const partes = [];
-    if (passou) partes.push(`${passou} passaram`);
-    if (falhou && Number(falhou) > 0) partes.push(`${falhou} falharam`);
+    if (passou) partes.push(`${passou} ${Number(passou) === 1 ? 'passou' : 'passaram'}`);
+    if (falhou && Number(falhou) > 0) partes.push(`${falhou} ${Number(falhou) === 1 ? 'falhou' : 'falharam'}`);
     return partes.join(', ');
 }
 
@@ -99,6 +99,10 @@ function anotar(reg, nome, args, r) {
         const alvo = String(a.path || a.command || a.target || a.url || a.consulta || '')
             .replace(/\s+/g, ' ').trim();
         if (reg.falhas.length < 20) reg.falhas.push({ acao: nome, alvo, motivo });
+        // teste vermelho também é TESTE: sem isto o registro dizia "nenhum teste" numa tarefa com npm test falhando
+        if (nome === 'run_shell' && EH_TESTE.test(String(a.command || '')) && reg.testes.length < 20) {
+            reg.testes.push({ comando: String(a.command).replace(/\s+/g, ' ').trim(), ok: false, code: r.code ?? 1, resumo: resumoDeTeste(r.stdout || r.saida || r.output || '') });
+        }
         // Uma tool que falhou não criou nem alterou nada. Continuar daqui
         // faria um write_file recusado aparecer na lista de criados.
         return reg;
@@ -128,6 +132,7 @@ function anotar(reg, nome, args, r) {
             return reg;
         }
 
+        case 'run_background':
         case 'run_in_new_terminal':
             if (reg.comandos.length < 40) {
                 reg.comandos.push({ comando: String(a.command || '').trim(), ok: true, code: 0, solto: true });
@@ -226,4 +231,33 @@ function resumo(reg, { colunas = 80 } = {}) {
     return out.join('\n');
 }
 
-module.exports = { novo, anotar, juntar, resumo, vazio, resumoDeTeste, EH_TESTE };
+/** O teste que o PrimoCode rodou sozinho no fim da tarefa (lib/act.js conferirTestes): entra na mesma seção de prova
+    do balanço, marcado, pra a pessoa ver que foi conferido mesmo quando o agente não rodou nada. */
+function anotarTeste(reg, { comando, ok, code, saida } = {}) {
+    if (!reg || !comando || reg.testes.length >= 20) return reg;
+    reg.testes.push({ comando: `${comando} · pelo PrimoCode`, ok: !!ok, code: code ?? (ok ? 0 : 1), resumo: resumoDeTeste(saida) });
+    return reg;
+}
+
+/**
+ * Uma linha do que o pedido FEZ, pra ficar na memória da conversa (o histórico guarda só o texto final).
+ * Sem isto, no pedido seguinte ("continua", "conserta o teste") o modelo não sabia quais arquivos mexeu
+ * nem que o teste tinha ficado vermelho, a não ser que a entrega dissesse. '' quando não fez nada.
+ */
+function paraMemoria(reg, teto = 500) {
+    if (!reg || vazio(reg)) return '';
+    const p = [];
+    const lista = (xs) => xs.slice(0, 8).join(', ') + (xs.length > 8 ? ` (+${xs.length - 8})` : '');
+    if (reg.criados && reg.criados.length) p.push(`criou ${lista(reg.criados)}`);
+    if (reg.alterados && reg.alterados.length) p.push(`alterou ${lista(reg.alterados)}`);
+    if (reg.testes && reg.testes.length) {
+        const u = reg.testes[reg.testes.length - 1];
+        p.push(`último teste: ${String(u.comando).replace(/ · pelo PrimoCode$/, '')} ${u.ok ? 'passou' : 'FALHOU'}${u.resumo ? ` (${u.resumo})` : ''}`);
+    }
+    if (reg.falhas && reg.falhas.length) p.push(`falhou: ${reg.falhas.slice(-2).map((f) => `${f.acao} ${f.alvo || ''}`.trim()).join('; ')}`);
+    if (!p.length) return '';
+    const t = `[o que este pedido fez no disco: ${p.join(' · ')}]`;
+    return t.length > teto ? t.slice(0, teto - 2) + '…]' : t;
+}
+
+module.exports = { novo, anotar, anotarTeste, juntar, resumo, vazio, resumoDeTeste, paraMemoria, EH_TESTE };

package/lib/regras.js

@@ -0,0 +1,88 @@
+/**
+ * regras.js — o /regra: "nunca mexa em X" que não some quando a conversa é resumida.
+ *
+ *   ler(projectDir)               → [texto]                         (as regras, na ordem)
+ *   adicionar(projectDir, texto)  → { arquivo, regras, ja_tinha }   (repetida não entra duas vezes)
+ *   tirar(projectDir, n)          → { tirada, regras } | null        (n começa em 1)
+ *   garantir(projectDir, lista)   → as regras de volta, se alguém reescreveu o PRIMO.md (o /init)
+ *   bloco(lista)                  → o markdown do bloco, entre marcas (puro)
+ *   sugerir(pedido, existentes)   → a regra que o pedido ditou ("nunca mexa no logo"), ou null (puro: só SUGERE o /regra)
+ *
+ * A regra dita no chat vira resumo quando a conversa enche, e o resumo pode perder ela (issue 67500 do Claude Code,
+ * 11/06/2026, lida num espelho [VERIFICAR]). O PRIMO.md entra inteiro em todo pedido (lib/mencoes.js), então a regra
+ * mora nele. E mora no TOPO: o mencoes.js corta o rabo de um PRIMO.md grande, e é a cabeça que sempre entra.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const INICIO = '<!-- primocode:regras -->', FIM = '<!-- /primocode:regras -->';
+const arquivoDe = (projectDir) => path.join(projectDir, 'PRIMO.md');
+const lerArquivo = (f) => { try { return fs.readFileSync(f, 'utf8'); } catch { return ''; } };
+const limpa = (t) => String(t || '').replace(/\s+/g, ' ').trim();
+
+function separar(texto) {
+    const i = texto.indexOf(INICIO), f = texto.indexOf(FIM);
+    if (i < 0 || f < i) return { antes: '', dentro: '', depois: texto };
+    return { antes: texto.slice(0, i), dentro: texto.slice(i + INICIO.length, f), depois: texto.slice(f + FIM.length) };
+}
+
+function ler(projectDir) {
+    return separar(lerArquivo(arquivoDe(projectDir))).dentro.split('\n')
+        .map((l) => (l.match(/^\s*\d+\.\s+(.+)$/) || [])[1]).filter(Boolean).map(limpa);
+}
+
+function bloco(lista) {
+    return [INICIO, '## Regras (siga sempre, mesmo depois de resumir a conversa)', '',
+        ...lista.map((r, i) => `${i + 1}. ${r}`), '', '_Escritas com /rule no PrimoCode._', FIM].join('\n');
+}
+
+function gravar(projectDir, lista) {
+    const arquivo = arquivoDe(projectDir);
+    const { antes, depois } = separar(lerArquivo(arquivo));
+    const resto = (antes + depois).replace(/^\s+/, '');
+    // sem regra nenhuma, o bloco sai inteiro: seção vazia não fica
+    const texto = lista.length ? bloco(lista) + '\n' + (resto ? '\n' + resto : '') : resto;
+    fs.writeFileSync(arquivo, texto);
+    return arquivo;
+}
+
+function adicionar(projectDir, texto) {
+    const nova = limpa(texto);
+    const lista = ler(projectDir);
+    if (!nova) return { arquivo: arquivoDe(projectDir), regras: lista, ja_tinha: false };
+    const ja = lista.some((r) => r.toLowerCase() === nova.toLowerCase());
+    if (!ja) lista.push(nova);
+    return { arquivo: gravar(projectDir, lista), regras: lista, ja_tinha: ja };
+}
+
+function tirar(projectDir, n) {
+    const lista = ler(projectDir);
+    const i = Number(n) - 1;
+    if (!Number.isInteger(i) || i < 0 || i >= lista.length) return null;
+    const [tirada] = lista.splice(i, 1);
+    gravar(projectDir, lista);
+    return { tirada, regras: lista };
+}
+
+function garantir(projectDir, lista) {
+    const agora = ler(projectDir);
+    const faltam = (lista || []).filter((r) => !agora.some((a) => a.toLowerCase() === r.toLowerCase()));
+    if (faltam.length) gravar(projectDir, [...agora, ...faltam]);
+    return faltam;
+}
+
+// "nunca mexa…", "não apague…", "sempre responda…": uma ordem que vale além deste pedido, até o fim da frase
+const ORDEM = /(?:^|[.!?;,]\s*|\s)((?:nunca|jamais)\s+(?:mais\s+)?\S+|n[ãa]o\s+(?:mexa|mexe|toque|toca|apague|apaga|altere|altera|mude|muda|use|usa|delete|remova|remove)\b|sempre\s+(?:use|usa|responda|responde|fale|fala|escreva|escreve|mantenha|mant[ée]m|deixe|deixa)\b)([^.!?;\n]{2,100})/i;
+
+function sugerir(pedido, existentes = []) {
+    const m = String(pedido || '').match(ORDEM);
+    if (!m) return null;
+    const regra = limpa(m[1] + m[2]).replace(/[,\s]+(?:e|mas|por favor|pfv|pf)$/i, '');
+    if (regra.split(' ').length < 3) return null;   // "nunca mais" sozinho não é regra
+    return existentes.some((r) => r.toLowerCase() === regra.toLowerCase()) ? null : regra;
+}
+
+module.exports = { ler, adicionar, tirar, garantir, bloco, sugerir, INICIO, FIM };