primocode 10.19.0 → 11.1.0

package/lib/local/provedor.js

@@ -1,169 +0,0 @@
-/**
- * provedor.js — a chave da própria pessoa, e com qual IA ela fala.
- *
- *   "Fica batendo no limite. Coloca um comando /provider onde você seleciona
- *    se é Gemini, ChatGPT etc., cola a key e ela roda local com a key
- *    configurada." (23/09/2026)
- *
- * Com um provedor configurado (/api), o agente fala DIRETO com a API dele, daqui da
- * máquina (lib/local/motor.js). O servidor e a cota compartilhada saem do
- * caminho: o limite passa a ser o da conta da pessoa.
- *
- * ── ONDE A CHAVE MORA ────────────────────────────────────────────────────
- * Em `~/.primocode/provedor.json`, permissão 600. Não no config.json: esse é
- * o arquivo que alguém abre para conferir um ajuste ou cola num chamado.
- *
- * ── O QUE NUNCA APARECE ──────────────────────────────────────────────────
- * A chave inteira — nem ao listar, nem num erro. Mostra-se o começo e o fim,
- * o bastante para reconhecer qual é.
- *
- * Todos falam o formato de chat da OpenAI (/chat/completions, tools, stream):
- * é o que Gemini, Claude, Groq, OpenRouter e DeepSeek aceitam também. Um
- * cliente só, e o provedor é só o endereço, o modelo e a chave.
- */
-
-'use strict';
-
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-
-const ARQUIVO = () => path.join(os.homedir(), '.primocode', 'provedor.json');
-
-/* A ordem é a do menu. `modelos` é a preferência: ao colar a chave, fica o
-   primeiro que a conta da pessoa de fato tem (a lista vem da própria API). */
-const PROVEDORES = {
-    /* Sem chave: a assinatura que a pessoa já tem na ferramenta de fora, que
-       roda escondida como cérebro (lib/local/motor-cli.js). */
-    'claude-code': {
-        nome: 'Claude Code',
-        cli: true,
-        modelos: ['opus'],
-        onde: 'https://docs.claude.com/claude-code',
-        dica: 'sua assinatura do Claude, sem chave',
-    },
-    codex: {
-        nome: 'Codex',
-        cli: true,
-        modelos: [''],
-        onde: 'https://github.com/openai/codex',
-        dica: 'sua assinatura do ChatGPT, sem chave',
-    },
-    gemini: {
-        nome: 'Gemini (Google)',
-        base: 'https://generativelanguage.googleapis.com/v1beta/openai',
-        modelos: ['gemini-2.5-flash', 'gemini-2.5-pro', 'gemini-2.0-flash'],
-        onde: 'https://aistudio.google.com/apikey',
-        dica: 'tem plano grátis',
-    },
-    chatgpt: {
-        nome: 'ChatGPT (OpenAI)',
-        base: 'https://api.openai.com/v1',
-        modelos: ['gpt-5-mini', 'gpt-5', 'gpt-4.1-mini', 'gpt-4o-mini'],
-        onde: 'https://platform.openai.com/api-keys',
-        dica: 'pago por uso',
-    },
-    claude: {
-        nome: 'Claude (Anthropic)',
-        base: 'https://api.anthropic.com/v1',
-        modelos: ['claude-sonnet-5', 'claude-haiku-4-5-20251001', 'claude-opus-5-5'],
-        onde: 'https://console.anthropic.com/settings/keys',
-        dica: 'pago por uso',
-    },
-    groq: {
-        nome: 'Groq',
-        base: 'https://api.groq.com/openai/v1',
-        modelos: ['openai/gpt-oss-120b', 'llama-3.3-70b-versatile', 'openai/gpt-oss-20b'],
-        onde: 'https://console.groq.com/keys',
-        dica: 'tem plano grátis, muito rápido',
-    },
-    openrouter: {
-        nome: 'OpenRouter',
-        base: 'https://openrouter.ai/api/v1',
-        modelos: ['openai/gpt-oss-120b', 'google/gemini-2.5-flash', 'anthropic/claude-sonnet-5'],
-        onde: 'https://openrouter.ai/keys',
-        dica: 'vários modelos numa chave só',
-    },
-    deepseek: {
-        nome: 'DeepSeek',
-        base: 'https://api.deepseek.com/v1',
-        modelos: ['deepseek-chat'],
-        onde: 'https://platform.deepseek.com/api_keys',
-        dica: 'barato',
-    },
-};
-
-/** A chave, irreconhecível para quem olha por cima do ombro. */
-function mascarar(chave) {
-    const k = String(chave || '');
-    if (k.length <= 10) return '••••';
-    return `${k.slice(0, 4)}…${k.slice(-4)}`;
-}
-
-let cache = null;
-let cacheMtime = 0;
-
-/** O provedor configurado, ou null (= segue pelo servidor, como sempre). */
-function atual() {
-    if (process.env.PRIMOCODE_SEM_PROVEDOR === '1') return null;
-    let st;
-    try { st = fs.statSync(ARQUIVO()); } catch { cache = null; return null; }
-    if (cache && st.mtimeMs === cacheMtime) return cache;
-    try {
-        const j = JSON.parse(fs.readFileSync(ARQUIVO(), 'utf8'));
-        const p = PROVEDORES[j.provedor];
-        cache = p && (j.chave || p.cli)
-            ? { id: j.provedor, nome: p.nome, cli: !!p.cli, base: j.base || p.base, modelo: j.modelo || p.modelos[0], chave: j.chave || '' }
-            : null;
-    } catch { cache = null; }
-    cacheMtime = st.mtimeMs;
-    return cache;
-}
-
-function salvar({ provedor, chave, modelo }) {
-    if (!PROVEDORES[provedor]) throw new Error(`provedor desconhecido: ${provedor}`);
-    const arq = ARQUIVO();
-    fs.mkdirSync(path.dirname(arq), { recursive: true });
-    fs.writeFileSync(arq, JSON.stringify({ provedor, chave: String(chave || '').trim(), modelo }, null, 2), { mode: 0o600 });
-    try { fs.chmodSync(arq, 0o600); } catch { /* Windows */ }
-    cache = null;
-    return atual();
-}
-
-function trocarModelo(modelo) {
-    const a = atual();
-    if (!a) return null;
-    return salvar({ provedor: a.id, chave: a.chave, modelo });
-}
-
-function desligar() {
-    try { fs.unlinkSync(ARQUIVO()); } catch { /* já não havia */ }
-    cache = null;
-}
-
-/** A chave colada serve? Pergunta a lista de modelos à própria API. */
-async function conferir(provedor, chave, { buscar = fetch } = {}) {
-    const p = PROVEDORES[provedor];
-    let r;
-    try {
-        r = await buscar(`${p.base}/models`, {
-            headers: { Authorization: `Bearer ${String(chave).trim()}` },
-            signal: AbortSignal.timeout(15000),
-        });
-    } catch (e) {
-        return { ok: false, error: `não consegui falar com ${p.nome}: ${e.message}` };
-    }
-    if (r.status === 401 || r.status === 403) return { ok: false, error: `${p.nome} recusou a chave (${r.status}). Confira se copiou inteira.` };
-    if (!r.ok) return { ok: false, error: `${p.nome} respondeu ${r.status} ao conferir a chave.` };
-    let lista = [];
-    try {
-        const j = await r.json();
-        lista = (j.data || j.models || []).map((m) => String(m.id || m.name || '').replace(/^models\//, '')).filter(Boolean);
-    } catch { /* sem lista: fica a preferência */ }
-    // Nenhum da preferência na lista (ou lista vazia): fica o primeiro dela, e
-    // `/api modelo <nome>` troca.
-    const modelo = p.modelos.find((m) => lista.includes(m)) || p.modelos[0];
-    return { ok: true, modelo, disponiveis: lista };
-}
-
-module.exports = { PROVEDORES, ARQUIVO, mascarar, atual, salvar, trocarModelo, desligar, conferir };

package/lib/marca-kit.js

@@ -1,312 +0,0 @@
-/**
- * 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': {
-            // O plano limita quantos kits se guarda (grátis 1): diz o porquê antes de perguntar qualquer coisa.
-            const lim = await (deps && deps.cabeMais ? deps.cabeMais(listar().length) : require('./limites.js').cabeMais('kitsMarca', listar().length));
-            if (!lim.ok) { dizer(lim.error); return 1; }
-            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 };

package/lib/marketplace.js

@@ -1,189 +0,0 @@
-/**
- * marketplace.js — a tela das skills, navegável pelas setas.
- *
- *   "/marketplace abre uma tela navegável no terminal, com navegação pelas
- *    setas, seções (uma delas é a seção de Skills) e rolagem para baixo. O
- *    usuário navega, ativa e instala skills ali. Dentro do marketplace existe
- *    a opção 'New Skill': seleciona com as setas, dá Enter, e o terminal pede
- *    em sequência o nome e o conteúdo da skill."
- *
- * ── O DESENHO É FUNÇÃO PURA, DE NOVO ─────────────────────────────────────
- * `montar()` recebe um estado e devolve linhas. `andar()` recebe uma tecla e
- * devolve o estado seguinte. Nenhuma das duas toca no terminal nem no disco.
- *
- * É o mesmo desenho do `/effort` e da caixa de digitar, e pelo mesmo motivo:
- * uma tela de terminal que só existe enquanto alguém aperta seta é uma tela
- * que ninguém consegue testar. Assim o teste percorre a lista inteira, abre e
- * fecha seção, rola até o fim e confere o que apareceu — sem nada na tela.
- *
- * ── POR QUE A LISTA É PLANA POR DENTRO ───────────────────────────────────
- * A tela tem seções, mas a navegação é UMA lista: título de seção é item que
- * não se escolhe, e a seta pula por cima dele. Tentar navegar em árvore (seta
- * para entrar, outra para sair) é o tipo de coisa que exige explicação — e
- * uma tela que precisa de manual não serve para quem abriu o terminal para
- * fazer outra coisa.
- *
- * ── O QUE ESTE MARKETPLACE NÃO É ─────────────────────────────────────────
- * Não há loja na internet. O catálogo é o que vem no produto mais o que
- * estiver instalado na máquina, e é isso que a tela mostra — sem inventar um
- * "1.248 skills disponíveis" que não existe. O dia em que existir um índice
- * remoto, ele entra como mais uma seção.
- */
-
-'use strict';
-
-const { c, truncate, padRight, visibleWidth } = require('./ui.js');
-
-// ── o estado ─────────────────────────────────────────────────────────────
-
-/**
- * @param {Array} skills  o que `skills.listar()` devolveu
- */
-function novo(skills) {
-    // A seleção nasce no primeiro item ESCOLHÍVEL, não no zero — o zero é um
-    // título de seção, e uma tela que abre sem nada marcado parece travada.
-    const base = { skills: skills || [], sel: 0, topo: 0, saiu: null };
-    const lista = itens(base);
-    base.sel = escolhivel(lista[0]) ? 0 : proximo(lista, 0, 1);
-    return base;
-}
-
-/**
- * A lista plana: cabeçalhos de seção e itens, na ordem em que aparecem.
- *
- * Cada item diz o que é e o que fazer com ele. A tela e as teclas leem daqui,
- * então não existe a chance de uma delas achar que o terceiro item é outro.
- */
-function itens(estado) {
-    const lista = [];
-    const ligadas = estado.skills.filter((s) => s.ligada);
-    const desligadas = estado.skills.filter((s) => !s.ligada);
-
-    lista.push({ tipo: 'secao', texto: 'Skills ativas', conta: ligadas.length });
-    if (!ligadas.length) lista.push({ tipo: 'vazio', texto: 'nenhuma ativa' });
-    for (const s of ligadas) lista.push({ tipo: 'skill', skill: s });
-
-    lista.push({ tipo: 'secao', texto: 'Desligadas', conta: desligadas.length });
-    if (!desligadas.length) lista.push({ tipo: 'vazio', texto: 'nenhuma desligada' });
-    for (const s of desligadas) lista.push({ tipo: 'skill', skill: s });
-
-    lista.push({ tipo: 'secao', texto: 'Criar' });
-    lista.push({ tipo: 'nova', texto: 'New Skill', detalhe: 'escreva a sua — o nome e o prompt' });
-    lista.push({ tipo: 'instalar', texto: 'Instalar de um arquivo', detalhe: 'um SKILL.md que você tem no disco' });
-
-    return lista;
-}
-
-/** Dá para parar em cima deste item? Título de seção e vazio, não. */
-const escolhivel = (item) => item && item.tipo !== 'secao' && item.tipo !== 'vazio';
-
-/** O primeiro item escolhível a partir de `de`, andando em `passo`. */
-function proximo(lista, de, passo) {
-    let i = de;
-    for (let n = 0; n < lista.length; n++) {
-        i += passo;
-        if (i < 0) i = lista.length - 1;
-        if (i >= lista.length) i = 0;
-        if (escolhivel(lista[i])) return i;
-    }
-    return de;
-}
-
-/**
- * Uma tecla → o estado seguinte.
- *
- * Devolve `{ estado, acao }`. A ação é o que o mundo lá fora precisa fazer —
- * ligar uma skill, abrir o diálogo de criar, sair. Este módulo não faz nada
- * disso: ele não sabe gravar arquivo nem perguntar nada.
- */
-function andar(estado, tecla, { altura = 14 } = {}) {
-    const lista = itens(estado);
-    const e = { ...estado };
-
-    // O primeiro pouso: se a seleção caiu num título, desce até um item.
-    if (!escolhivel(lista[e.sel])) e.sel = proximo(lista, e.sel, 1);
-
-    const nome = (tecla && tecla.name) || '';
-
-    if (nome === 'down' || nome === 'j') e.sel = proximo(lista, e.sel, 1);
-    else if (nome === 'up' || nome === 'k') e.sel = proximo(lista, e.sel, -1);
-    else if (nome === 'pagedown') { for (let i = 0; i < 5; i++) e.sel = proximo(lista, e.sel, 1); }
-    else if (nome === 'pageup') { for (let i = 0; i < 5; i++) e.sel = proximo(lista, e.sel, -1); }
-    else if (nome === 'home') { e.sel = proximo(lista, lista.length - 1, 1); }
-    else if (nome === 'end') { e.sel = proximo(lista, 0, -1); }
-    else if (nome === 'escape' || nome === 'q') return { estado: { ...e, saiu: 'fechar' }, acao: { tipo: 'fechar' } };
-    else if (nome === 'return' || nome === 'enter' || (tecla && tecla.sequence === ' ')) {
-        const item = lista[e.sel];
-        if (!item) return { estado: e, acao: null };
-        if (item.tipo === 'skill') {
-            return { estado: e, acao: { tipo: 'alternar', skill: item.skill } };
-        }
-        if (item.tipo === 'nova') return { estado: { ...e, saiu: 'nova' }, acao: { tipo: 'nova' } };
-        if (item.tipo === 'instalar') return { estado: { ...e, saiu: 'instalar' }, acao: { tipo: 'instalar' } };
-    }
-
-    // A janela acompanha a seleção: sem isto, descer faz o item escolhido
-    // sumir embaixo e a seta parece ter parado de funcionar.
-    const visiveis = Math.max(4, altura);
-    if (e.sel < e.topo) e.topo = e.sel;
-    if (e.sel >= e.topo + visiveis) e.topo = e.sel - visiveis + 1;
-    e.topo = Math.max(0, Math.min(e.topo, Math.max(0, lista.length - visiveis)));
-
-    return { estado: e, acao: null };
-}
-
-// ── o desenho ────────────────────────────────────────────────────────────
-
-function montar(estado, { colunas = 80, altura = 14 } = {}) {
-    const larg = Math.max(40, Math.min(colunas - 1, 110));
-    const lista = itens(estado);
-    const visiveis = Math.max(4, altura);
-    const topo = Math.max(0, Math.min(estado.topo || 0, Math.max(0, lista.length - visiveis)));
-
-    const out = [];
-    out.push('');
-    out.push('  ' + c.bold(c.brand('Marketplace')) + c.dim('  ·  as skills do Primo Code'));
-    out.push('  ' + c.dim('─'.repeat(larg - 4)));
-
-    for (let i = topo; i < Math.min(lista.length, topo + visiveis); i++) {
-        const item = lista[i];
-        const escolhido = i === estado.sel;
-        const seta = escolhido ? c.brand('❯ ') : '  ';
-
-        if (item.tipo === 'secao') {
-            // Linha em branco antes da seção, menos na primeira: é o que
-            // separa os grupos sem precisar de moldura.
-            if (out.length > 3) out.push('');
-            out.push('  ' + c.bold(c.white(item.texto))
-                + (item.conta != null ? c.dim(`  ${item.conta}`) : ''));
-            continue;
-        }
-        if (item.tipo === 'vazio') { out.push('    ' + c.dim(item.texto)); continue; }
-
-        if (item.tipo === 'skill') {
-            const s = item.skill;
-            const marca = s.ligada ? c.ok('●') : c.dim('○');
-            const titulo = escolhido ? c.bold(c.white(s.titulo)) : c.white(s.titulo);
-            const selo = s.doProduto ? c.dim('  do produto') : c.brandDim('  sua');
-            out.push('  ' + seta + marca + ' ' + truncate(titulo + selo, larg - 8));
-            // A descrição só aparece no que está selecionado: com ela em
-            // todas, a lista dobra de altura e ninguém lê nenhuma.
-            if (escolhido && s.descricao) {
-                out.push('      ' + c.dim(truncate(s.descricao, larg - 8)));
-            }
-            continue;
-        }
-
-        const titulo = escolhido ? c.bold(c.brand(item.texto)) : c.brandDim(item.texto);
-        out.push('  ' + seta + titulo);
-        if (escolhido && item.detalhe) out.push('      ' + c.dim(item.detalhe));
-    }
-
-    out.push('');
-    out.push('  ' + c.dim('─'.repeat(larg - 4)));
-    out.push('  ' + c.dim('↑↓ navega · Enter liga e desliga · Esc fecha'));
-    out.push('');
-    return out.join('\n');
-}
-
-module.exports = { novo, itens, andar, montar, escolhivel, proximo };