primocode 9.8.0-beta.0 → 9.8.0-beta.2

package/lib/local/entrada.js

@@ -0,0 +1,332 @@
+/**
+ * orcamento-entrada.js — o que ENTRA no pedido, e quanto isso custa.
+ *
+ * ── O NÚMERO QUE MOTIVOU ESTE ARQUIVO ────────────────────────────────────
+ * Medido no servidor, com o pedido VAZIO — antes de o usuário digitar
+ * qualquer coisa:
+ *
+ *     schema das 45 ferramentas ....... 4.326 tokens
+ *     prompt do sistema ............... 2.365 tokens
+ *     ────────────────────────────────────────────
+ *     piso de qualquer pedido ......... 6.691 tokens
+ *     teto do plano grátis ............ 6.000 tokens por minuto
+ *
+ * Ou seja: TODO pedido do modo primocode já nascia estourado. Não era a
+ * conversa que crescia demais — era o custo fixo que não cabia. O usuário via
+ * "a conversa passou do teto" no meio de uma tarefa e não tinha o que encurtar.
+ *
+ * ── A IDEIA ──────────────────────────────────────────────────────────────
+ * Ninguém precisa das 45 ferramentas para fazer um slide. Quem pede um vídeo
+ * não usa `desktop_click`; quem conserta um bug não usa `studio_criar`. Então
+ * cada pedido leva só o que aquele pedido pode usar — ferramentas E seções do
+ * prompt — e o que sobra do orçamento vira espaço para a conversa.
+ *
+ * O núcleo (ler, escrever, procurar, rodar, terminar) vai SEMPRE: é o que
+ * qualquer tarefa usa, e adivinhar errado aqui custaria a tarefa inteira.
+ *
+ * Puro de propósito: sem I/O e sem rede, para o teste medir o orçamento sem
+ * chave de API nenhuma.
+ */
+
+'use strict';
+
+/**
+ * A MESMA conta do orcamento.js — e isso não era verdade antes.
+ *
+ * Aqui era 4 caracteres por token e lá 2,6. Para o mesmo prompt e as mesmas
+ * ferramentas as duas discordavam em 2.070 tokens, e quem decidia o orçamento
+ * de entrada era a conta OTIMISTA: achava que 3.844 cabiam em 5.200 quando o
+ * custo real era ~5.900. JSON de schema é o pior caso — pontuação, aspas e
+ * identificador curto tokenizam muito pior que texto corrido.
+ */
+const CHARS_POR_TOKEN = 2.6;
+function tokensDe(x) {
+    const texto = typeof x === 'string' ? x : JSON.stringify(x || '');
+    return Math.ceil(texto.length / CHARS_POR_TOKEN);
+}
+
+/**
+ * O mesmo schema, com a descrição cortada na primeira frase.
+ *
+ * A primeira frase é a que diz o que a tool FAZ; o resto é conselho de uso,
+ * que também está no prompt. Num teto apertado isso vale 768 tokens (3.130 ->
+ * 2.362) sem tirar nenhuma ferramenta da mão do agente — e ferramenta a menos
+ * é tarefa que não sai.
+ */
+function enxugarSchema(tools) {
+    return (tools || []).map((t) => {
+        const d = t && t.function && t.function.description;
+        if (!d) return t;
+        const primeira = String(d).split(/(?<=\.)\s/)[0].slice(0, 160);
+        if (primeira.length >= String(d).length) return t;
+        return { ...t, function: { ...t.function, description: primeira } };
+    });
+}
+
+// ── Os grupos ────────────────────────────────────────────────────────────
+// `sempre: true` é o núcleo — vai em todo pedido, sem discussão.
+const GRUPOS = [
+    {
+        nome: 'nucleo',
+        sempre: true,
+        tools: ['write_file', 'edit_file', 'multi_edit', 'read_file', 'list_dir',
+            'glob', 'grep', 'run_shell', 'write_todos', 'finish'],
+    },
+    {
+        nome: 'estudio',
+        tools: ['studio_manual', 'studio_spec', 'studio_criar', 'studio_ler',
+            'studio_atualizar', 'studio_versoes', 'studio_listar', 'studio_midia'],
+        // O que o estúdio produz, e os apps que ele substitui.
+        gatilho: /\b(slides?|apresenta[çc][ãa]o|deck|v[íi]deo|reels?|anima[çc][ãa]o|post|banner|capa|thumbnail|arte|cartaz|logo|planilha|tabela|or[çc]amento|documento|relat[óo]rio|artigo|proposta|contrato|diagrama|fluxograma|organograma|mapa mental|narra[çc][ãa]o|trilha|est[úu]dio|canva|powerpoint|keynote|word|docs|excel|sheets|photoshop|figma|capcut|premiere|miro)\b/i,
+    },
+    {
+        nome: 'navegador',
+        tools: ['browser_open', 'browser_click', 'browser_type', 'browser_key',
+            'browser_read', 'browser_screenshot', 'browser_scroll', 'browser_wait',
+            'browser_eval', 'open_in_browser'],
+        gatilho: /\b(site|p[áa]gina|navegador|browser|chrome|url|https?:|www\.|link|formul[áa]rio|login|clicar no bot[ãa]o|testar? (a p[áa]gina|no navegador)|pesquis|busca|internet|not[íi]cia|empresa|mercado)\b/i,
+    },
+    {
+        nome: 'computador',
+        tools: ['desktop_open_app', 'desktop_windows', 'desktop_focus', 'desktop_elements',
+            'desktop_click_element', 'desktop_click', 'desktop_double_click', 'desktop_move',
+            'desktop_drag', 'desktop_type', 'desktop_key', 'desktop_scroll', 'desktop_size',
+            'desktop_screenshot'],
+        // Só quando a tarefa é MESMO no computador. É o grupo mais caro
+        // (1.141 tokens) e o menos usado no dia a dia.
+        gatilho: /\b(janela|[áa]rea de trabalho|desktop|abrir? o (app|programa|aplicativo)|clica(r)? (na tela|no [íi]cone)|[íi]cone|mouse|teclado|atalho|print da tela|screenshot|alt\+tab|ctrl\+|bloco de notas|calculadora|explorer|finder)\b/i,
+    },
+    {
+        nome: 'pesquisa',
+        tools: ['pesquisar_referencia'],
+        gatilho: /\b(pesquis|busca|procur|internet|documenta[çc][ãa]o|refer[êe]ncia|empresa|mercado|not[íi]cia|quem [ée]|sobre a |sobre o |dados de|hist[óo]ria d)\b/i,
+    },
+    {
+        /* O PIPELINE DE QUATRO PAPÉIS, e ele é caro de duas formas: o schema
+           dele é longo, e chamá-lo custa seis a oito agentes. Por isso o
+           gatilho pede o PAR — um verbo de construir colado num substantivo de
+           coisa inteira. "Melhore o site" e "conserte o app" não passam de
+           propósito: o pipeline constrói do zero, e mandá-lo mexer no que já
+           existe é pagar oito agentes para refazer o que estava pronto. */
+        nome: 'pipeline',
+        tools: ['construir_app'],
+        gatilho: /\b(fa[çc]a|fa[çc]er|faz|cria|crie|criar|monta|monte|montar|constr[óo]i|construa|construir|desenvolv[ae]|quero|preciso de)\b[^.!?]{0,24}\b(app|aplicativo|site|p[áa]gina|landing|jogo|game|ferramenta|dashboard|painel|calculadora|sistema|portf[óo]lio|loja|formul[áa]rio|cron[ôo]metro|agenda|lista de tarefas|to-?do)\b/i,
+    },
+    {
+        /* O ARQUIVO do vídeo. Quem pede "faz um vídeo" recebe o link e o
+           botão de baixar; a ferramenta que gera o mp4 sem clique só entra
+           quando o pedido fala do arquivo — é o que mantém o pedido de vídeo
+           dentro do teto do minuto (medido: ela custa ~180 tokens). */
+        nome: 'exportar',
+        tools: ['studio_exportar'],
+        gatilho: /\b(mp4|webm|baix[ae]r?|download|exporta\w*|salv[ae]r? (o )?v[íi]deo|arquivo (do|de) v[íi]deo|me manda o v[íi]deo|manda o arquivo|renderiza\w*)\b/i,
+    },
+    {
+        nome: 'delegar',
+        tools: ['spawn_agent'],
+        // Delegar só compensa em tarefa grande; em pedido curto é peso morto.
+        gatilho: /\b(v[áa]rios|v[áa]rias|todos os|todas as|em paralelo|projeto inteiro|refator|migra[çc][ãa]o|auditor)\b/i,
+    },
+    {
+        nome: 'terminal',
+        tools: ['run_in_new_terminal'],
+        gatilho: /\b(servidor|dev|watch|npm run|yarn|vite|next|rodar? em segundo plano|localhost|porta \d+)\b/i,
+    },
+    {
+        // Sem tool nova — só a seção de prompt com as regras de qualidade de
+        // código. Nasceu de reclamação real do dono: "ele faz coisas
+        // horríveis em relação a código". As regras custam ~200 tokens e só
+        // entram quando a tarefa É de código.
+        nome: 'codigo',
+        tools: [],
+        gatilho: /\b(c[óo]digo|app|site|jogo|fun[çc][ãa]o|bug|erro|script|html|css|javascript|typescript|python|node|api|backend|frontend|componente|refator|classe|m[óo]dulo|landing)\b/i,
+    },
+];
+
+/**
+ * Quais grupos esta tarefa pode usar.
+ *
+ * Olha o pedido do usuário — não a conversa inteira: o que o modelo escreveu
+ * no meio do caminho não deve mudar o que ele pode usar depois. `forcar`
+ * existe para o que já foi decidido fora daqui (o esforço alto sempre pesquisa).
+ */
+function gruposDe(texto, forcar = []) {
+    const t = String(texto || '');
+    const escolhidos = new Set(['nucleo', ...forcar]);
+    for (const g of GRUPOS) {
+        if (g.sempre) { escolhidos.add(g.nome); continue; }
+        if (g.gatilho && g.gatilho.test(t)) escolhidos.add(g.nome);
+    }
+    return escolhidos;
+}
+
+/** As ferramentas dos grupos escolhidos, na ordem original da lista. */
+function escolherFerramentas(todas, texto, opts = {}) {
+    const grupos = gruposDe(texto, opts.forcar);
+    const permitidas = new Set();
+    for (const g of GRUPOS) {
+        if (grupos.has(g.nome)) for (const t of g.tools) permitidas.add(t);
+    }
+    const escolhidas = (todas || []).filter((t) => permitidas.has(t.function && t.function.name));
+    // Rede de segurança: se a seleção falhar (nome novo que ninguém mapeou),
+    // é melhor mandar tudo do que mandar um agente sem ferramenta.
+    return escolhidas.length >= 5 ? escolhidas : todas;
+}
+
+/**
+ * O que a conversa mostra que o agente JÁ APRENDEU.
+ *
+ * A seção "O ESTÚDIO" do prompt ensina o que a spec entrega — e a spec, quando
+ * já foi lida, está inteira na conversa. Manter as duas é pagar duas vezes
+ * pelo mesmo ensinamento, e são 1.113 tokens que fazem falta justamente na
+ * hora de escrever o documento.
+ *
+ * O mesmo vale para pesquisa: com as fontes já lidas, o texto sobre COMO
+ * pesquisar não muda mais nada.
+ */
+function jaAprendeu(messages) {
+    const nomePorId = new Map();
+    for (const m of messages || []) {
+        for (const tc of (m && m.tool_calls) || []) {
+            nomePorId.set(tc.id, (tc.function && tc.function.name) || tc.name);
+        }
+    }
+    const feitas = new Set();
+    for (const m of messages || []) {
+        if (m && m.role === 'tool' && nomePorId.has(m.tool_call_id)) feitas.add(nomePorId.get(m.tool_call_id));
+    }
+    const dispensaveis = new Set();
+    if (feitas.has('studio_spec') || feitas.has('studio_manual')) dispensaveis.add('estudio');
+    if (feitas.has('pesquisar_referencia')) dispensaveis.add('pesquisa');
+    return dispensaveis;
+}
+
+/**
+ * O prompt, montado só com as seções que a tarefa usa.
+ *
+ * `secoes` é { nome: texto }. O núcleo entra sempre; as outras entram quando o
+ * grupo correspondente entrou.
+ */
+function montarPrompt(nucleo, secoes, texto, opts = {}) {
+    const grupos = gruposDe(texto, opts.forcar);
+    const dispensaveis = opts.jaAprendeu || new Set();
+    const partes = [nucleo];
+    for (const [nome, corpo] of Object.entries(secoes || {})) {
+        if (grupos.has(nome) && corpo && !dispensaveis.has(nome)) partes.push(corpo);
+    }
+    return partes.join('\n\n');
+}
+
+/**
+ * O relatório do que este pedido vai custar, para o servidor registrar e para
+ * o teste provar que a economia existe.
+ */
+function relatorio({ prompt, ferramentas, messages }) {
+    const p = tokensDe(prompt);
+    const f = tokensDe(ferramentas);
+    const m = tokensDe(messages);
+    return { prompt: p, ferramentas: f, conversa: m, total: p + f + m, tools: (ferramentas || []).length };
+}
+
+/**
+ * Faz a CONVERSA caber no que sobrou do orçamento.
+ *
+ * A seleção de ferramentas resolve o custo fixo; isto resolve o variável. Numa
+ * tarefa de pesquisa o histórico cresce rápido (cada página lida são milhares
+ * de caracteres), e sem um teto ela volta a estourar no meio do trabalho —
+ * justamente depois de todo o esforço já gasto.
+ *
+ * Ordem das concessões, da menos dolorosa para a mais:
+ *   1. encurta os resultados de tool ANTIGOS (os novos são os que importam);
+ *   2. encurta mais ainda, se preciso;
+ *   3. em último caso, descarta as rodadas mais VELHAS — sempre o par
+ *      inteiro (o turno do assistente com tool_calls + as respostas dele),
+ *      porque a API recusa um role:'tool' órfão.
+ *
+ * O pedido do usuário e a última rodada nunca são descartados: sem eles o
+ * modelo não sabe mais o que estava fazendo.
+ */
+// Tools cuja resposta é DOCUMENTO FIXO e que o agente precisa ter em mãos na
+// hora de escrever. Encolher isto é o que criou o loop original: sem o formato,
+// o modelo pede a spec de novo, e de novo.
+//
+// O CLI já protege as mesmas mensagens antes de mandar (lib/repeticao.js), mas
+// quem falava por último aqui era `caberNoTeto`, que não sabia disso e cortava
+// assim mesmo. Dois compactadores brigando, e o do servidor ganhava.
+const REFERENCIAS = new Set(['studio_manual', 'studio_spec']);
+
+// Referência tem teto GENEROSO, não infinito.
+//
+// Proteger a spec inteira parecia certo — sem o formato o agente não escreve o
+// documento — mas a spec do `corte` são 3.270 tokens, e com o prompt e as 17
+// tools isso dá 7.126: estoura o minuto SOZINHO, e nenhum corte na conversa
+// resolve. Protegida demais, ela deixava de caber. O começo do documento é o
+// formato (que o agente precisa); o fim são exemplos e opções avançadas.
+const LIMITE_REFERENCIA = 3500;
+
+/** Os índices de role:'tool' que não podem encolher: a cópia mais nova de cada referência. */
+function referenciasProtegidas(messages) {
+    const nomePorId = new Map();
+    for (const m of messages || []) {
+        for (const tc of (m && m.tool_calls) || []) {
+            nomePorId.set(tc.id, (tc.function && tc.function.name) || tc.name);
+        }
+    }
+    const ultima = new Map();
+    (messages || []).forEach((m, i) => {
+        if (!m || m.role !== 'tool') return;
+        const nome = nomePorId.get(m.tool_call_id);
+        if (REFERENCIAS.has(nome)) ultima.set(nome, i);
+    });
+    return new Set(ultima.values());
+}
+
+function caberNoTeto(messages, sobra) {
+    const conta = (m) => tokensDe(m);
+    if (conta(messages) <= sobra) return { messages, cortou: false };
+
+    let atual = messages.map((m) => ({ ...m }));
+
+    // 1 e 2: encurtar resultados antigos, em dois apertos.
+    const protegidas = referenciasProtegidas(atual);
+    for (const limite of [400, 120]) {
+        const indices = atual.map((m, i) => (m.role === 'tool' ? i : -1)).filter((i) => i >= 0);
+        const manterInteiros = new Set(indices.slice(-2));
+        atual = atual.map((m, i) => {
+            const texto = String(m.content || '');
+            // Referência: teto próprio, muito maior que o dos outros — o
+            // formato vem no começo do documento.
+            if (protegidas.has(i)) {
+                if (texto.length <= LIMITE_REFERENCIA) return m;
+                return { ...m, content: texto.slice(0, LIMITE_REFERENCIA) + '…(spec cortada no limite do plano; o formato essencial está acima)' };
+            }
+            if (m.role !== 'tool' || manterInteiros.has(i)) return m;
+            if (texto.length <= limite) return m;
+            return { ...m, content: texto.slice(0, limite) + '…(encurtado para caber no limite do plano)' };
+        });
+        if (conta(atual) <= sobra) return { messages: atual, cortou: true, como: 'encurtou resultados antigos' };
+    }
+
+    // 3: descartar as rodadas mais velhas, em pares completos.
+    while (conta(atual) > sobra) {
+        const aindaProtegidas = referenciasProtegidas(atual);
+        const primeiroAssistente = atual.findIndex((m, i) => {
+            if (!(m.role === 'assistant' && m.tool_calls)) return false;
+            // Descartar a rodada que trouxe a spec é recriar o loop original:
+            // sem o formato o agente pede a spec de novo, e de novo.
+            let f = i + 1;
+            while (f < atual.length && atual[f].role === 'tool') { if (aindaProtegidas.has(f)) return false; f++; }
+            return true;
+        });
+        if (primeiroAssistente === -1) break;
+        let fim = primeiroAssistente + 1;
+        while (fim < atual.length && atual[fim].role === 'tool') fim++;
+        // Nunca engolir tudo: para se sobrar só o pedido do usuário.
+        if (fim >= atual.length - 1) break;
+        atual = [...atual.slice(0, primeiroAssistente), ...atual.slice(fim)];
+    }
+
+    return { messages: atual, cortou: true, como: 'descartou as rodadas mais antigas' };
+}
+
+module.exports = { GRUPOS, CHARS_POR_TOKEN, REFERENCIAS, LIMITE_REFERENCIA, tokensDe, enxugarSchema, referenciasProtegidas, jaAprendeu, gruposDe, escolherFerramentas, montarPrompt, relatorio, caberNoTeto };

