primocode 10.13.0 → 10.14.1

package/lib/headless.js

@@ -0,0 +1,71 @@
+/**
+ * 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 { 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();
+}
+
+function resultadoJson({ texto, erro, inicio, permissao }) {
+    return JSON.stringify({ type: 'result', is_error: !!erro, result: erro ? String(erro) : texto, duration_ms: Date.now() - inicio, permission_mode: permissao || 'auto' });
+}
+
+module.exports = { analisar, montarPedido, lerStdin, capturar, resultadoJson, FORMATOS };

package/lib/hooks.js

@@ -0,0 +1,72 @@
+/**
+ * hooks.js — comandos seus que rodam ANTES e DEPOIS de cada ferramenta.
+ *
+ * Arquivo: ~/.primocode/hooks.json (vale em tudo) e <projeto>/.primocode/hooks.json:
+ *
+ *   { "PreToolUse":  [{ "matcher": "run_shell|write_file", "command": "./checar.sh" }],
+ *     "PostToolUse": [{ "matcher": "write_file|edit_file", "command": "npx prettier --write ." }] }
+ *
+ * O comando recebe o evento em JSON no stdin ({evento, ferramenta, argumentos,
+ * resultado, pasta}). No PreToolUse, sair com código 2 BLOQUEIA a ferramenta e o
+ * stderr vira o motivo que o agente lê. Qualquer outro código só avisa. Sem
+ * `matcher`, vale para toda ferramenta. O contrato é o mesmo dos hooks
+ * documentados do Claude Code (code.claude.com/docs/en/hooks); o código é nosso.
+ */
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const EVENTOS = ['PreToolUse', 'PostToolUse'];
+const PRAZO_MS = 10000;
+
+function ler(arquivo) {
+    try {
+        const j = JSON.parse(fs.readFileSync(arquivo, 'utf8'));
+        return j && typeof j === 'object' ? j : {};
+    } catch { return {}; }
+}
+
+/** Os hooks de um evento: os da casa primeiro, depois os do projeto. */
+function carregar(evento, projectDir) {
+    const arquivos = [path.join(os.homedir(), '.primocode', 'hooks.json')];
+    if (projectDir) arquivos.push(path.join(projectDir, '.primocode', 'hooks.json'));
+    const out = [];
+    for (const a of arquivos) {
+        const lista = ler(a)[evento];
+        if (!Array.isArray(lista)) continue;
+        for (const h of lista) if (h && typeof h.command === 'string' && h.command.trim()) out.push(h);
+    }
+    return out;
+}
+
+function casa(matcher, nome) {
+    if (!matcher || matcher === '*') return true;
+    try { return new RegExp(`^(?:${matcher})$`).test(nome); } catch { return false; }
+}
+
+/**
+ * Roda os hooks do evento. Devolve { bloqueado, motivo, avisos[] }.
+ * Só o PreToolUse bloqueia.
+ */
+function rodar(evento, { nome, args, resultado, projectDir }) {
+    const saida = { bloqueado: false, motivo: '', avisos: [] };
+    if (!EVENTOS.includes(evento)) return saida;
+    const entrada = JSON.stringify({ evento, ferramenta: nome, argumentos: args || {}, resultado, pasta: projectDir });
+    for (const h of carregar(evento, projectDir)) {
+        if (!casa(h.matcher, nome)) continue;
+        const r = spawnSync(h.command, { shell: true, input: entrada, cwd: projectDir || process.cwd(), encoding: 'utf8', timeout: h.timeout ? h.timeout * 1000 : PRAZO_MS });
+        const err = String(r.stderr || '').trim();
+        if (evento === 'PreToolUse' && r.status === 2) {
+            saida.bloqueado = true;
+            saida.motivo = err || `bloqueado pelo hook: ${h.command}`;
+            return saida;
+        }
+        if (r.error || r.status !== 0) saida.avisos.push(`hook "${h.command.slice(0, 40)}" ${r.error ? 'falhou: ' + r.error.message : 'saiu com ' + r.status}${err ? ' — ' + err.slice(0, 120) : ''}`);
+    }
+    return saida;
+}
+
+module.exports = { EVENTOS, carregar, casa, rodar };

package/lib/limites.js

