primocode 10.17.0 → 10.19.0

package/lib/guardar.js

@@ -0,0 +1,118 @@
+/**
+ * guardar.js — o /save: guarda o projeto no GitHub, num repositório PRIVADO.
+ *
+ * Pra quem nunca programou, "guardar" é uma ação só: o resto (git init, commit,
+ * criar o repositório, enviar) acontece sozinho, em linguagem de gente.
+ *
+ *   mensagemDoCommit(statusZ)  → "Guarda 2 arquivos novos (a.js, b.js) e 1 alterado (c.js)"
+ *   urlPublica(remoto)         → 'https://github.com/eu/projeto' (de git@… ou https://….git)
+ *   salvar(dir, { run, log })  → { ok, url, erro? }
+ *
+ * `run(cmd, args, { cwd })` devolve { status, stdout, stderr }; o teste troca por um falso
+ * (gh nunca roda de verdade nos testes). Segredo nunca entra no commit: os arquivos vão um
+ * a um (não `git add -A`) e o que a lib/protecao.js reconhece como chave fica de fora.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const protecao = require('./protecao.js');
+
+function rodar(cmd, args, { cwd } = {}) {
+    const r = spawnSync(cmd, args, { cwd, encoding: 'utf8', timeout: 120000 });
+    return { status: r.error ? 127 : r.status, stdout: r.stdout || '', stderr: (r.stderr || '') + (r.error ? String(r.error.message) : '') };
+}
+
+/** `git status --porcelain -z -uall` → [{ codigo, arquivo }] (renomeado conta pelo nome novo). */
+function lerStatus(statusZ) {
+    const itens = String(statusZ || '').split('\0').filter(Boolean);
+    const out = [];
+    for (let i = 0; i < itens.length; i++) {
+        const codigo = itens[i].slice(0, 2);
+        out.push({ codigo, arquivo: itens[i].slice(3) });
+        if (/[RC]/.test(codigo)) i++; // o nome antigo vem logo depois
+    }
+    return out;
+}
+
+function mensagemDoCommit(statusZ) {
+    const itens = lerStatus(statusZ).filter((x) => !protecao.nomeDeSegredo(x.arquivo));
+    const grupo = (teste) => itens.filter((x) => teste(x.codigo)).map((x) => x.arquivo);
+    const novos = grupo((c) => c === '??' || c.includes('A'));
+    const apagados = grupo((c) => c.includes('D'));
+    const mudados = grupo((c) => !(c === '??' || c.includes('A') || c.includes('D')));
+    const parte = (lista, um, varios) => {
+        if (!lista.length) return '';
+        const nomes = lista.slice(0, 3).join(', ') + (lista.length > 3 ? ` e mais ${lista.length - 3}` : '');
+        return `${lista.length} ${lista.length === 1 ? um : varios} (${nomes})`;
+    };
+    const partes = [parte(novos, 'arquivo novo', 'arquivos novos'), parte(mudados, 'alterado', 'alterados'), parte(apagados, 'apagado', 'apagados')].filter(Boolean);
+    if (!partes.length) return 'Guarda o projeto';
+    return 'Guarda ' + (partes.length > 1 ? partes.slice(0, -1).join(', ') + ' e ' + partes[partes.length - 1] : partes[0]);
+}
+
+function urlPublica(remoto) {
+    const r = String(remoto || '').trim().replace(/\.git$/, '');
+    const ssh = r.match(/^(?:ssh:\/\/)?git@([^:/]+)[:/](.+)$/);
+    return ssh ? `https://${ssh[1]}/${ssh[2]}` : r;
+}
+
+const nomeDoRepo = (dir) => path.basename(path.resolve(dir)).toLowerCase().replace(/[^a-z0-9._-]+/g, '-').replace(/^-+|-+$/g, '') || 'meu-projeto';
+
+/** Garante `.env` (e variações) no .gitignore quando há arquivo de segredo na pasta. */
+function protegerSegredos(dir) {
+    if (protecao.envFicaDeFora(dir)) return false;
+    const temSegredo = fs.readdirSync(dir).some((n) => protecao.nomeDeSegredo(n));
+    if (!temSegredo) return false;
+    const f = path.join(dir, '.gitignore');
+    const atual = fs.existsSync(f) ? fs.readFileSync(f, 'utf8') : '';
+    fs.writeFileSync(f, atual + (atual && !atual.endsWith('\n') ? '\n' : '') + '.env\n.env.*\n');
+    return true;
+}
+
+function salvar(dir, { run = rodar, log = () => {} } = {}) {
+    const git = (...a) => run('git', a, { cwd: dir });
+    if (git('--version').status !== 0) return { ok: false, erro: 'Falta instalar o git neste computador (https://git-scm.com).' };
+
+    if (git('rev-parse', '--is-inside-work-tree').status !== 0) {
+        if (git('init', '-b', 'main').status !== 0 && git('init').status !== 0) return { ok: false, erro: 'Não consegui preparar a pasta para guardar.' };
+        log('Preparei a pasta para guardar a história do projeto.');
+    }
+    if (protegerSegredos(dir)) log('Achei um arquivo de chave (.env) e pus no .gitignore: ele não sai do seu computador.');
+
+    const st = git('status', '--porcelain', '-z', '-uall').stdout;
+    const arquivos = lerStatus(st).filter((x) => !protecao.nomeDeSegredo(x.arquivo));
+    if (arquivos.length) {
+        const add = git('add', '--', ...arquivos.map((x) => x.arquivo));
+        if (add.status !== 0) return { ok: false, erro: `Não consegui separar os arquivos: ${add.stderr.trim().split('\n')[0]}` };
+        const msg = mensagemDoCommit(st);
+        const com = git('commit', '-m', msg);
+        if (com.status !== 0) {
+            const tudo = com.stdout + com.stderr;
+            if (/tell me who you are|user\.email|user\.name/i.test(tudo)) return { ok: false, erro: 'O git não sabe quem é você. Rode: git config --global user.name "Seu Nome" e git config --global user.email "seu@email.com".' };
+            return { ok: false, erro: `Não consegui guardar a versão: ${tudo.trim().split('\n')[0]}` };
+        }
+        log(`${msg}.`);
+    } else log('Nada novo desde a última vez.');
+
+    let remoto = git('remote', 'get-url', 'origin');
+    if (remoto.status !== 0) {
+        if (git('rev-parse', '--verify', 'HEAD').status !== 0) return { ok: false, erro: 'A pasta está vazia: crie algo antes de guardar.' };
+        if (run('gh', ['--version'], { cwd: dir }).status !== 0) return { ok: false, erro: 'Falta o GitHub CLI. Instale em https://cli.github.com e rode /save de novo.' };
+        if (run('gh', ['auth', 'status'], { cwd: dir }).status !== 0) return { ok: false, erro: 'Você ainda não entrou no GitHub: rode `gh auth login` no terminal e depois /save de novo.' };
+        const nome = nomeDoRepo(dir);
+        const cria = run('gh', ['repo', 'create', nome, '--private', '--source', '.', '--push'], { cwd: dir });
+        if (cria.status !== 0) return { ok: false, erro: `O GitHub não criou o repositório: ${(cria.stderr || cria.stdout).trim().split('\n')[0]}` };
+        log(`Criei o repositório privado "${nome}" no GitHub (só você vê).`);
+        remoto = git('remote', 'get-url', 'origin');
+    } else {
+        const push = git('push', '-u', 'origin', 'HEAD');
+        if (push.status !== 0) return { ok: false, erro: `Não consegui enviar: ${push.stderr.trim().split('\n').pop()}` };
+    }
+    const url = urlPublica(remoto.stdout);
+    return { ok: true, url };
+}
+
+module.exports = { salvar, mensagemDoCommit, urlPublica, lerStatus, nomeDoRepo, protegerSegredos, rodar };

