primocode 10.15.2 → 10.17.0

package/lib/entrega.js

@@ -0,0 +1,58 @@
+/**
+ * entrega.js — relatório grande não se perde: corta e guarda o resto.
+ *
+ * Visto no pi-desktop (vastsa, LGPL-3.0; só a ideia, código nosso): o relatório
+ * do subagente tem teto, e o que passa do teto vai para um arquivo, com o
+ * caminho no fim do texto. Antes, o `entregaDoAgente` fazia `.slice(0, 4000)`
+ * e o resto sumia: o especialista escrevia 9 mil caracteres de achados e o
+ * agente principal lia a metade, sem saber que faltava metade.
+ *
+ * O corte cai no fim de um parágrafo (ou de uma linha), nunca no meio de uma
+ * palavra. O arquivo mora na pasta temporária e é liberado para leitura, então
+ * o `read_file` do agente principal alcança.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const TETO = 4000;
+
+function pontoDeCorte(texto, teto) {
+    const trecho = texto.slice(0, teto);
+    for (const sep of ['\n\n', '\n', '. ']) {
+        const i = trecho.lastIndexOf(sep);
+        if (i > teto * 0.6) return i + (sep === '. ' ? 1 : 0);
+    }
+    return teto;
+}
+
+/**
+ * @returns {{texto: string, arquivo: string|null, cortado: boolean}}
+ * `gravar(texto, quem)` devolve o caminho do arquivo (injetável no teste).
+ */
+function limitar(texto, { teto = TETO, quem = 'agente', gravar = gravarNaTemp } = {}) {
+    const t = String(texto == null ? '' : texto).trim();
+    if (t.length <= teto) return { texto: t, arquivo: null, cortado: false };
+    const corte = pontoDeCorte(t, teto);
+    let arquivo = null;
+    try { arquivo = gravar(t, quem); } catch { /* sem disco: corta e avisa mesmo assim */ }
+    const aviso = arquivo
+        ? `\n\n(…relatório cortado: ${t.length} caracteres, faltam ${t.length - corte}. O texto inteiro está em ${arquivo} — leia com read_file se precisar do resto.)`
+        : `\n\n(…relatório cortado: ${t.length} caracteres, faltam ${t.length - corte}. Não deu para guardar o resto; peça de novo ao agente, mais curto.)`;
+    return { texto: t.slice(0, corte).trimEnd() + aviso, arquivo, cortado: true };
+}
+
+function gravarNaTemp(texto, quem) {
+    const dir = path.join(os.tmpdir(), 'primocode-entregas');
+    fs.mkdirSync(dir, { recursive: true });
+    const nome = `${Date.now()}-${String(quem).toLowerCase().replace(/[^a-z0-9]+/g, '-').slice(0, 30) || 'agente'}.md`;
+    const arquivo = path.join(dir, nome);
+    fs.writeFileSync(arquivo, texto, 'utf8');
+    try { require('./tools').liberarLeitura(dir); } catch { /* sem tools: o arquivo existe do mesmo jeito */ }
+    return arquivo;
+}
+
+module.exports = { limitar, TETO };

package/lib/estudio/conferencia-visual.js