package/lib/local/motor-cli.js

@@ -0,0 +1,90 @@
+/**
+ * motor-cli.js — o Claude Code ou o Codex da pessoa como cérebro do PrimoCode.
+ *
+ *   "Coloca o /claude de novo, mas dentro do /api: aí coloca /claude e
+ *    /codex." (24/09/2026)
+ *
+ * Sem chave: usa a assinatura que a pessoa já tem nessas ferramentas. O
+ * agente (o loop, as ferramentas, a tela) continua sendo o do PrimoCode; a
+ * ferramenta de fora só decide o próximo passo, pelo protocolo de bloco
+ * marcado de lib/claude-engine.js (o Codex usa o mesmo).
+ *
+ * Os motores só sabem o `requestAct`. Chat e resumo, aqui, são uma pergunta
+ * de texto simples ao mesmo CLI; o plano não divide (uma ida a mais a um CLI
+ * lento custaria mais do que a divisão poupa) e segue em passo único.
+ */
+
+'use strict';
+
+const { execFileSync } = require('child_process');
+const cerebro = require('./cerebro.json');
+
+const SEM_APARECER = { stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true };
+
+function motorDe(id) {
+    if (id === 'codex') {
+        /* O padrão antigo do motor (gpt-5-mini) é recusado por conta de
+           assinatura do ChatGPT — medido: "o Codex não aceitou o modelo", e
+           uma segunda chamada em TODA rodada. Pelo /api, vai o modelo da
+           conta. Quem quiser outro ainda usa PRIMOCODE_CODEX_MODELO. */
+        if (process.env.PRIMOCODE_CODEX_MODELO === undefined) process.env.PRIMOCODE_CODEX_MODELO = '';
+        return require('../codex-engine.js');
+    }
+    return require('../claude-engine.js');
+}
+
+/** Uma pergunta de texto, resposta de texto. Sem protocolo, sem ferramenta. */
+function perguntar(id, texto) {
+    if (id === 'codex') return String(motorDe('codex').chamarCodex(texto) || '').trim();
+    const claude = motorDe('claude-code');
+    const saida = execFileSync('claude', ['-p', '--output-format', 'json', ...claude.argsDoModelo()], {
+        encoding: 'utf-8', timeout: 120000, input: texto, maxBuffer: 8 * 1024 * 1024, ...SEM_APARECER,
+    });
+    try { return String(JSON.parse(saida).result || '').trim(); } catch { return String(saida || '').trim(); }
+}
+
+function criar(id) {
+    const motor = motorDe(id);
+    return {
+        requestAct: (servidor, payload, emit) => motor.requestAct(servidor, payload, emit),
+
+        async requestChat(_servidor, { messages, prompt, history } = {}, emit) {
+            const turnos = Array.isArray(messages) ? messages
+                : [...(Array.isArray(history) ? history : []), ...(prompt ? [{ role: 'user', content: prompt }] : [])];
+            const conversa = turnos.filter((m) => m && m.role && typeof m.content === 'string')
+                .map((m) => `${m.role === 'user' ? 'PESSOA' : 'VOCÊ'}: ${m.content}`).join('\n');
+            try {
+                const resposta = perguntar(id, `${cerebro.SYSTEM_CHAT}\n\nResponda só à última fala da PESSOA.\n\n${conversa}`);
+                if (resposta) emit({ delta: resposta });
+            } catch (e) {
+                emit({ erro: e.message });
+            }
+            emit({ done: true });
+        },
+
+        async requestResumo(_servidor, { resumo, mensagens } = {}) {
+            const novas = (mensagens || []).filter((m) => m && m.role);
+            if (!novas.length) return { resumo: String(resumo || '') };
+            const corpo = (resumo ? `RESUMO ANTERIOR:\n${resumo}\n\n` : '') + 'MENSAGENS NOVAS:\n'
+                + novas.map((m) => `${m.role === 'user' ? 'USUÁRIO' : m.role === 'assistant' ? 'AGENTE' : 'FERRAMENTA'}: `
+                    + String(typeof m.content === 'string' ? m.content : JSON.stringify(m.content || '')).slice(0, 1200)).join('\n');
+            try {
+                return { resumo: perguntar(id, `${cerebro.SYSTEM_RESUMO}\n\n${corpo}`) || String(resumo || '') };
+            } catch (e) {
+                return { resumo: String(resumo || ''), erro: e.message };
+            }
+        },
+
+        async requestPlano(_servidor, { prompt } = {}) {
+            return { passos: [{ titulo: 'tarefa', pedido: String(prompt || '').trim() }], dividiu: false };
+        },
+    };
+}
+
+/** A ferramenta está instalada? (sem rodar nada caro) */
+function instalado(id) {
+    if (id === 'codex') return motorDe('codex').temCodex();
+    return motorDe('claude-code').temClaudeCode();
+}
+
+module.exports = { criar, instalado, perguntar };