package/lib/headless.js

@@ -12,6 +12,7 @@
  */
 'use strict';
 
+const path = require('path');
 const { stripAnsi } = require('./ui');
 
 const FORMATOS = ['text', 'json'];
@@ -64,6 +65,24 @@ async function capturar(fn, { calar = false } = {}) {
     return texto.replace(/\n{3,}/g, '\n\n').trim();
 }
 
+/**
+ * A pasta do pedido no modo script: a de onde o comando rodou. Antes o `-p`
+ * ignorava a pasta e trabalhava no último projeto da sessão (currentProject):
+ * `cd meu-app && primocode -p "grave o PLANO.md"` gravava em outro lugar.
+ * null = segue o padrão: na casa, na raiz do disco e no ~/primocode (lá o
+ * PrimoCode escolhe ou cria o projeto), e no app, que manda a pasta dele.
+ */
+function pastaDoScript({ cwd, casa, raiz, app = false } = {}) {
+    if (app || !cwd) return null;
+    // realpath: no macOS a pasta temporária é /var e /private/var ao mesmo tempo
+    const real = (p) => { try { return require('fs').realpathSync(p); } catch { return path.resolve(p); } };
+    const r = real(cwd);
+    if (r === path.parse(r).root) return null;
+    if (casa && r === real(casa)) return null;
+    if (raiz && r === real(raiz)) return null;
+    return r;
+}
+
 function resultadoJson({ texto, erro, inicio, permissao, conversa, markdown }) {
     return JSON.stringify({ type: 'result', is_error: !!erro, result: erro ? String(erro) : texto, duration_ms: Date.now() - inicio, permission_mode: permissao || 'auto', conversa: conversa || null, markdown: erro ? null : (markdown || null) });
 }