@@ -0,0 +1,76 @@
+/**
+ * conferencia-visual.js — o olho DEPOIS do render: o quadro de cada cena, lido de verdade.
+ *
+ *   conferir({quadros, pl, guarda, visao}) → {olho: 'vision'|'caixas', problemas: [{cena, tipo, texto}], leituras}
+ *
+ * Com o Vision do macOS (lib/estudio/visao.js): o texto que aparece no quadro (OCR) e os rostos. Reprova:
+ *   borda        texto a menos de 3% da beira do quadro (colado na borda)
+ *   rosto        texto em cima de um rosto
+ *   encavalado   duas linhas de texto uma em cima da outra
+ * Sempre (com ou sem o Vision): as caixas finais da guarda do kit (linhas "GUARDA {json}") conferidas de novo
+ * (maquina-guarda.verificarCaixas): sobreposição e fora da zona segura. Sem Vision, é só isso ("caixas").
+ * Puro na decisão (julgarLeitura): testável sem quadro nem Vision.
+ */
+'use strict';
+
+const G = require('./maquina-guarda.js');
+
+const LIM = { borda: 0.03, conf: 0.5, alturaMin: 0.012, rostoMin: 0.004 };
+const area = (c) => Math.max(0, c[2] - c[0]) * Math.max(0, c[3] - c[1]);
+const inter = (a, b) => Math.max(0, Math.min(a[2], b[2]) - Math.max(a[0], b[0])) * Math.max(0, Math.min(a[3], b[3]) - Math.max(a[1], b[1]));
+
+/** Os problemas de UM quadro lido pelo Vision ({w, h, textos:[{texto, conf, caixa}], rostos:[caixa]}). */
+function julgarLeitura(q, cena, { foto = null } = {}) {
+    const out = [];
+    if (!q || !q.ok || !q.w || !q.h) return out;
+    const W = q.w, H = q.h;
+    const textos = (q.textos || []).filter((t) => t.conf >= LIM.conf && (t.caixa[3] - t.caixa[1]) >= H * LIM.alturaMin && String(t.texto).replace(/[^A-Za-zÀ-ÿ0-9]/g, '').length >= 2);
+    // com a caixa da foto (já na escala do quadro), só vale rosto DENTRO dela: o fundo desfocado é a mesma foto ampliada e também tem rosto
+    const naFoto = (r) => !foto || ((r[0] + r[2]) / 2 >= foto[0] && (r[0] + r[2]) / 2 <= foto[2] && (r[1] + r[3]) / 2 >= foto[1] && (r[1] + r[3]) / 2 <= foto[3]);
+    const rostos = (q.rostos || []).filter((r) => area(r) >= W * H * LIM.rostoMin && naFoto(r));
+    for (const t of textos) {
+        const c = t.caixa;
+        if (c[0] < W * LIM.borda || c[2] > W * (1 - LIM.borda) || c[1] < H * LIM.borda || c[3] > H * (1 - LIM.borda)) out.push({ cena, tipo: 'borda', texto: `texto colado na borda: "${t.texto}"` });
+        for (const r of rostos) if (inter(c, r) > 0.15 * area(c)) out.push({ cena, tipo: 'rosto', texto: `texto sobre o rosto: "${t.texto}"` });
+    }
+    for (let i = 0; i < textos.length; i++) for (let j = i + 1; j < textos.length; j++) {
+        const a = textos[i].caixa, b = textos[j].caixa;
+        if (inter(a, b) > 0.3 * Math.min(area(a), area(b))) out.push({ cena, tipo: 'encavalado', texto: `textos encavalados: "${textos[i].texto}" × "${textos[j].texto}"` });
+    }
+    return out;
+}
+
+/** As linhas "GUARDA {json}" que o kit escreveu (uma por cena). */
+function lerGuarda(saida) {
+    return String(saida || '').split('\n').filter((l) => /^GUARDA \{/.test(l)).map((l) => { try { return JSON.parse(l.slice(7)); } catch { return null; } }).filter(Boolean);
+}
+
+/** `quadros[i]` é o quadro da cena i. `guarda` = lerGuarda(saida). `visao` injetável (testes); null = sem olho. */
+function conferir({ quadros = [], pl = {}, guarda = [], visao } = {}) {
+    const problemas = [];
+    const legenda = !!(pl.legenda && pl.legenda.chunks && pl.legenda.chunks.length);
+    for (const g of guarda) {
+        for (const v of G.verificarCaixas(g.caixas, g.w || pl.w, g.h || pl.h, { legenda })) problemas.push({ cena: g.cena, tipo: /fora|trilho/.test(v) ? 'zona' : 'sobreposicao', texto: v });
+    }
+    let V = visao;
+    if (V === undefined) { try { V = require('./visao.js'); } catch { V = null; } }
+    let olho = 'caixas', leituras = null;
+    if (V && V.disponivel() && quadros.length) {
+        const r = V.ler(quadros);
+        if (r && r.ok) {
+            olho = 'vision'; leituras = r.quadros;
+            r.quadros.forEach((q) => {
+                const i = quadros.indexOf(q.arquivo);
+                if (i < 0) return;
+                // a caixa da foto (layout) levada pro quadro: escala do quadro, câmera ~0,94 em volta do centro, 20% de folga
+                const g = guarda.find((x) => x.cena === i), fc = g && (g.caixas || []).find((c) => c.tipo === 'foto');
+                let foto = null;
+                if (fc && q.w) { const W0 = g.w || pl.w, H0 = g.h || pl.h, k = q.w / W0, cx = W0 / 2, cy = H0 / 2, e = (x, c0) => (c0 + (x - c0) * 0.94) * k; const fw = (fc.c[2] - fc.c[0]) * 0.1 * k, fh = (fc.c[3] - fc.c[1]) * 0.1 * k; foto = [e(fc.c[0], cx) - fw, e(fc.c[1], cy) - fh, e(fc.c[2], cx) + fw, e(fc.c[3], cy) + fh]; }
+                problemas.push(...julgarLeitura(q, i, { foto }));
+            });
+        }
+    }
+    return { olho, problemas, leituras };
+}
+
+module.exports = { conferir, julgarLeitura, lerGuarda, LIM };

package/lib/estudio/diretor.js

@@ -77,9 +77,14 @@ const PEDE_EFEITO = /\b(tir[ae]r?|remov\w*|troc\w*)\s+(o\s+)?fundo\b|\bsepar\w*\
    arquivo de vídeo em qualquer lugar da frase é edição. */
 const EDITA_ARQUIVO = /\b(edit\w*|edi[cç][aã]o|p[oõ]e\s+(ele\s+)?pra\s+editar)\b[\s\S]*\.(mp4|mov|mkv|webm|m4v)\b|\.(mp4|mov|mkv|webm|m4v)\b[\s\S]*\b(edit\w*|edi[cç][aã]o)\b/i;
 
+/* A gravação da pessoa FALANDO, sem caminho de arquivo na frase (20/10, a edição completa do
+   editor_pro): "edita meu vídeo", "faz um reels disso", "coloca legenda e efeitos nele". Fala de
+   uma gravação que JÁ existe ("disso", "meu vídeo", "nele"), não de criar um vídeo do zero. */
+const PEDE_EDICAO_FALADA = /\bedit\w*\s+(o\s+|esse\s+|este\s+)?(meu\s+)?(v[ií]deo|grava[cç][aã]o)\s+(meu|que\s+eu\s+gravei)\b|\bedit\w*\s+(o\s+)?meu\s+v[ií]deo\b|\b(faz|fa[cç]a|transform\w*|vir\w*)\s+(um\s+|uma\s+|em\s+)?(reels?|tiktok|shorts?|criativo|corte)\s+(disso|desse|dessa|deste|desta|com\s+(esse|essa|este|esta|a\s+minha|o\s+meu))\b|\bcoloc\w*\s+(uma\s+)?legendas?\s+e\s+(uns\s+)?efeitos?\b|\b(legend\w*|efeitos?)\b[\s\S]{0,30}\b(no\s+meu\s+v[ií]deo|na\s+minha\s+grava[cç][aã]o|nele|nessa\s+grava[cç][aã]o)\b/i;
+
 function precisaDeEdicao(texto) {
     const t = String(texto || '');
-    return PEDE_EDICAO.test(t) || PEDE_EFEITO.test(t) || EDITA_ARQUIVO.test(t);
+    return PEDE_EDICAO.test(t) || PEDE_EFEITO.test(t) || EDITA_ARQUIVO.test(t) || PEDE_EDICAO_FALADA.test(t);
 }
 
 // ── 2. as decisões que não são do modelo ─────────────────────────────────

package/lib/estudio/exportar.js

@@ -154,7 +154,9 @@ function registrar({ id, assunto, caminho, formato, duracao, assinatura, entrega
     try { fs.mkdirSync(path.dirname(arq), { recursive: true }); fs.writeFileSync(arq, JSON.stringify(l.slice(-200), null, 2)); } catch { /* sem disco: segue */ }
     return item;
 }
-const listar = (arq) => ler(arq).filter((v) => v.caminho && fs.existsSync(v.caminho)).sort((a, b) => String(b.data).localeCompare(String(a.data)));
+// mais novo primeiro; no empate de data (dois no mesmo milissegundo), vale a ordem de gravação: o último registrado vem antes
+const listar = (arq) => ler(arq).map((v, i) => ({ v, i })).filter(({ v }) => v.caminho && fs.existsSync(v.caminho))
+    .sort((a, b) => String(b.v.data).localeCompare(String(a.v.data)) || b.i - a.i).map(({ v }) => v);
 function abrirNoSistema(alvo) {
     if (process.env.PRIMOCODE_SEM_NAVEGADOR === '1') return false;   // app do Primo (voz): navegador só com clique explícito
     const cmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'cmd' : 'xdg-open';