@@ -0,0 +1,100 @@
+/**
+ * limites.js — o que o plano libera, aplicado de verdade na CLI.
+ *
+ * A tabela mora em server/lib/planos.js; o servidor responde o plano da pessoa
+ * em POST /api/video/cota (recursos + o catálogo enxuto). Aqui ficam:
+ *   - situacao(): o plano agora, guardado 5 min na memória do processo;
+ *   - o MODO LOCAL generoso (sem rede, servidor mudo ou campo que o servidor
+ *     ainda não manda): nada é barrado. Errar para o lado de quem trabalha;
+ *   - bloqueio(): a mensagem curta e honesta — o quê, em que plano você está,
+ *     qual plano libera e o comando para assinar. Nunca barra sem dizer o porquê.
+ */
+
+'use strict';
+
+const GENEROSO = { videosMes: 0, resolucao: 2160, marcaDagua: false, narracaoPremium: true, clubeCompleto: true,
+    scriptsAE: true, prioridade: 0, subagentes: 7, kitsMarca: 0, versoesEditor: 0 };
+const MAX_PARALELO = 8;
+const VALIDADE = 5 * 60000;
+
+let cache = null;
+const avisos = [];
+
+/** Completa o que o servidor não mandou com o generoso (campo novo, servidor velho). */
+function completar(c) {
+    const r = { ...GENEROSO };
+    for (const [k, v] of Object.entries((c && c.recursos) || {})) if (v !== undefined && v !== null) r[k] = v;
+    return { ...(c || {}), recursos: r };
+}
+
+function guardar(c) { cache = { em: Date.now(), c: completar(c) }; }
+function esquecer() { cache = null; }
+
+/** Nos testes (node test/x.test.js) ninguém bate no servidor de verdade: vale o modo local. */
+const emTeste = () => /\.test\.m?js$/.test(String(process.argv[1] || '')) || process.env.PRIMOCODE_LIMITES === 'local';
+
+/** O plano agora: {plano, recursos, planos, offline}. Nunca lança. */
+async function situacao(deps = {}) {
+    if (cache && Date.now() - cache.em < VALIDADE) return cache.c;
+    if (emTeste() && !deps.consultar) return completar(require('./estudio/cota.js').LOCAL);
+    let c;
+    try { c = await (deps.consultar || require('./estudio/cota.js').consultar)('checar'); } catch { c = require('./estudio/cota.js').LOCAL; }
+    guardar(c);
+    return cache.c;
+}
+const recursos = async (deps) => (await situacao(deps)).recursos;
+
+const reais = (n) => `R$ ${Number(n).toFixed(2).replace('.', ',')}`;
+
+/* Cada recurso: o que o plano ganha ao passar, e o texto de quando bate. */
+const RECURSOS = {
+    narracaoPremium: { de: (r) => !!r.narracaoPremium, texto: 'A narração premium (voz do Gemini)', libera: 'a narração premium' },
+    clubeCompleto: { de: (r) => !!r.clubeCompleto, texto: 'A receita completa do Clube (etapas e prompt)', libera: 'as receitas completas do Clube' },
+    scriptsAE: { de: (r) => !!r.scriptsAE, texto: 'Os scripts de After Effects modelo', libera: 'os scripts de After Effects modelo' },
+    kitsMarca: { n: (r) => r.kitsMarca, texto: (r) => `Você já tem ${r.kitsMarca} kit${r.kitsMarca > 1 ? 's' : ''} de marca, o limite do plano`, libera: (r) => (r.kitsMarca ? `${r.kitsMarca} kits de marca` : 'kits de marca sem teto') },
+    versoesEditor: { n: (r) => r.versoesEditor, texto: (r) => `Este vídeo já tem ${r.versoesEditor} edições, o limite do plano`, libera: (r) => (r.versoesEditor ? `${r.versoesEditor} edições por vídeo` : 'edições sem teto') },
+    subagentes: { n: (r) => r.subagentes + 1, texto: (r) => `Seu plano roda ${r.subagentes + 1} subagente${r.subagentes ? 's juntos' : ' por vez'}`, libera: (r) => (r.subagentes ? `${r.subagentes + 1} subagentes juntos` : 'subagentes em paralelo') },
+};
+
+/** O primeiro plano acima do atual que libera `chave` (ou null). */
+function quemLibera(chave, c) {
+    const def = RECURSOS[chave], lista = c.planos || [];
+    const i = lista.findIndex((p) => p.id === c.plano);
+    return lista.slice(i + 1).find((p) => (def.de ? def.de(p.recursos) : (def.n(p.recursos) === 0 || def.n(p.recursos) > def.n(c.recursos)))) || null;
+}
+
+/** A mensagem de limite: curta, com o motivo, o degrau que libera e o comando. */
+function bloqueio(chave, c) {
+    const def = RECURSOS[chave], r = c.recursos;
+    const nome = ((c.planos || []).find((p) => p.id === c.plano) || {}).nome || c.plano;
+    const p = quemLibera(chave, c);
+    const texto = typeof def.texto === 'function' ? def.texto(r) : `${def.texto} não vêm no plano ${nome}`;
+    const libera = typeof def.libera === 'function' ? def.libera(p ? p.recursos : r) : def.libera;
+    return `${texto} (plano ${nome}).`
+        + (p ? ` O ${p.nome} (${reais(p.preco)}/mês) libera ${libera}.` : '')
+        + ' Veja e assine: primocode planos (ou primocode.web.app/planos).';
+}
+
+/** Libera o que é só ligado/desligado. {ok:true} ou {ok:false, error}. */
+async function exigir(chave, deps) {
+    const c = await situacao(deps);
+    return RECURSOS[chave].de(c.recursos) ? { ok: true } : { ok: false, error: bloqueio(chave, c) };
+}
+
+/** Limite numérico: `usados` já é o que existe; passa se o teto é 0 (sem teto) ou se ainda cabe mais um. */
+async function cabeMais(chave, usados, deps) {
+    const c = await situacao(deps), teto = RECURSOS[chave].n(c.recursos);
+    return !teto || usados < teto ? { ok: true } : { ok: false, error: bloqueio(chave, c) };
+}
+
+/** Quantos subagentes rodam juntos na mesma rodada (o principal fica de fora). */
+async function paralelo(deps) {
+    const c = await situacao(deps);
+    return { max: Math.min(MAX_PARALELO, c.recursos.subagentes + 1), aviso: (n) => (n > c.recursos.subagentes + 1 ? bloqueio('subagentes', c) : null) };
+}
+
+/** Avisos que o resultado da ferramenta leva ao fim da vez (ex.: narração premium trocada pela local). */
+function avisar(msg) { if (msg && !avisos.includes(msg)) avisos.push(msg); }
+function pegarAvisos() { return avisos.splice(0); }
+
+module.exports = { GENEROSO, MAX_PARALELO, situacao, recursos, guardar, esquecer, completar, bloqueio, quemLibera, exigir, cabeMais, paralelo, avisar, pegarAvisos, RECURSOS };