@@ -80,4 +99,4 @@ function ultimaResposta(historico, desde = 0) {
     return null;
 }
 
-module.exports = { analisar, montarPedido, lerStdin, capturar, resultadoJson, ultimaResposta, FORMATOS };
+module.exports = { analisar, montarPedido, lerStdin, capturar, resultadoJson, ultimaResposta, pastaDoScript, FORMATOS };

package/lib/idioma.js

@@ -0,0 +1,74 @@
+/**
+ * idioma.js — a resposta fala a língua do pedido (26/10).
+ *
+ * Visto num `primocode -p` de verdade: o pedido veio em português claro, as
+ * ferramentas devolveram inglês, e o agente respondeu em inglês. Quem nunca
+ * programou lê "Done! I created the file" e não sabe se deu certo.
+ *
+ * Duas peças, baratas: a ordem que vai pro modelo antes do pedido
+ * (`instrucao`) e a conferência no fim (`trocouDeIdioma`), que conta palavras
+ * comuns de cada língua. Sem modelo, sem rede. Na dúvida, diz que não sabe
+ * (null) — e aí ninguém é mandado de volta.
+ */
+
+'use strict';
+
+// Palavras que quase só aparecem numa das duas línguas. As ambíguas ("a", "do",
+// "no", "me", "as") ficam de fora: contar elas dava pontos pros dois lados.
+const PT = new Set(('que não nao uma um os para pra com você voce está esta isso este essa esse pelo pela mas como foi '
+    + 'são sao já ja também tambem agora arquivo pronto feito criei crie grave escreva faça faca de da dos das na nas '
+    + 'em ao se seu sua ele ela o e é ou mais quando onde porque por sem tem ficou aqui vou deu certo então entao '
+    + 'ainda tudo nada sobre depois antes fiz salvei').split(' '));
+const EN = new Set(('the and is are you to of with this that it for your i have has was were will be been created '
+    + 'file done here now which what from on in an by not can should all we into there i\'ve i\'ll it\'s let\'s '
+    + 'updated added wrote saved successfully please task completed').split(' '));
+// Letra com acento de português: cada palavra que tem uma vale um ponto a mais.
+const ACENTO = /[ãõçáéíóúâêôà]/i;
+
+const NOMES = { pt: 'português do Brasil', en: 'inglês' };
+
+/** Tira o que não é prosa: bloco de código, `código`, link, caminho. */
+function soProsa(texto) {
+    return String(texto || '')
+        .replace(/```[\s\S]*?```/g, ' ')
+        .replace(/`[^`]*`/g, ' ')
+        .replace(/https?:\/\/\S+/g, ' ')
+        .replace(/\S*[/\\]\S*/g, ' ');
+}
+
+/** 'pt', 'en' ou null (curto demais, misturado, ou outra língua). */
+function detectar(texto) {
+    const palavras = soProsa(texto).toLowerCase().match(/[a-zà-ÿ']+/g) || [];
+    if (palavras.length < 4) return null;
+    let pt = 0, en = 0;
+    for (const p of palavras) {
+        if (PT.has(p)) pt++;
+        if (EN.has(p)) en++;
+        if (ACENTO.test(p)) pt++;
+    }
+    if (pt >= 3 && pt >= en * 2) return 'pt';
+    if (en >= 3 && en >= pt * 2) return 'en';
+    return null;
+}
+
+/** A linha que vai pro modelo antes do pedido, ou '' quando não dá pra saber a língua. */
+function instrucao(pedido) {
+    const lingua = detectar(pedido);
+    if (!lingua) return '';
+    return `[idioma] O pedido está em ${NOMES[lingua]}. Responda em ${NOMES[lingua]} — o texto e o finish — `
+        + `mesmo quando as ferramentas devolvem outra língua. Código e nomes de arquivo ficam como são.`;
+}
+
+/**
+ * A resposta final saiu claramente noutra língua? Devolve o recado pra mandar
+ * o agente de volta, ou null. Só julga quando as duas línguas são claras.
+ */
+function trocouDeIdioma(pedido, resposta) {
+    const de = detectar(pedido);
+    const saiu = detectar(resposta);
+    if (!de || !saiu || de === saiu) return null;
+    return `A sua resposta final está em ${NOMES[saiu]}, mas o pedido foi em ${NOMES[de]}. `
+        + `Escreva a mesma resposta em ${NOMES[de]}, sem mudar o conteúdo.`;
+}
+
+module.exports = { detectar, instrucao, trocouDeIdioma, NOMES };

package/lib/kits-parecidos.js

@@ -0,0 +1,99 @@
+/**
+ * kits-parecidos.js — o vídeo de referência da pessoa aponta os kits mais parecidos.
+ *
+ * A tela de referências mede o vídeo (gosto-medir.js: paleta, ritmo, movimento). Antes o `primocode kit referencia`
+ * devolvia a medida e "escolha o kit mais próximo", e a IA chutava pelo nome. Agora: a paleta da capa de cada kit
+ * (lida uma vez com o ffmpeg e guardada em ~/.primocode/kits-paletas.json) e o ritmo da receita (duração média das
+ * batidas) contra os do vídeo. Devolve os 3 mais perto, com o porquê. Sugere; quem escolhe é a IA.
+ */
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const hexRgb = (h) => { const n = parseInt(String(h).replace('#', '').padEnd(6, '0').slice(0, 6), 16); return [(n >> 16) & 255, (n >> 8) & 255, n & 255]; };
+const rgbHex = (c) => '#' + c.map((x) => Math.round(x).toString(16).padStart(2, '0')).join('');
+/* distância perceptual barata ("redmean"): melhor que RGB puro sem precisar de Lab */
+function dist(a, b) {
+    const r = (a[0] + b[0]) / 2, dr = a[0] - b[0], dg = a[1] - b[1], db = a[2] - b[2];
+    return Math.sqrt((2 + r / 256) * dr * dr + 4 * dg * dg + (2 + (255 - r) / 256) * db * db);
+}
+
+/** As 5 cores que mais aparecem numa imagem (ffmpeg → 12×21 px → baldes de 32 níveis). null sem ffmpeg. */
+function paletaDaImagem(arq) {
+    const r = spawnSync('ffmpeg', ['-v', 'error', '-i', arq, '-vf', 'scale=12:21', '-f', 'rawvideo', '-pix_fmt', 'rgb24', '-'], { maxBuffer: 1 << 20 });
+    if (r.status !== 0 || !r.stdout || !r.stdout.length) return null;
+    const baldes = new Map();
+    for (let i = 0; i + 2 < r.stdout.length; i += 3) {
+        const c = [r.stdout[i], r.stdout[i + 1], r.stdout[i + 2]];
+        const ch = c.map((x) => x >> 5).join(',');
+        const b = baldes.get(ch) || { n: 0, s: [0, 0, 0] };
+        b.n++; b.s = b.s.map((x, j) => x + c[j]);
+        baldes.set(ch, b);
+    }
+    const total = r.stdout.length / 3;
+    const cores = [...baldes.values()].sort((a, b) => b.n - a.n).map((b) => ({ c: b.s.map((x) => x / b.n), f: b.n / total }));
+    // cores DISTINTAS (um fundo escuro não ocupa as 5 vagas com 5 tons de preto) + o acento: a mais saturada com 2%+ da tela
+    const escolhidas = [];
+    for (const x of cores) { if (escolhidas.length >= 4) break; if (escolhidas.every((e) => dist(e.c, x.c) > 70)) escolhidas.push(x); }
+    const sat = (c) => (Math.max(...c) - Math.min(...c)) / 255;
+    const acento = cores.filter((x) => x.f >= 0.02 && !escolhidas.includes(x)).sort((a, b) => sat(b.c) - sat(a.c))[0];
+    if (acento && sat(acento.c) > 0.35) escolhidas.push(acento);
+    return escolhidas.map((x) => rgbHex(x.c));
+}
+
+function paletas(kits, { home = os.homedir() } = {}) {
+    const arq = path.join(home, '.primocode', 'kits-paletas.json');
+    let cache = {};
+    try { cache = JSON.parse(fs.readFileSync(arq, 'utf8')); } catch { /* primeira vez */ }
+    let mudou = false;
+    const out = {};
+    for (const k of kits) {
+        if (!k.capa) continue;
+        let m = 0;
+        try { m = Math.round(fs.statSync(k.capa).mtimeMs); } catch { continue; }
+        const ch = `${k.slug}@${m}`;
+        if (!cache[ch]) { const p = paletaDaImagem(k.capa); if (!p) continue; cache[ch] = p; mudou = true; }
+        out[k.slug] = cache[ch];
+    }
+    if (mudou) { try { fs.mkdirSync(path.dirname(arq), { recursive: true }); fs.writeFileSync(arq, JSON.stringify(cache)); } catch { /* sem cache */ } }
+    return out;
+}
+
+/** O ritmo do kit pela receita: a duração média das batidas (rápido < 1,6 s ≤ médio < 2,4 s ≤ lento). */
+function ritmoDoKit(k) {
+    try {
+        const r = JSON.parse(fs.readFileSync(path.join(k.pasta, 'receita.json'), 'utf8'));
+        const fps = r.fps || 30;
+        const ds = (r.batidas || []).map((b) => ((b.duracao || [45, 45])[0] + (b.duracao || [45, 45])[1]) / 2 / fps);
+        const media = ds.reduce((a, b) => a + b, 0) / (ds.length || 1);
+        return media < 1.6 ? 'rapido' : media < 2.4 ? 'medio' : 'lento';
+    } catch { return null; }
+}
+
+/** Distância de paleta: cada cor do vídeo até a cor mais perto do kit, e vice-versa (0 = igual). */
+function distPaleta(a, b) {
+    const A = a.map(hexRgb), B = b.map(hexRgb);
+    const ida = A.reduce((s, c) => s + Math.min(...B.map((x) => dist(c, x))), 0) / A.length;
+    const volta = B.reduce((s, c) => s + Math.min(...A.map((x) => dist(c, x))), 0) / B.length;
+    return (ida + volta) / 2;
+}
+
+/** Os `n` kits mais perto da medida do vídeo: [{k, nota, porque}]. */
+function parecidos(medida, kits, { home, n = 3 } = {}) {
+    if (!medida || !Array.isArray(medida.paleta) || !medida.paleta.length) return [];
+    const pals = paletas(kits, { home });
+    const ORDEM = { rapido: 0, medio: 1, lento: 2 };
+    return kits.filter((k) => pals[k.slug]).map((k) => {
+        const dp = distPaleta(medida.paleta, pals[k.slug]);
+        const rk = ritmoDoKit(k);
+        const dr = rk && medida.ritmo && ORDEM[rk] != null && ORDEM[medida.ritmo] != null ? Math.abs(ORDEM[rk] - ORDEM[medida.ritmo]) : 1;
+        const nota = dp + dr * 35;
+        const porque = `cores ${dp < 90 ? 'bem perto' : dp < 160 ? 'perto' : 'diferentes'} (${pals[k.slug].slice(0, 3).join(' ')})${rk ? `, ritmo ${rk === medida.ritmo ? 'igual' : rk}` : ''}`;
+        return { k, nota, porque };
+    }).sort((a, b) => a.nota - b.nota).slice(0, n);
+}
+
+module.exports = { parecidos, paletas, paletaDaImagem, ritmoDoKit, distPaleta };