primocode 8.38.0 → 8.39.0

package/lib/marca.js

@@ -0,0 +1,280 @@
+/**
+ * marca.js — a logo e a identidade visual de uma empresa, puxadas do site.
+ *
+ * Pedido do dono: "puxe a logo e identidade visual da empresa". O agente
+ * fazia peça de marca com `marca.cor` chutada e sem logo, ou pedia o arquivo
+ * ao usuário — e o usuário, que só disse "faz um vídeo para a Paris Group",
+ * não estava ali para mandar arquivo nenhum. O site da empresa TEM a logo,
+ * as cores e as fontes; é só ler como uma pessoa leria.
+ *
+ * ── O QUE SE LÊ, E EM QUE ORDEM ──────────────────────────────────────────
+ *   nome   og:site_name → <title> (sem o " | slogan")
+ *   frase  meta description / og:description (o "sobre" em uma linha)
+ *   logo   <img> com "logo" no src/alt/class (a de verdade, no cabeçalho) →
+ *          apple-touch-icon (180 px, o melhor ícone que todo site tem) →
+ *          og:image (é a imagem de compartilhar, às vezes é a logo, às vezes
+ *          uma foto — por isso vem por último) → favicon.
+ *          SVG ganha de PNG no mesmo lugar: escala sem borrar.
+ *   cores  meta theme-color primeiro (a empresa DISSE qual é a cor), depois
+ *          as cores mais repetidas no CSS (inline e nas folhas ligadas),
+ *          fora branco/preto/cinza — o que sobra é a paleta.
+ *   fontes os "family=" do Google Fonts e os font-family do CSS, fora as
+ *          genéricas (sans-serif, Arial, system-ui).
+ *
+ * A logo é BAIXADA para o projeto e ENVIADA ao estúdio: volta como
+ * "/midia/…", pronta para `marca.logo`. O resto volta como `marca` pronta
+ * para colar no documento.
+ *
+ * Zero dependências: o `pegar` do referencia.js (texto e binário), e o
+ * chute de domínio dele quando a pessoa deu só o nome.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const referencia = require('./referencia.js');
+
+const GENERICAS_FONTE = /^(sans-serif|serif|monospace|system-ui|-apple-system|blinkmacsystemfont|segoe ui|arial|helvetica( neue)?|roboto|inherit|initial|ui-sans-serif|ui-serif|ui-monospace|apple color emoji|segoe ui emoji|noto color emoji|times new roman|courier new|verdana|tahoma|georgia)$/i;
+
+function absoluta(href, base) {
+    try { return new URL(String(href || '').replace(/&amp;/g, '&'), base).href; } catch { return null; }
+}
+
+function atributo(tag, nome) {
+    const m = new RegExp(`\\b${nome}\\s*=\\s*("([^"]*)"|'([^']*)'|([^\\s>]+))`, 'i').exec(tag);
+    return m ? (m[2] != null ? m[2] : m[3] != null ? m[3] : m[4]) : null;
+}
+
+function metas(html) {
+    const saida = {};
+    for (const tag of html.match(/<meta\b[^>]*>/gi) || []) {
+        const chave = atributo(tag, 'property') || atributo(tag, 'name');
+        const valor = atributo(tag, 'content');
+        if (chave && valor && saida[chave.toLowerCase()] == null) saida[chave.toLowerCase()] = valor.trim();
+    }
+    return saida;
+}
+
+/** As candidatas a logo, da melhor para a pior. */
+function candidatasALogo(html, base) {
+    const lista = [];
+    // 1. <img> que se chama logo — no cabeçalho é a logo de verdade.
+    for (const tag of html.match(/<img\b[^>]*>/gi) || []) {
+        const src = atributo(tag, 'src') || atributo(tag, 'data-src') || '';
+        const alt = atributo(tag, 'alt') || '';
+        const cls = atributo(tag, 'class') || '';
+        const id = atributo(tag, 'id') || '';
+        if (/logo|brand|marca/i.test(`${src} ${alt} ${cls} ${id}`) && !/sponsor|partner|cliente|client|parceir/i.test(`${alt} ${cls} ${src}`)) {
+            const u = absoluta(src, base);
+            if (u && !/^data:/.test(u)) lista.push({ url: u, fonte: 'img-logo', nota: /\.svg(\?|$)/i.test(u) ? 30 : 20 });
+        }
+    }
+    // 1b. SVG inline no cabeçalho com "logo" no nome — não dá para baixar,
+    //     mas o agente pode saber que existe (e usar o nome em texto).
+    // 2. Ícones declarados.
+    for (const tag of html.match(/<link\b[^>]*>/gi) || []) {
+        const rel = (atributo(tag, 'rel') || '').toLowerCase();
+        const href = atributo(tag, 'href');
+        if (!href) continue;
+        const u = absoluta(href, base);
+        if (!u) continue;
+        if (/apple-touch-icon/.test(rel)) lista.push({ url: u, fonte: 'apple-touch-icon', nota: 15 });
+        else if (/\bicon\b/.test(rel)) {
+            const tam = parseInt((atributo(tag, 'sizes') || '0').split('x')[0], 10) || 0;
+            lista.push({ url: u, fonte: 'icon', nota: /\.svg(\?|$)/i.test(u) ? 14 : (tam >= 128 ? 10 : 4) });
+        }
+    }
+    // 3. og:image — a imagem de compartilhar. Às vezes é a logo, às vezes é
+    //    uma foto: fica atrás das declaradas.
+    const m = metas(html);
+    const og = m['og:image'] || m['twitter:image'];
+    if (og) { const u = absoluta(og, base); if (u) lista.push({ url: u, fonte: 'og:image', nota: 6 }); }
+    // 4. O favicon padrão, quando nada foi declarado.
+    lista.push({ url: absoluta('/favicon.ico', base), fonte: 'favicon', nota: 1 });
+    // Ordena e tira repetidos.
+    const vistos = new Set();
+    return lista.filter((c) => c.url && !vistos.has(c.url) && vistos.add(c.url)).sort((a, b) => b.nota - a.nota);
+}
+
+/** As cores de um CSS, contadas. Fora branco, preto e cinza. */
+function coresDe(css, contagem) {
+    const re = /#([0-9a-f]{6}|[0-9a-f]{3})\b|rgba?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})/gi;
+    let m;
+    while ((m = re.exec(css))) {
+        let hex;
+        if (m[1]) {
+            hex = m[1].length === 3 ? m[1].split('').map((c) => c + c).join('') : m[1];
+        } else {
+            hex = [m[2], m[3], m[4]].map((n) => Math.min(255, +n).toString(16).padStart(2, '0')).join('');
+        }
+        hex = '#' + hex.toLowerCase();
+        const r = parseInt(hex.slice(1, 3), 16), g = parseInt(hex.slice(3, 5), 16), b = parseInt(hex.slice(5, 7), 16);
+        const max = Math.max(r, g, b), min = Math.min(r, g, b);
+        const sat = max === 0 ? 0 : (max - min) / max;
+        // Cinza (pouca saturação), quase branco e quase preto não são
+        // identidade — são o papel e a tinta de todo site.
+        if (sat < 0.18 || max < 40 || (min > 225)) continue;
+        contagem.set(hex, (contagem.get(hex) || 0) + 1);
+    }
+}
+
+function fontesDe(html, css) {
+    const achadas = new Map();
+    // Google Fonts: family=Plus+Jakarta+Sans:wght@400;700&family=Inter
+    for (const m of html.matchAll(/fonts\.googleapis\.com\/css2?\?([^"' >]+)/gi)) {
+        for (const f of m[1].matchAll(/family=([^&:]+)/g)) {
+            const nome = decodeURIComponent(f[1].replace(/\+/g, ' ')).trim();
+            if (nome) achadas.set(nome, (achadas.get(nome) || 0) + 10);
+        }
+    }
+    // Para em ; } e aspas: o CSS aqui inclui atributos style="…" da página,
+    // e sem a aspa como fim o nome da fonte engolia o atributo seguinte
+    // (medido: 'sans-serif"  style="color:#7fa6ff').
+    for (const m of css.matchAll(/font-family\s*:\s*([^;}]+)/gi)) {
+        for (const parte of m[1].split(',')) {
+            const nome = parte.trim().replace(/\s*!important/, '').replace(/^["']|["']$/g, '').trim();
+            if (!nome || nome.length > 40 || GENERICAS_FONTE.test(nome) || /[(){}:="']/.test(nome)) continue;
+            achadas.set(nome, (achadas.get(nome) || 0) + 1);
+        }
+    }
+    return [...achadas.entries()].sort((a, b) => b[1] - a[1]).map(([n]) => n).slice(0, 3);
+}
+
+/** Descobre o site quando veio só o nome: o chute de domínio do referencia.js. */
+async function acharSite(nome) {
+    const palpites = referencia.sitesProvaveis(`site da empresa "${nome}"`);
+    const { vivos, html } = await referencia.chutesVivos(palpites, 1);
+    if (vivos.length) return { url: vivos[0].url, html: html.get(vivos[0].url) };
+    // Sem chute vivo, o buscador.
+    const achados = await referencia.buscar(`${nome} site oficial`, 4);
+    for (const a of achados) {
+        if (/wikipedia|linkedin|instagram|facebook|youtube|twitter|x\.com/i.test(a.url)) continue;
+        const h = await referencia.pegar(a.url, { timeout: 8000 });
+        if (h && h.length > 500) return { url: a.url, html: h };
+    }
+    return null;
+}
+
+/**
+ * A tool. `site` (URL) ou `nome` (a empresa). Devolve a identidade e a
+ * `marca` pronta para o documento do estúdio.
+ */
+async function marcaDaEmpresa(args, { projectDir, studio }) {
+    const nome = String(args.nome || args.empresa || '').trim();
+    let site = String(args.site || args.url || '').trim();
+    if (!nome && !site) return { ok: false, error: 'Diga o nome da empresa (nome) ou o endereço do site (site).' };
+    if (site && !/^https?:\/\//i.test(site)) site = 'https://' + site;
+
+    let html = null;
+    if (site) html = await referencia.pegar(site, { timeout: 12000 });
+    if (!html && site && !/\/\/www\./i.test(site)) {
+        const comWww = site.replace(/^(https?:\/\/)/i, '$1www.');
+        html = await referencia.pegar(comWww, { timeout: 12000 });
+        if (html) site = comWww;
+    }
+    if (!html && nome) {
+        const achado = await acharSite(nome);
+        if (achado) { site = achado.url; html = achado.html; }
+    }
+    if (!html) {
+        return {
+            ok: false,
+            error: `Não achei o site de "${nome || site}".`,
+            comoCorrigir: 'Se souber o endereço, chame de novo com site:"https://…". Se não, siga SEM a logo: '
+                + 'use o nome em texto na assinatura ("tipo":"assinatura","nome":…) e uma cor de tema — '
+                + 'e diga ao usuário que a logo não foi encontrada para ele mandar o arquivo (studio_midia).',
+        };
+    }
+
+    const m = metas(html);
+    const titulo = (html.match(/<title[^>]*>([\s\S]*?)<\/title>/i) || [])[1] || '';
+    // Sem og:site_name nem <title> (site montado por JavaScript), o nome vem
+    // do domínio: "nubank.com.br" → "Nubank". Melhor que campo vazio.
+    const dominio = ((site.match(/^https?:\/\/(?:www\.)?([^/]+)/i) || [])[1] || '').split('.')[0];
+    const nomeSite = (m['og:site_name'] || m['application-name'] || titulo.split(/\s[|–—-]\s|\s·\s/)[0] || nome
+        || (dominio ? dominio.charAt(0).toUpperCase() + dominio.slice(1) : '')).trim().slice(0, 80);
+    const frase = (m['description'] || m['og:description'] || '').trim().slice(0, 240);
+
+    // Cores: theme-color declarada, depois o CSS (inline + até 3 folhas).
+    const contagem = new Map();
+    let css = (html.match(/<style\b[^>]*>([\s\S]*?)<\/style>/gi) || []).join('\n');
+    // Só o MIOLO do style="…": com o `style="` junto, o fim de um atributo
+    // virava começo do nome da fonte seguinte (medido: 'sans-serif" style=…').
+    css += ' ' + (html.match(/\sstyle\s*=\s*"[^"]*"/gi) || []).map((a) => a.replace(/^\sstyle\s*=\s*"|"$/g, '')).join('; ');
+    const folhas = [];
+    for (const tag of html.match(/<link\b[^>]*>/gi) || []) {
+        if (/stylesheet/i.test(atributo(tag, 'rel') || '')) {
+            const u = absoluta(atributo(tag, 'href'), site);
+            if (u && !/fonts\.googleapis/i.test(u)) folhas.push(u);
+        }
+    }
+    const conteudos = await Promise.all(folhas.slice(0, 3).map((u) => referencia.pegar(u, { timeout: 8000 })));
+    for (const c of conteudos) if (c) css += '\n' + c.slice(0, 300000);
+    coresDe(css, contagem);
+    const paleta = [...contagem.entries()].sort((a, b) => b[1] - a[1]).map(([c]) => c).slice(0, 6);
+    let principal = null;
+    const tema = m['theme-color'];
+    if (tema && /^#?[0-9a-f]{3,8}$/i.test(tema.replace('#', ''))) {
+        const h = tema.replace('#', '').toLowerCase();
+        principal = '#' + (h.length === 3 ? h.split('').map((c) => c + c).join('') : h.slice(0, 6));
+        const r = parseInt(principal.slice(1, 3), 16), g = parseInt(principal.slice(3, 5), 16), b = parseInt(principal.slice(5, 7), 16);
+        const max = Math.max(r, g, b), min = Math.min(r, g, b);
+        if (max === 0 || (max - min) / max < 0.18 || min > 225) principal = null;   // theme-color branco/preto não é a cor da marca
+    }
+    if (!principal) principal = paleta[0] || null;
+
+    const fontes = fontesDe(html, css);
+
+    // A logo: tenta as candidatas em ordem até uma baixar de verdade.
+    let logo = null;
+    const candidatas = candidatasALogo(html, site);
+    const tentadas = [];
+    for (const c of candidatas.slice(0, 6)) {
+        const bytes = await referencia.pegar(c.url, { timeout: 10000, binario: true });
+        if (!bytes || bytes.length < 200) { tentadas.push(`${c.fonte}: não abriu`); continue; }
+        const cab = bytes.subarray(0, 16);
+        const ext = /^<\?xml|^<svg/i.test(bytes.subarray(0, 64).toString('utf8').trim()) ? '.svg'
+            : cab[0] === 0x89 && cab[1] === 0x50 ? '.png'
+                : cab[0] === 0xff && cab[1] === 0xd8 ? '.jpg'
+                    : cab.subarray(0, 4).toString() === 'RIFF' ? '.webp'
+                        : cab[0] === 0x00 && cab[1] === 0x00 && cab[2] === 0x01 && cab[3] === 0x00 ? '.ico'
+                            : cab.subarray(0, 3).toString() === 'GIF' ? '.gif' : null;
+        if (!ext) { tentadas.push(`${c.fonte}: não é imagem`); continue; }
+        if (ext === '.ico' && candidatas.length > 1 && c.fonte === 'favicon') { tentadas.push('favicon: só .ico'); }
+        const pasta = path.join(projectDir || process.cwd(), 'midia');
+        fs.mkdirSync(pasta, { recursive: true });
+        const arquivo = path.join(pasta, `logo-${nomeSite.toLowerCase().normalize('NFD').replace(/[̀-ͯ]/g, '').replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '') || 'marca'}${ext}`);
+        fs.writeFileSync(arquivo, bytes);
+        let url = null;
+        if (studio && ext !== '.ico') {
+            const envio = await studio.midiaEnviar({ arquivo });
+            if (envio && envio.ok !== false) url = envio.url;
+        }
+        logo = { url: url || null, arquivoLocal: path.relative(projectDir || process.cwd(), arquivo), origem: c.url, fonte: c.fonte, formato: ext.slice(1), bytes: bytes.length };
+        break;
+    }
+
+    const marca = {};
+    if (principal) marca.cor = principal;
+    if (logo && logo.url) marca.logo = logo.url;
+    return {
+        ok: true,
+        nome: nomeSite || nome,
+        site,
+        frase: frase || null,
+        cores: { principal, paleta },
+        fontes,
+        logo,
+        marca,
+        comoUsar: (Object.keys(marca).length
+            ? `No documento do estúdio: "marca": ${JSON.stringify(marca)}. `
+            : 'Sem cor nem logo confiáveis: use o nome em texto na assinatura e o tema pelo assunto. ')
+            + (fontes.length ? `Fonte da marca: ${fontes[0]} (o estúdio usa a do tema; cite a fonte só se for pedir código/HTML). ` : '')
+            + (logo && !logo.url && logo.formato === 'ico' ? 'A única logo encontrada foi o favicon .ico, que o estúdio não usa — peça o arquivo ao usuário se a peça for de marca. ' : '')
+            + (frase ? `Uma linha sobre a empresa, do próprio site: "${frase}".` : ''),
+        tentativasDeLogo: tentadas.length ? tentadas : undefined,
+    };
+}
+
+module.exports = { marcaDaEmpresa, candidatasALogo, coresDe, fontesDe, metas, atributo };