primocode 10.19.0 → 11.1.0

package/lib/estudio/projeto.js

@@ -1,340 +0,0 @@
-/**
- * projeto.js — cada vídeo é uma pasta, e ela não some.
- *
- *   "Memória de projetos: todos os vídeos gerados ficam salvos. Semanas depois
- *    eu posso dizer 'não gostei de tal parte daquele vídeo' e a IA precisa
- *    localizar o projeto, lembrar o que fez e editar aquele trecho."
- *
- * ── O QUE MUDOU DE VERDADE ───────────────────────────────────────────────
- * O Studio antigo guardava as peças dentro de um servidor Python, num
- * `arquivos/` com id numérico, e o "histórico" era uma lista de versões do
- * documento JSON. Duas coisas não funcionavam ali:
- *
- *   · para achar "aquele vídeo do PicPay de três semanas atrás" era preciso
- *     saber o id; e
- *   · o que ficava guardado era o RESULTADO, não as decisões. Reabrir um
- *     projeto dizia o que existia, nunca por quê — e sem o porquê, mexer num
- *     trecho vira refazer do zero.
- *
- * Aqui a pasta guarda as duas coisas: o plano (o que é cada cena) e o
- * caderno (o que foi pedido, o que foi decidido e o que mudou, em ordem).
- * Semanas depois, "não gostei da parte do cartão" acha o projeto pelo texto,
- * lê o caderno, e mexe SÓ naquela cena.
- *
- * ── POR QUE NÃO HÁ SERVIDOR ──────────────────────────────────────────────
- * O Studio antigo subia um servidor Python em localhost:7777 e falava com ele
- * por HTTP. Isso existia porque a interface de edição era uma página web. A
- * interface morreu — a IA faz tudo e abre o vídeo pronto —, e com ela morre o
- * servidor. Sobra o que importa: pastas, arquivos e ffmpeg.
- *
- * Isso apaga uma classe inteira de defeito. "O estúdio não está rodando na sua
- * máquina" era uma resposta real que o agente dava, e era um pedido de vídeo
- * que morria por causa de uma porta ocupada.
- */
-
-'use strict';
-
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const crypto = require('crypto');
-
-const { nomeCurto, semColisao } = require('../nome-curto.js');
-
-const CASA = path.join(os.homedir(), '.primocode', 'studio');
-const PROJETOS = path.join(CASA, 'projetos');
-
-/* Nome de ARQUIVO (o mp4, o pdf da saída). A pasta do projeto não usa mais
-   isto: ver `criar` e lib/nome-curto.js. */
-function apelidar(bruto) {
-    return String(bruto || '')
-        .normalize('NFD').replace(/[̀-ͯ]/g, '')
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, '-')
-        .replace(/^-+|-+$/g, '')
-        .slice(0, 40) || 'projeto';
-}
-
-function agora() { return new Date().toISOString(); }
-
-function garantirCasa() {
-    fs.mkdirSync(PROJETOS, { recursive: true });
-    return PROJETOS;
-}
-
-/* ── ONDE MORA CADA PROJETO ──────────────────────────────────────────────
- * Antes: `projetos/2026-10-11-claude-e-humano-conversam-sobre-o-segund`. A
- * data na frente servia para a lista sair em ordem, e o resto era a frase
- * cortada no meio. O dono: "essa estrutura de pastas está horrível".
- *
- * Agora: `projetos/2026-10/claude-segundo-cerebro`. O MÊS vira pasta (a
- * ordem cronológica continua de graça, e um mês cabe numa tela), e o nome é
- * curto e legível (lib/nome-curto.js). O dia exato fica no projeto.json.
- *
- * O id continua sendo SÓ o nome da pasta — sem o mês. É ele que o modelo
- * escreve, que vai na memória e que a pessoa cita; pôr barra nele faria o
- * `pastaDe` recusar (e com razão). Por isso o nome é único entre TODOS os
- * meses, e quem acha a pasta pelo id é o `pastaDe`, que olha os meses.
- *
- * Os projetos antigos (`projetos/2026-09-25-...`) ficam onde estão: nada é
- * renomeado, e o id antigo continua abrindo o mesmo projeto. */
-const MES = /^\d{4}-\d{2}$/;
-
-function mesDe(data = new Date()) {
-    return `${data.getFullYear()}-${String(data.getMonth() + 1).padStart(2, '0')}`;
-}
-
-/** As pastas de mês que existem, da mais nova para a mais velha. */
-function meses() {
-    try {
-        return fs.readdirSync(PROJETOS, { withFileTypes: true })
-            .filter((d) => d.isDirectory() && MES.test(d.name)).map((d) => d.name).sort().reverse();
-    } catch { return []; }
-}
-
-/** Todos os ids que existem, antigos (soltos) e novos (dentro do mês). */
-function idsTomados() {
-    const ids = [];
-    try {
-        for (const d of fs.readdirSync(PROJETOS, { withFileTypes: true })) {
-            if (d.isDirectory() && !MES.test(d.name)) ids.push(d.name);
-        }
-    } catch { /* casa vazia */ }
-    for (const m of meses()) {
-        try {
-            for (const d of fs.readdirSync(path.join(PROJETOS, m), { withFileTypes: true })) {
-                if (d.isDirectory()) ids.push(d.name);
-            }
-        } catch { /* mês sumiu no meio */ }
-    }
-    return ids;
-}
-
-/**
- * Abre um projeto novo, em `projetos/<AAAA-MM>/<nome-curto>`.
- */
-function criar({ titulo, pedido, formato = 'video' }) {
-    garantirCasa();
-    const texto = titulo || pedido;
-    const base = nomeCurto(texto) || 'projeto';
-    const id = semColisao(base, idsTomados(), `${titulo || ''} ${pedido || ''}`);
-
-    const pasta = path.join(PROJETOS, mesDe(), id);
-    for (const sub of ['midia', 'saida', 'entrada']) {
-        fs.mkdirSync(path.join(pasta, sub), { recursive: true });
-    }
-
-    const meta = {
-        id,
-        titulo: String(titulo || pedido || 'sem título').slice(0, 120),
-        formato,                       // video | slides | arte | documento
-        pedido: String(pedido || ''),
-        criado: agora(),
-        mudado: agora(),
-        renders: [],
-    };
-    escreverJSON(path.join(pasta, 'projeto.json'), meta);
-    anotar(id, 'nasceu', String(pedido || ''));
-    return { ok: true, id, pasta, meta };
-}
-
-function escreverJSON(arquivo, valor) {
-    fs.mkdirSync(path.dirname(arquivo), { recursive: true });
-    fs.writeFileSync(arquivo, JSON.stringify(valor, null, 2), 'utf8');
-}
-
-function lerJSON(arquivo, padrao = null) {
-    try { return JSON.parse(fs.readFileSync(arquivo, 'utf8')); } catch { return padrao; }
-}
-
-/**
- * A pasta de um projeto — ou null, quando o id não serve.
- *
- * ── POR QUE ISTO VALIDA, EM VEZ DE SÓ CONCATENAR ────────────────────────
- * O `id` vem do MODELO, e o modelo erra de dois jeitos que doem aqui:
- *
- * 1. Não manda nada. Visto em produção: o agente chamou `estudio_plano` sem
- *    `id`, o `path.join` recebeu `undefined` e a tool explodiu com
- *    'The "path" argument must be of type string. Received undefined' — uma
- *    mensagem que não fala de projeto nenhum, e que o agente não tem como
- *    corrigir porque não diz o que faltou. A checagem de "achei o projeto?"
- *    vinha DEPOIS, e nunca era alcançada.
- *
- * 2. Manda um id com caminho dentro ("../../etc/passwd", "/tmp/x"). O
- *    `path.join` obedece: sobe de pasta e sai da casa dos projetos. O id de
- *    um projeto é um nome de pasta, não um caminho — então tudo que tem
- *    barra ou `..` é recusado, em vez de resolvido.
- */
-function pastaDe(id) {
-    if (typeof id !== 'string' || !id.trim()) return null;
-    const limpo = id.trim();
-    if (limpo.includes('/') || limpo.includes('\\') || limpo.includes('..')) return null;
-    // Um mês não é projeto: "2026-10" como id abriria a pasta do mês inteiro.
-    if (MES.test(limpo)) return null;
-    // O antigo, solto na casa (`2026-09-25-...`), continua valendo.
-    const solto = path.join(PROJETOS, limpo);
-    if (fs.existsSync(solto)) return solto;
-    for (const m of meses()) {
-        const dentro = path.join(PROJETOS, m, limpo);
-        if (fs.existsSync(dentro)) return dentro;
-    }
-    // Não existe ainda: o lugar de antes. Quem precisa que exista (`ler`)
-    // confere o projeto.json; este caminho só serve para dizer onde seria.
-    return solto;
-}
-
-/** O meta de um projeto, ou null. */
-function ler(id) {
-    const pasta = pastaDe(id);
-    if (!pasta) return null;
-    const meta = lerJSON(path.join(pasta, 'projeto.json'));
-    if (!meta) return null;
-    return { ...meta, pasta };
-}
-
-function salvar(id, mudancas) {
-    const meta = ler(id);
-    if (!meta) return { ok: false, error: `Projeto "${id}" não existe.` };
-    const novo = { ...meta, ...mudancas, id, mudado: agora() };
-    delete novo.pasta;
-    escreverJSON(path.join(pastaDe(id), 'projeto.json'), novo);
-    return { ok: true, meta: { ...novo, pasta: pastaDe(id) } };
-}
-
-/** Todos, do mais novo para o mais velho. */
-/* A ordem vinha do nome (a data na frente). Sem data no nome, ela vem do
-   `criado` do projeto.json — que todo projeto, velho ou novo, tem. */
-function listar({ limite = 50 } = {}) {
-    garantirCasa();
-    const todos = idsTomados().map(ler).filter(Boolean);
-    todos.sort((a, b) => String(b.criado || '').localeCompare(String(a.criado || '')) || (a.id < b.id ? 1 : -1));
-    return todos.slice(0, limite);
-}
-
-// ── o caderno ────────────────────────────────────────────────────────────
-
-/**
- * O que foi pedido, decidido e mudado — em ordem, uma linha por evento.
- *
- * Guardado como texto (JSONL), não como JSON de uma lista só: um caderno
- * cresce sempre, e reescrever o arquivo inteiro a cada anotação é como se
- * perde um caderno quando o processo morre no meio.
- */
-function anotar(id, tipo, texto, extra = {}) {
-    const pasta = pastaDe(id);
-    if (!pasta) return false;
-    const linha = JSON.stringify({ quando: agora(), tipo, texto: String(texto || ''), ...extra });
-    try {
-        fs.mkdirSync(pasta, { recursive: true });
-        fs.appendFileSync(path.join(pasta, 'caderno.jsonl'), linha + '\n', 'utf8');
-        return true;
-    } catch { return false; }
-}
-
-function caderno(id, { ultimas = 40 } = {}) {
-    const pasta = pastaDe(id);
-    if (!pasta) return [];
-    let bruto = '';
-    try { bruto = fs.readFileSync(path.join(pasta, 'caderno.jsonl'), 'utf8'); } catch { return []; }
-    const linhas = bruto.split('\n').filter(Boolean).slice(-ultimas);
-    return linhas.map((l) => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
-}
-
-// ── achar de novo ────────────────────────────────────────────────────────
-
-const semAcento = (v) => String(v || '').toLowerCase()
-    .normalize('NFD').replace(/[̀-ͯ]/g, '');
-
-/**
- * Acha o projeto pelo que a pessoa lembra.
- *
- * Ela não lembra do id. Ela diz "o vídeo do PicPay", "aquele do olho", "o de
- * semana passada". Então a busca olha título, pedido e o CADERNO inteiro —
- * porque o que ela lembra costuma ser um detalhe do meio do processo ("aquele
- * com o cartão passando"), que nunca esteve no título.
- *
- * Empate desempata pelo mais novo: quem diz "aquele vídeo" quase sempre fala
- * do último.
- */
-function procurar(texto, { limite = 5 } = {}) {
-    const termos = semAcento(texto).split(/\s+/).filter((t) => t.length >= 3);
-    if (!termos.length) return listar({ limite });
-
-    const pontuados = listar({ limite: 200 }).map((p) => {
-        const palha = semAcento([
-            p.titulo, p.pedido,
-            ...caderno(p.id, { ultimas: 200 }).map((e) => e.texto),
-        ].join(' '));
-        let pontos = 0;
-        for (const t of termos) if (palha.includes(t)) pontos++;
-        return { projeto: p, pontos };
-    }).filter((x) => x.pontos > 0);
-
-    pontuados.sort((a, b) => b.pontos - a.pontos
-        || String(b.projeto.criado || '').localeCompare(String(a.projeto.criado || '')));
-    return pontuados.slice(0, limite).map((x) => x.projeto);
-}
-
-// ── o plano ──────────────────────────────────────────────────────────────
-
-// null quando o id não serve — e `lerJSON(null)` devolve null, que é o que
-// todo mundo aqui já sabe tratar.
-const planoDe = (id) => { const p = pastaDe(id); return p ? path.join(p, 'plano.json') : null; };
-
-function lerPlano(id) { const a = planoDe(id); return a ? lerJSON(a) : null; }
-
-/**
- * Grava o plano e guarda a versão anterior.
- *
- * As versões existem para "volta como estava antes" e para o caso de uma
- * edição pontual estragar o resto. Elas são numeradas e ficam em `versoes/`;
- * nada é sobrescrito sem uma cópia ficar para trás.
- */
-function salvarPlano(id, plano, motivo = '') {
-    const pasta = pastaDe(id);
-    if (!pasta) return { ok: false, error: `Projeto "${id}" não existe.` };
-    const anterior = lerPlano(id);
-    if (anterior) {
-        const versoes = path.join(pasta, 'versoes');
-        fs.mkdirSync(versoes, { recursive: true });
-        const n = fs.readdirSync(versoes).filter((f) => f.endsWith('.json')).length + 1;
-        escreverJSON(path.join(versoes, `${String(n).padStart(3, '0')}.json`), anterior);
-    }
-    escreverJSON(planoDe(id), plano);
-    anotar(id, 'plano', motivo || 'plano atualizado', { cenas: (plano.cenas || []).length });
-    return { ok: true };
-}
-
-function versoes(id) {
-    const pasta = pastaDe(id);
-    if (!pasta) return [];
-    const dir = path.join(pasta, 'versoes');
-    try { return fs.readdirSync(dir).filter((f) => f.endsWith('.json')).sort(); } catch { return []; }
-}
-
-function voltarPara(id, versao) {
-    const pasta = pastaDe(id);
-    if (!pasta) return { ok: false, error: `Projeto "${id}" não existe.` };
-    const arquivo = path.join(pasta, 'versoes', String(versao || '').replace(/[^\w.-]+/g, ''));
-    const plano = lerJSON(arquivo);
-    if (!plano) return { ok: false, error: `Versão "${versao}" não existe.` };
-    salvarPlano(id, plano, `voltou para a versão ${versao}`);
-    return { ok: true, plano };
-}
-
-/** Onde guardar uma mídia baixada, com nome que não colide. */
-function caminhoDeMidia(id, nome) {
-    const pasta = pastaDe(id);
-    if (!pasta) return null;
-    const limpo = String(nome || 'arquivo').replace(/[^\w.-]+/g, '-').slice(-60);
-    const marca = crypto.randomBytes(3).toString('hex');
-    return path.join(pasta, 'midia', `${marca}-${limpo}`);
-}
-
-module.exports = {
-    CASA, PROJETOS,
-    criar, ler, salvar, listar, procurar, pastaDe, apelidar, mesDe,
-    anotar, caderno,
-    lerPlano, salvarPlano, versoes, voltarPara,
-    caminhoDeMidia, escreverJSON, lerJSON,
-};

package/lib/estudio/projetos.js

@@ -1,72 +0,0 @@
-/**
- * projetos.js — receitas de projetos completos que a IA consulta antes de montar.
- *
- * Cada receita (dados/projetos/*.json) diz para quem serve, a ficha técnica,
- * as etapas e um prompt com {{CAMPOS}}. O conteúdo é original do PrimoCode e
- * descreve o que as ferramentas do Estúdio já fazem.
- */
-
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-
-const PASTA = path.join(__dirname, 'dados', 'projetos');
-const CATEGORIAS = ['narrado', 'produto', 'saas', 'sound', 'elementos', 'ae'];
-
-const sem = (s) => String(s || '').normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase();
-
-let cache = null;
-function todos() {
-    if (!cache) {
-        cache = fs.readdirSync(PASTA).filter((f) => f.endsWith('.json')).sort()
-            .map((f) => JSON.parse(fs.readFileSync(path.join(PASTA, f), 'utf8')));
-    }
-    return cache;
-}
-
-/** Busca sem acento em título, resumo, estilo e indicado; sem termo, lista tudo. */
-function procurar({ termo, categoria, limite = 10 } = {}) {
-    const cat = categoria ? sem(categoria) : '';
-    const palavras = sem(termo).split(/\s+/).filter(Boolean);
-    const achados = todos().filter((p) => {
-        if (cat && p.categoria !== cat) return false;
-        const palheiro = sem([p.titulo, p.resumo, (p.estilo || []).join(' '), p.indicado].join(' '));
-        return palavras.every((w) => palheiro.includes(w));
-    })
-        // Com 68 receitas, a ordem importa: a palavra no título vale mais que no resumo.
-        .map((p) => ({ p, nota: palavras.filter((w) => sem(p.titulo).includes(w)).length }))
-        .sort((a, b) => b.nota - a.nota)
-        .map((x) => x.p)
-        .slice(0, Math.max(1, Number(limite) || 10));
-    return {
-        ok: true, quantos: achados.length, categorias: CATEGORIAS,
-        projetos: achados.map((p) => ({ id: p.id, titulo: p.titulo, categoria: p.categoria, resumo: p.resumo, estilo: p.estilo, motor: p.ficha.motor })),
-        nota: 'estudio_midia acao:"projeto" nome:"<id>" traz a receita inteira.',
-    };
-}
-
-/** A receita inteira, pelo id (ou, na falta, o melhor palpite do texto). */
-function ver(id, { c } = {}) {
-    const q = sem(id).trim();
-    if (!q) return { ok: false, error: 'diga o id da receita (acao:"projetos" lista).' };
-    const p = todos().find((x) => x.id === q) || procurar({ termo: q, limite: 1 }).projetos.map((x) => todos().find((y) => y.id === x.id))[0];
-    if (!p) return { ok: false, error: `não há receita "${id}".`, ids: todos().map((x) => x.id) };
-    // O plano decide (lib/limites.js): grátis vê o resumo; sem scriptsAE a receita vem sem os scripts.
-    if (c && c.recursos) {
-        const lim = require('../limites.js');
-        if (!c.recursos.clubeCompleto) {
-            const { id: i, titulo, categoria, resumo, indicado, estilo, ficha } = p;
-            return { ok: true, bloqueado: true, projeto: { id: i, titulo, categoria, resumo, indicado, estilo, ficha }, aviso: lim.bloqueio('clubeCompleto', c) };
-        }
-        if (p.scripts_ae && !c.recursos.scriptsAE) {
-            const { scripts_ae: _, ...resto } = p;
-            return { ok: true, projeto: resto, scripts_ae_bloqueado: lim.bloqueio('scriptsAE', c) };
-        }
-    }
-    // Os scripts do After Effects ficam em disco: a resposta leva o caminho, e o agente lê só o que precisar.
-    if (p.scripts_ae) p.scripts_ae = { ...p.scripts_ae, caminho: path.join(__dirname, 'dados', 'projetos-ae', p.id.replace(/^clube-/, '')) };
-    return { ok: true, projeto: p };
-}
-
-module.exports = { procurar, ver, CATEGORIAS };

package/lib/exportar-conversa.js

@@ -1,49 +0,0 @@
-/**
- * exportar-conversa.js — o /exportar: a conversa vira um .md pra guardar ou mandar pra alguém.
- *
- *   mascarar(texto)                              → o texto sem chave nem senha        (puro)
- *   montarMd(historico, { projeto, quando })     → o .md                               (puro)
- *   gravar(historico, { projeto, quando, raiz }) → caminho do arquivo
- *
- * O OpenCode tirou o /share em 15/10/2026 (rohitai.com [VERIFICAR]) e quem usava pra mostrar a conversa ficou sem.
- * Aqui é local, sem link público: um arquivo em ~/primocode/conversas/, com chave e senha trocadas por
- * "[chave escondida]" (os mesmos padrões da varredura do "pronto", lib/chave-exposta.js).
- */
-
-'use strict';
-
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const { TIPOS } = require('./chave-exposta.js');
-
-function mascarar(texto) {
-    let t = String(texto == null ? '' : texto);
-    for (const [, re] of TIPOS) t = t.replace(new RegExp(re.source, re.flags.includes('g') ? re.flags : re.flags + 'g'), '[chave escondida]');
-    return t;
-}
-
-const QUEM = { user: 'Você', assistant: 'PrimoCode' };
-
-function montarMd(historico, { projeto = '', quando = new Date() } = {}) {
-    const data = quando.toLocaleString('pt-BR', { dateStyle: 'long', timeStyle: 'short' });
-    const linhas = [`# Conversa${projeto ? ` em ${projeto}` : ''}`, '', `_${data} · exportada pelo PrimoCode_`, ''];
-    for (const m of historico || []) {
-        if (!QUEM[m.role]) continue;   // ferramenta e sistema ficam de fora: é a conversa, não o log
-        const texto = typeof m.content === 'string' ? m.content : JSON.stringify(m.content || '');
-        linhas.push(`## ${QUEM[m.role]}`, '', mascarar(texto).trim(), '');
-    }
-    return linhas.join('\n');
-}
-
-function gravar(historico, { projeto = '', quando = new Date(), raiz = path.join(os.homedir(), 'primocode', 'conversas') } = {}) {
-    const p2 = (n) => String(n).padStart(2, '0');
-    const carimbo = `${quando.getFullYear()}-${p2(quando.getMonth() + 1)}-${p2(quando.getDate())}-${p2(quando.getHours())}${p2(quando.getMinutes())}`;
-    const nome = `${(projeto || 'conversa').toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '') || 'conversa'}-${carimbo}.md`;
-    fs.mkdirSync(raiz, { recursive: true });
-    const arq = path.join(raiz, nome);
-    fs.writeFileSync(arq, montarMd(historico, { projeto, quando }));
-    return arq;
-}
-
-module.exports = { mascarar, montarMd, gravar };

package/lib/headless.js

@@ -1,102 +0,0 @@
-/**
- * headless.js — `primocode -p "pedido"`: sem tela, para script e CI.
- *
- *   primocode -p "arruma o teste"                 texto no stdout
- *   primocode -p "..." --output-format json       um JSON no fim: {type, is_error, result, duration_ms}
- *   git diff | primocode -p "revisa isso"         o stdin entra no pedido
- *   primocode -p "..." --permission-mode plan     só lê (ver lib/perigo.js)
- *
- * Mesma ideia do `claude -p` e do `codex exec` (flags documentadas deles; o
- * código é nosso). O pedido passa pelo MESMO caminho do digitado (sendPrompt).
- * Código de saída: 0 ok, 1 erro.
- */
-'use strict';
-
-const path = require('path');
-const { stripAnsi } = require('./ui');
-
-const FORMATOS = ['text', 'json'];
-
-/** Tira -p/--print, --output-format e --permission-mode dos argumentos. */
-function analisar(argv) {
-    const r = { ativo: false, formato: 'text', permissao: null, resto: [], erro: null };
-    for (let i = 0; i < argv.length; i++) {
-        const a = argv[i];
-        const [chave, valor] = a.startsWith('--') && a.includes('=') ? [a.slice(0, a.indexOf('=')), a.slice(a.indexOf('=') + 1)] : [a, null];
-        if (a === '-p' || a === '--print') r.ativo = true;
-        else if (chave === '--output-format') {
-            const v = valor !== null ? valor : argv[++i];
-            if (!FORMATOS.includes(v)) r.erro = `--output-format aceita ${FORMATOS.join(' ou ')}`;
-            else r.formato = v;
-        } else if (chave === '--permission-mode') r.permissao = valor !== null ? valor : argv[++i];
-        else r.resto.push(a);
-    }
-    return r;
-}
-
-/** O pedido: os argumentos soltos, mais o stdin (que vem depois, como contexto). */
-function montarPedido(palavras, stdin) {
-    const pedido = palavras.join(' ').trim();
-    const extra = String(stdin || '').trim();
-    if (pedido && extra) return `${pedido}\n\n${extra}`;
-    return pedido || extra;
-}
-
-function lerStdin() {
-    if (process.stdin.isTTY) return Promise.resolve('');
-    return new Promise((resolve) => {
-        let s = '';
-        process.stdin.setEncoding('utf8');
-        process.stdin.on('data', (d) => { s += d; });
-        process.stdin.on('end', () => resolve(s));
-        process.stdin.on('error', () => resolve(s));
-    });
-}
-
-/** Roda `fn` guardando tudo o que ela escreve. `calar` esconde da tela. */
-async function capturar(fn, { calar = false } = {}) {
-    const log = console.log;
-    const escrever = process.stdout.write.bind(process.stdout);
-    let texto = '';
-    const pega = (s) => { texto += stripAnsi(s); };
-    console.log = (...a) => { pega(a.join(' ') + '\n'); if (!calar) log(...a); };
-    process.stdout.write = (s, ...resto) => { pega(typeof s === 'string' ? s : Buffer.from(s).toString()); return calar ? true : escrever(s, ...resto); };
-    try { await fn(); } finally { console.log = log; process.stdout.write = escrever; }
-    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) });
-}
-
-/* A última resposta do agente como ele escreveu (markdown cru), sem o que o terminal desenha em volta. */
-function ultimaResposta(historico, desde = 0) {
-    for (let i = (historico || []).length - 1; i >= desde; i--) {
-        const m = historico[i];
-        if (!m || m.role !== 'assistant') continue;
-        const t = typeof m.content === 'string' ? m.content
-            : Array.isArray(m.content) ? m.content.map((p) => (typeof p === 'string' ? p : (p && p.type === 'text' && p.text) || '')).join('\n') : '';
-        if (t.trim()) return t.trim();
-    }
-    return null;
-}
-
-module.exports = { analisar, montarPedido, lerStdin, capturar, resultadoJson, ultimaResposta, pastaDoScript, FORMATOS };

package/lib/kits-parecidos.js

@@ -1,99 +0,0 @@
-/**
- * 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 };