primocode 10.13.0 → 10.14.0

package/lib/local/entrada.js

@@ -88,6 +88,13 @@ const GRUPOS = [
         tools: ['estudio_video'],
         gatilho: /\b(grava[çc][ãa]o|gravei|filmagem|filmei|meu v[íi]deo|edit\w* (o |a |meu |minha |esse |essa |este |esta )?(v[íi]deo|grava[çc][ãa]o)|\.mp4|\.mov|legendas?|cort(a|ar|e) (o )?sil[êe]ncio|recort(a|ar|e) (a )?pessoa|transcrev\w*|importa\w* (o )?v[íi]deo)\b/i,
     },
+    {
+        /* O motor After Effects só entra quando o pedido o chama: o esquema
+           dele pesa no teto do minuto e "faz um vídeo" não precisa dele. */
+        nome: 'after-effects',
+        tools: ['estudio_ae', 'estudio_motion', 'estudio_editar'],
+        gatilho: /\b(after ?effects?|aftereffects|\bae\b|effectcraft|extendscript|\.jsx|keyframes?|express[ãa]o do ae|motion( design| graphics?)?|an[uú]ncio animado|vinheta|reels?|estudio_motion|estudio_editar|editor de v[íi]deo|pr[ée]via|deixa mais (r[áa]pido|lento)|tira a m[úu]sica|troca (o|a) (t[íi]tulo|cor|fonte|m[úu]sica))\b/i,
+    },
     {
         nome: 'navegador',
         tools: ['browser_open', 'browser_click', 'browser_type', 'browser_key',
@@ -154,7 +161,7 @@ const GRUPOS = [
            ASSUNTO (o que costuma ter partes) e pelo TAMANHO (ver `ehGrande`). */
         nome: 'delegar',
         tools: ['spawn_agent'],
-        gatilho: /\b(v[áa]rios|v[áa]rias|todos os|todas as|em paralelo|projeto inteiro|refator\w*|migra[çc][ãa]o|auditor\w*|e tamb[ée]m|e depois|al[ée]m disso|sistema|plataforma|complet[oa]|backend|frontend|front e back|full.?stack|testes|telas|m[óo]dulos|camadas|arquivos|crud|api e|app|aplicativo|site)\b/i,
+        gatilho: /\b(v[áa]rios|v[áa]rias|todos os|todas as|em paralelo|projeto inteiro|refator\w*|migra[çc][ãa]o|auditor\w*|e tamb[ée]m|e depois|al[ée]m disso|sistema|plataforma|complet[oa]|backend|frontend|front e back|full.?stack|testes|telas|m[óo]dulos|camadas|arquivos|crud|api e)\b/i,   // sem "site", "app", "aplicativo": casavam com quase todo pedido (13/10)
     },
     {
         nome: 'terminal',
@@ -189,7 +196,14 @@ function gruposDe(texto, forcar = []) {
     // Pedido grande delega mesmo sem a palavra certa. E quem pode construir
     // um app inteiro também pode dividir: as duas saídas vão juntas, e a
     // seção de delegar diz quando é cada uma.
-    if (ehGrande(t) || escolhidos.has('pipeline')) escolhidos.add('delegar');
+    /* O TIME SÓ EM PEDIDO GRANDE (13/10: "como fazer a cota não acabar?").
+       "Faz um site de portfólio" ganhava o construir_app e o spawn_agent, e o
+       modelo os usava: 22 chamadas, 6 de subagente, para um site de uma página.
+       Cada subagente é mais pedidos na cota grátis. Pedido pequeno: um agente. */
+    const grande = ehGrande(t);
+    if (!grande) escolhidos.delete('pipeline');
+    // O spawn_agent segue o gatilho dele (backend e frontend, várias telas…); o pedido grande também o ganha.
+    if (grande) escolhidos.add('delegar');
     // Antes de clicar, o MCP: quem vai mexer no navegador ou no desktop leva os conectores.
     if (escolhidos.has('navegador') || escolhidos.has('computador')) escolhidos.add('mcp');
     return escolhidos;
@@ -348,11 +362,27 @@ function referenciasProtegidas(messages) {
     return new Set(ultima.values());
 }
 
+/* O QUE FOI FEITO NÃO SOME (13/10: "continua lendo e listando coisas
+   desnecessárias"). Com ~1.900 tokens de conversa, as leituras velhas saíam
+   inteiras e o modelo, sem saber que já tinha lido, lia de novo. Agora o
+   resultado encurtado diz o que era, e a rodada descartada vira uma linha no
+   pedido: "você já fez isto, não repita". */
+const LEITURAS = new Set(['read_file', 'list_dir', 'glob', 'grep']);
+function chamadaCurta(tc) {
+    const f = (tc && tc.function) || {};
+    let a = {};
+    try { a = JSON.parse(f.arguments || '{}'); } catch { /* argumento ilegível */ }
+    const alvo = a.path || a.pattern || a.query || a.command || a.id || '';
+    return `${f.name || '?'}${alvo ? ' ' + String(alvo).slice(0, 50) : ''}`;
+}
+
 function caberNoTeto(messages, sobra) {
     const conta = (m) => tokensDe(m);
     if (conta(messages) <= sobra) return { messages, cortou: false };
 
     let atual = messages.map((m) => ({ ...m }));
+    const chamadaDe = new Map();
+    for (const m of atual) if (m.role === 'assistant' && Array.isArray(m.tool_calls)) for (const tc of m.tool_calls) chamadaDe.set(tc.id, tc);
 
     // 1 e 2: encurtar resultados antigos, em dois apertos.
     const protegidas = referenciasProtegidas(atual);
@@ -369,6 +399,11 @@ function caberNoTeto(messages, sobra) {
             }
             if (m.role !== 'tool' || manterInteiros.has(i)) return m;
             if (texto.length <= limite) return m;
+            const tc = chamadaDe.get(m.tool_call_id);
+            if (tc && LEITURAS.has((tc.function || {}).name)) {
+                const linhas = texto.split('\n').length;
+                return { ...m, content: `[já lido: ${chamadaCurta(tc)}, ${linhas} linhas — saiu daqui para caber no plano. Não leia de novo; releia só se for editar ESTE arquivo agora.]` };
+            }
             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' };
@@ -390,6 +425,15 @@ function caberNoTeto(messages, sobra) {
         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;
+        // A rodada sai, o rastro fica: uma linha no último pedido antes dela.
+        const feitas = (atual[primeiroAssistente].tool_calls || []).map(chamadaCurta);
+        let u = primeiroAssistente - 1;
+        while (u >= 0 && atual[u].role !== 'user') u--;
+        if (u >= 0 && feitas.length && typeof atual[u].content === 'string') {
+            const marca = '\n\n[você já fez, e saiu da conversa para caber no plano: ';
+            const c = atual[u].content;
+            atual[u] = { ...atual[u], content: c.includes(marca) ? c.replace(/\. Não repita\.\]\s*$/, '; ' + feitas.join('; ') + '. Não repita.]') : c + marca + feitas.join('; ') + '. Não repita.]' };
+        }
         atual = [...atual.slice(0, primeiroAssistente), ...atual.slice(fim)];
     }
 

package/lib/marca-kit.js

@@ -0,0 +1,309 @@
+/**
+ * marca-kit.js — o KIT DE MARCA: a pessoa cria uma vez, todo vídeo e site usa.
+ *
+ *   ~/.primocode/marcas/<nome>/marca.json   nome, cores {fundo,destaque,tinta,apoio},
+ *                                           fontes {titulo,texto} (Google Fonts), tom, slogan,
+ *                                           site, redes, assinatura (motion preferida, opcional)
+ *   ~/.primocode/marcas/<nome>/logo.png|svg
+ *   ~/.primocode/marcas/.ativa              nome do kit ativo (global)
+ *   <projeto>/.primocode/marca              fixa o kit naquela pasta (ganha do global)
+ *
+ * Comandos: `primocode marca criar|listar|usar <nome> [aqui]|mostrar|apagar <nome>` e `/marca`.
+ * O Estúdio chama `preencher(marca, {pastas})`: o kit entra por baixo, o que o
+ * roteiro já trouxe ganha, campo a campo.
+ */
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const PAPEIS = ['fundo', 'destaque', 'tinta', 'apoio'];
+
+function raiz() { return process.env.PRIMOCODE_MARCAS || path.join(os.homedir(), '.primocode', 'marcas'); }
+
+function slug(nome) {
+    return String(nome || '').normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 40);
+}
+const hexOk = (h) => /^#[0-9a-f]{6}$/i.test(String(h || ''));
+function normHex(h) {
+    let s = String(h || '').trim();
+    if (/^[0-9a-f]{3}$/i.test(s)) s = '#' + s;
+    if (/^#[0-9a-f]{3}$/i.test(s)) s = '#' + s.slice(1).split('').map((x) => x + x).join('');
+    if (/^[0-9a-f]{6}$/i.test(s)) s = '#' + s;
+    return hexOk(s) ? s.toLowerCase() : null;
+}
+
+// ── contraste (WCAG) ─────────────────────────────────────────────────────
+function rgb(h) { const n = parseInt(h.slice(1), 16); return [n >> 16, (n >> 8) & 255, n & 255]; }
+function luz(h) {
+    const [r, g, b] = rgb(h).map((v) => { v /= 255; return v <= 0.03928 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4); });
+    return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+}
+function contraste(a, b) {
+    const [x, y] = [luz(a), luz(b)].sort((p, q) => q - p);
+    return (x + 0.05) / (y + 0.05);
+}
+function misturar(a, b, t) {
+    const A = rgb(a), B = rgb(b);
+    return '#' + A.map((v, i) => Math.round(v + (B[i] - v) * t).toString(16).padStart(2, '0')).join('');
+}
+/** A cor mais perto de `cor` que passa de `min` sobre `fundo` (clareia ou escurece em direção ao extremo que contrasta). */
+function ajustar(cor, fundo, min = 4.5) {
+    const alvo = luz(fundo) > 0.18 ? '#000000' : '#ffffff';
+    for (let t = 0.05; t <= 1.001; t += 0.05) {
+        const c = misturar(cor, alvo, t);
+        if (contraste(c, fundo) >= min) return c;
+    }
+    return alvo;
+}
+/** Confere tinta×fundo e destaque×fundo. Devolve [{par, razao, ok, sugestao}]. */
+function validarContraste(cores = {}, min = 4.5) {
+    const out = [];
+    for (const [par, k] of [['tinta×fundo', 'tinta'], ['destaque×fundo', 'destaque']]) {
+        if (!hexOk(cores[k]) || !hexOk(cores.fundo)) continue;
+        const razao = Math.round(contraste(cores[k], cores.fundo) * 100) / 100;
+        const ok = razao >= min;
+        out.push({ par, razao, ok, ...(ok ? {} : { sugestao: { [k]: ajustar(cores[k], cores.fundo, min) } }) });
+    }
+    return out;
+}
+
+// ── disco ────────────────────────────────────────────────────────────────
+function pastaDe(nome) { const s = slug(nome); return s ? path.join(raiz(), s) : null; }
+function ler(nome) {
+    const p = pastaDe(nome);
+    if (!p) return null;
+    try {
+        const m = JSON.parse(fs.readFileSync(path.join(p, 'marca.json'), 'utf8'));
+        const logo = ['logo.svg', 'logo.png'].map((f) => path.join(p, f)).find((f) => fs.existsSync(f));
+        return { ...m, ...(logo ? { logo } : {}), _pasta: p };
+    } catch { return null; }
+}
+function listar() {
+    try {
+        return fs.readdirSync(raiz(), { withFileTypes: true }).filter((d) => d.isDirectory())
+            .map((d) => ler(d.name)).filter(Boolean);
+    } catch { return []; }
+}
+function validar(m) {
+    const erros = [];
+    if (!m || !String(m.nome || '').trim()) erros.push('falta o nome.');
+    for (const k of PAPEIS) if (m.cores && m.cores[k] && !hexOk(m.cores[k])) erros.push(`cor ${k} inválida: ${m.cores[k]}`);
+    return erros;
+}
+/** Grava o kit. `logoArquivo` (opcional) é copiado para logo.png|svg. */
+function salvar(m, { logoArquivo } = {}) {
+    const erros = validar(m);
+    if (erros.length) return { ok: false, error: erros.join(' ') };
+    const p = pastaDe(m.nome);
+    if (!p) return { ok: false, error: 'o nome não serve de pasta.' };
+    fs.mkdirSync(p, { recursive: true });
+    const { logo, _pasta, ...dados } = m;
+    fs.writeFileSync(path.join(p, 'marca.json'), JSON.stringify({ ...dados, criada: dados.criada || new Date().toISOString() }, null, 2) + '\n');
+    if (logoArquivo && fs.existsSync(logoArquivo)) {
+        const ext = /\.svg$/i.test(logoArquivo) ? '.svg' : '.png';
+        for (const e of ['.svg', '.png']) try { fs.unlinkSync(path.join(p, 'logo' + e)); } catch { /* não havia */ }
+        fs.copyFileSync(logoArquivo, path.join(p, 'logo' + ext));
+    }
+    return { ok: true, pasta: p, kit: ler(m.nome) };
+}
+function apagar(nome) {
+    const p = pastaDe(nome);
+    if (!p || !fs.existsSync(path.join(p, 'marca.json'))) return { ok: false, error: `não há kit "${nome}".` };
+    fs.rmSync(p, { recursive: true, force: true });
+    if (ativaGlobal() === slug(nome)) try { fs.unlinkSync(path.join(raiz(), '.ativa')); } catch { /* ok */ }
+    return { ok: true };
+}
+
+// ── ativa: pino do projeto ganha da global ────────────────────────────────
+function ativaGlobal() { try { return fs.readFileSync(path.join(raiz(), '.ativa'), 'utf8').trim() || null; } catch { return null; } }
+function usar(nome, { aqui = null } = {}) {
+    const k = ler(nome);
+    if (!k) return { ok: false, error: `não há kit "${nome}". Veja: primocode marca listar` };
+    if (aqui) {
+        fs.mkdirSync(path.join(aqui, '.primocode'), { recursive: true });
+        fs.writeFileSync(path.join(aqui, '.primocode', 'marca'), slug(nome) + '\n');
+        return { ok: true, kit: k, onde: 'projeto' };
+    }
+    fs.mkdirSync(raiz(), { recursive: true });
+    fs.writeFileSync(path.join(raiz(), '.ativa'), slug(nome) + '\n');
+    return { ok: true, kit: k, onde: 'global' };
+}
+function fixadaEm(pasta) {
+    let d = pasta ? path.resolve(pasta) : null;
+    for (let i = 0; d && i < 6; i++) {
+        try { const n = fs.readFileSync(path.join(d, '.primocode', 'marca'), 'utf8').trim(); if (n) return n; } catch { /* sobe */ }
+        const pai = path.dirname(d);
+        if (pai === d) break;
+        d = pai;
+    }
+    return null;
+}
+/** O kit em vigor: pino do primeiro `pastas` que tiver, senão a global. */
+function ativa(pastas = []) {
+    for (const p of [].concat(pastas).filter(Boolean)) {
+        const n = fixadaEm(p);
+        if (n) { const k = ler(n); if (k) return k; }
+    }
+    const g = ativaGlobal();
+    return g ? ler(g) : null;
+}
+
+/**
+ * O gancho do Estúdio: preenche a `marca` do JSON com o kit, campo a campo
+ * (o que a pessoa/roteiro já pôs ganha). Sem kit ativo, devolve a marca intacta.
+ */
+function preencher(marca, { pastas = [] } = {}) {
+    const k = ativa(pastas);
+    if (!k) return marca;
+    const m = marca && typeof marca === 'object' ? marca : {};
+    const temCores = m.cores && (Array.isArray(m.cores) ? m.cores.length : Object.keys(m.cores).length);
+    const temFontes = m.fontes && (Array.isArray(m.fontes) ? m.fontes.length : Object.keys(m.fontes).length);
+    return {
+        ...m,
+        nome: m.nome || k.nome,
+        cores: temCores ? (Array.isArray(m.cores) ? m.cores : { ...(k.cores || {}), ...m.cores }) : { ...(k.cores || {}) },
+        fontes: temFontes ? (Array.isArray(m.fontes) ? m.fontes : { ...(k.fontes || {}), ...m.fontes }) : { ...(k.fontes || {}) },
+        ...(m.logo || k.logo ? { logo: m.logo || k.logo } : {}),
+        ...(k.slogan && !m.slogan ? { slogan: k.slogan } : {}),
+        ...(k.tom && !m.tom ? { tom: k.tom } : {}),
+        ...(k.assinatura && !m.assinatura ? { assinatura: k.assinatura } : {}),
+        kit: k.nome,
+    };
+}
+
+// ── do site: logo e cores com o que já existe ────────────────────────────
+async function doSite(entrada, { identidade = require('./estudio/identidade.js') } = {}) {
+    let url = String(entrada || '').trim();
+    if (!url) return { ok: false, error: 'sem site.' };
+    if (!/^https?:\/\//i.test(url)) {
+        if (!/\./.test(url)) { const a = await identidade.acharSite(url); if (!a || !a.ok) return { ok: false, error: (a && a.error) || 'não achei o site.' }; url = a.url || a.site; }
+        else url = 'https://' + url;
+    }
+    const r = await identidade.analisar(url);
+    if (!r.ok) return r;
+    const lista = ((r.cores && r.cores.marca) || []).map((x) => x.cor || x).filter(hexOk);
+    const todas = lista.length ? lista : ((r.cores && r.cores.todas) || []).map((x) => x.cor || x).filter(hexOk);
+    const cores = require('./estudio/marca.js').marcaEmObjeto({ cores: todas }).cores || {};
+    const f = r.fontes || {};
+    const nomes = [...(f.doGoogleFonts || []), ...(f.declaradas || []).map((x) => x.fonte)];
+    const unicas = [...new Set(nomes)];
+    const fontes = { ...(unicas[0] ? { titulo: unicas[0] } : {}), ...(unicas[0] ? { texto: unicas[1] || unicas[0] } : {}) };
+    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'marca-'));
+    let logoArquivo = null;
+    try {
+        const l = await identidade.pegarLogo(r.html || '', r.url, { pasta: tmp, nome: 'kit' });
+        if (l && l.ok && l.src) logoArquivo = path.join(tmp, l.src);
+    } catch { /* sem logo: a pessoa manda depois */ }
+    return { ok: true, url: r.url, nome: r.marca || '', slogan: r.descricao || '', cores, fontes, logoArquivo };
+}
+
+// ── criar (interativo curto) ─────────────────────────────────────────────
+/**
+ * `perguntar(texto, padrao) → Promise<string>` e `dizer(texto)` são injetáveis (teste).
+ * Fluxo: nome → site (opcional) → confirma cores/fonte/logo → contraste → grava.
+ */
+async function criar({ perguntar, dizer = console.log, deps = {} } = {}) {
+    const nome = String(await perguntar('Nome da marca', '')).trim();
+    if (!nome) return { ok: false, error: 'sem nome, sem kit.' };
+    const site = String(await perguntar('Site (opcional, Enter pula)', '')).trim();
+    let achado = { cores: {}, fontes: {}, logoArquivo: null, slogan: '' };
+    if (site) {
+        dizer('Lendo o site...');
+        const r = await doSite(site, deps);
+        if (r.ok) { achado = r; dizer(`Achei: ${Object.entries(r.cores).map(([k, v]) => `${k} ${v}`).join(' · ') || 'sem cores'}${r.fontes.titulo ? ` · fonte ${r.fontes.titulo}` : ''}${r.logoArquivo ? ' · logo' : ' · sem logo'}`); }
+        else dizer(`Não deu pra ler o site (${r.error}). Sigo com o que você disser.`);
+    }
+    const cores = {};
+    for (const k of PAPEIS) {
+        const padrao = achado.cores[k] || (k === 'fundo' ? '#0b0b0f' : k === 'tinta' ? '#f5f5f5' : k === 'destaque' ? '#ff5a1f' : '');
+        const v = normHex(await perguntar(`Cor ${k}${k === 'apoio' ? ' (opcional)' : ''}`, padrao));
+        if (v) cores[k] = v;
+    }
+    let sugeriu = [];
+    for (let volta = 0; volta < 2; volta++) {
+        const ruins = validarContraste(cores).filter((x) => !x.ok);
+        if (!ruins.length) break;
+        for (const x of ruins) {
+            const [k, v] = Object.entries(x.sugestao)[0];
+            dizer(`Contraste baixo em ${x.par}: ${x.razao} (o mínimo é 4,5). Sugiro ${k} ${v}.`);
+            const ok = /^(s|sim|y|yes|)$/i.test(String(await perguntar(`Trocar ${k} por ${v}? (s/n)`, 's')).trim());
+            if (ok) { cores[k] = v; sugeriu.push(k); }
+        }
+    }
+    const titulo = String(await perguntar('Fonte do título (Google Fonts)', achado.fontes.titulo || '')).trim();
+    const texto = String(await perguntar('Fonte do texto (Google Fonts)', achado.fontes.texto || titulo)).trim();
+    const slogan = String(await perguntar('Slogan (opcional)', '')).trim();
+    const tom = String(await perguntar('Tom de voz (opcional, ex.: direto e simpático)', '')).trim();
+    const redes = String(await perguntar('@redes (opcional)', '')).trim();
+    let logoArquivo = achado.logoArquivo;
+    if (!logoArquivo) {
+        const l = String(await perguntar('Arquivo do logo (png/svg, opcional)', '')).trim().replace(/^~(?=\/)/, os.homedir());
+        if (l && fs.existsSync(l)) logoArquivo = l; else if (l) dizer('Não achei esse arquivo; fica sem logo.');
+    }
+    const r = salvar({
+        nome, cores,
+        ...((titulo || texto) ? { fontes: { ...(titulo ? { titulo } : {}), ...(texto ? { texto } : {}) } } : {}),
+        ...(slogan ? { slogan } : {}), ...(tom ? { tom } : {}), ...(site ? { site } : {}), ...(redes ? { redes: redes.split(/[\s,]+/).filter(Boolean) } : {}),
+    }, { logoArquivo });
+    if (r.ok) r.contraste = validarContraste(cores);
+    return r;
+}
+
+// ── texto e CLI ──────────────────────────────────────────────────────────
+function mostrar(k) {
+    if (!k) return 'Nenhum kit ativo. Crie um: primocode marca criar';
+    const c = k.cores || {}, f = k.fontes || {};
+    const lin = [`Marca: ${k.nome}`,
+        `  cores   ${PAPEIS.filter((p) => c[p]).map((p) => `${p} ${c[p]}`).join(' · ') || '-'}`,
+        `  fontes  ${f.titulo || '-'} / ${f.texto || '-'}`,
+        `  logo    ${k.logo || '-'}`];
+    for (const [r, v] of [['slogan', k.slogan], ['tom', k.tom], ['site', k.site], ['redes', (k.redes || []).join(' ')], ['motion', k.assinatura]]) if (v) lin.push(`  ${r.padEnd(7)} ${v}`);
+    const ruins = validarContraste(c).filter((x) => !x.ok);
+    for (const x of ruins) lin.push(`  ! contraste ${x.par} ${x.razao} (< 4,5)`);
+    return lin.join('\n');
+}
+function tela(lista, ativaNome) {
+    return lista.length ? lista.map((k) => `${slug(k.nome) === ativaNome ? '●' : ' '} ${k.nome}${k.site ? '  ' + k.site : ''}`).join('\n') : 'Nenhum kit ainda. Crie um: primocode marca criar';
+}
+
+function perguntarNoTerminal() {
+    const rl = require('readline').createInterface({ input: process.stdin, output: process.stdout });
+    const ask = (t, p) => new Promise((res) => rl.question(`${t}${p ? ` [${p}]` : ''}: `, (a) => res(a.trim() || p || '')));
+    return { ask, fechar: () => rl.close() };
+}
+
+/** `primocode marca <op>`; o /marca da sessão chama o mesmo, com `perguntar` próprio. */
+async function main(argv, { perguntar, dizer = console.log, pasta = process.cwd(), deps } = {}) {
+    const [op = 'mostrar', ...resto] = argv;
+    const nome = resto.filter((x) => x !== 'aqui').join(' ').trim();
+    const aqui = resto.includes('aqui');
+    switch (op) {
+        case 'criar': {
+            const t = perguntar ? null : perguntarNoTerminal();
+            try {
+                const r = await criar({ perguntar: perguntar || t.ask, dizer, deps });
+                if (!r.ok) { dizer(r.error); return 1; }
+                dizer(`Kit "${r.kit.nome}" salvo em ${r.pasta}. Ativar: primocode marca usar ${r.kit.nome}`);
+                return 0;
+            } finally { if (t) t.fechar(); }
+        }
+        case 'listar': case 'ls': dizer(tela(listar(), ativaGlobal())); return 0;
+        case 'usar': {
+            if (!nome) { dizer('Qual? primocode marca usar <nome> [aqui]'); return 1; }
+            const r = usar(nome, { aqui: aqui ? pasta : null });
+            dizer(r.ok ? `Marca "${r.kit.nome}" ${r.onde === 'projeto' ? 'fixada nesta pasta' : 'ativa'}.` : r.error);
+            return r.ok ? 0 : 1;
+        }
+        case 'mostrar': case 'ver': dizer(mostrar(nome ? ler(nome) : ativa([pasta]))); return 0;
+        case 'apagar': case 'rm': {
+            if (!nome) { dizer('Qual? primocode marca apagar <nome>'); return 1; }
+            const r = apagar(nome);
+            dizer(r.ok ? `Kit "${nome}" apagado.` : r.error);
+            return r.ok ? 0 : 1;
+        }
+        default: dizer('Uso: primocode marca criar | listar | usar <nome> [aqui] | mostrar [nome] | apagar <nome>'); return 1;
+    }
+}
+
+module.exports = { raiz, slug, normHex, contraste, ajustar, validarContraste, ler, listar, salvar, apagar, usar, ativa, fixadaEm, preencher, doSite, criar, mostrar, main };