vtex-audit 0.1.0

package/README.md

@@ -0,0 +1,226 @@
+# VTEX Audit 🚀
+
+CLI profissional para auditoria de **Performance, SEO e Qualidade Técnica** em lojas **VTEX IO**, baseado no Lighthouse — com **diagnóstico acionável**, foco em **LCP**, **3rd‑party scripts** e **boas práticas reais de e‑commerce**.
+
+> Não é apenas um wrapper do Lighthouse.  
+> É um **auditor especializado em VTEX IO**.
+
+---
+
+## ✨ Principais diferenciais
+
+✅ Auditoria **opiniada para VTEX IO**  
+✅ Identificação automática do **Largest Contentful Paint (LCP)**  
+✅ Descoberta do **elemento exato responsável pelo LCP**  
+✅ Ranking dos **arquivos mais pesados**  
+✅ Ranking das **requisições mais lentas**  
+✅ Detecção de **scripts third‑party**  
+✅ Sugestões automáticas de **correções prováveis**  
+✅ Relatórios JSON e HTML  
+✅ Interface de terminal profissional  
+✅ Pronto para **CI/CD e pipelines**  
+
+---
+
+## 📦 Instalação
+
+### Uso rápido (recomendado)
+
+```bash
+npx vtex-audit --url https://www.sualoja.com.br
+```
+
+### Instalação global
+
+```bash
+npm install -g vtex-audit
+```
+
+---
+
+## 🚀 Uso
+
+### Mobile (default)
+
+```bash
+vtex-audit --url https://www.sualoja.com.br
+```
+
+### Desktop
+
+```bash
+vtex-audit --url https://www.sualoja.com.br --device desktop
+```
+
+### Gerar relatórios
+
+```bash
+vtex-audit --url https://www.sualoja.com.br --json --html
+```
+
+### Diretório de saída
+
+```bash
+vtex-audit --url https://www.sualoja.com.br --out ./audit
+```
+
+---
+
+## 📊 Exemplo de saída
+
+```
+VTEX Audit (mobile)
+URL: https://www.loja.com.br
+
+Scores (Lighthouse)
+Performance: 51
+SEO: 100
+Accessibility: 91
+Best Practices: 57
+
+Core metrics
+LCP: 16.7s
+CLS: 0.004
+TBT: 375ms
+Requests: 168
+Total weight: 2.4 MB
+
+LCP details
+Element: img.banner__img
+Asset: https://.../banner-home.webp
+
+Top culprits
+Largest transfers:
+- hero-banner.webp (420 KB)
+- vendor.js (310 KB)
+
+Slowest requests:
+- google-analytics.js (1.8s)
+- facebook-pixel.js (1.4s)
+
+Top domains:
+- pandorajoias.vtexassets.com
+- www.googletagmanager.com ⚠️
+- connect.facebook.net ⚠️
+
+Likely fixes
+→ Priorizar banner LCP
+→ Converter imagens para WebP / AVIF
+→ Adiar scripts third‑party
+→ Reduzir apps globais VTEX
+```
+
+---
+
+## 🔍 O que o VTEX Audit analisa
+
+### Lighthouse
+- Performance
+- SEO
+- Accessibility
+- Best Practices
+
+### Métricas principais
+- Largest Contentful Paint (LCP)
+- Cumulative Layout Shift (CLS)
+- Total Blocking Time (TBT)
+- Time To Interactive (TTI)
+- Speed Index
+
+---
+
+## 🔎 SEO custom (fora do Lighthouse)
+
+- ❌ Página sem `<h1>`
+- ❌ Imagens sem atributo `alt`
+- ❌ Meta title ausente
+- ❌ Meta description ausente
+- ❌ Conteúdo vazio acima da dobra
+
+---
+
+## ⚡ Performance avançada
+
+- Identificação do **elemento real do LCP**
+- URL do asset responsável
+- Top 10 arquivos por peso
+- Top 10 requests mais lentas
+- Ranking por domínio
+- Destaque automático de **third‑party scripts**
+- Diagnóstico focado em **VTEX IO**
+
+---
+
+## 🧠 Diferença para o Lighthouse tradicional
+
+| Lighthouse | VTEX Audit |
+|----------|-----------|
+| Genérico | Especializado em VTEX |
+| Interface web | CLI profissional |
+| Apenas notas | Diagnóstico acionável |
+| Sem ranking | Top culpados |
+| Sem noção de apps | Identifica third‑party |
+| Manual | Automatizável |
+| Sem contexto | Sugestões práticas |
+
+---
+
+## 🤖 CI / GitHub Actions
+
+```yaml
+- name: VTEX Audit
+  run: npx vtex-audit --url https://www.sualoja.com.br
+```
+
+Ideal para validar performance antes de deploy.
+
+---
+
+## 📁 Estrutura dos relatórios
+
+```
+./vtex-audit
+├── mobile-home.json
+├── mobile-home.html
+├── seo-report.json
+```
+
+---
+
+## 🛠 Stack
+
+- Node.js 18+
+- TypeScript
+- Lighthouse
+- Chrome Launcher
+- Ora
+- Boxen
+- CLI Table
+- Pretty Bytes
+
+---
+
+## 🧭 Roadmap
+
+- [ ] Auditoria por múltiplas rotas (Home, PLP, PDP)
+- [ ] Comparação entre deploys
+- [ ] Exportação Markdown
+- [ ] Dashboard Web
+- [ ] Integração com VTEX Admin
+- [ ] GitHub Checks
+- [ ] VTEX Toolbelt Plugin
+
+---
+
+## 👨‍💻 Autor
+
+**Denis Palhares Gonçalves**  
+Senior Full Stack Developer  
+Especialista em VTEX IO  
++10 anos em e‑commerce
+
+---
+
+## 📄 Licença
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/index.js

@@ -0,0 +1,488 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import chalk from "chalk";
+import boxen from "boxen";
+import ora from "ora";
+import prettyBytes from "pretty-bytes";
+import Table from "cli-table3";
+
+// src/audit/lighthouse.ts
+import lighthouse from "lighthouse";
+import { launch } from "chrome-launcher";
+function safeHost(raw) {
+  try {
+    return new URL(raw).hostname;
+  } catch {
+    return "unknown";
+  }
+}
+function toNumberOrNull(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : null;
+}
+async function runLighthouse(url2, device2) {
+  const chrome = await launch({
+    chromeFlags: ["--headless=new", "--no-sandbox", "--disable-gpu", "--disable-dev-shm-usage"]
+  });
+  try {
+    const opts2 = {
+      port: chrome.port,
+      logLevel: "error",
+      output: "json",
+      onlyCategories: ["performance", "seo", "accessibility", "best-practices"],
+      emulatedFormFactor: device2,
+      maxWaitForLoad: 12e4
+    };
+    const runnerResult = await lighthouse(url2, opts2);
+    if (!runnerResult?.lhr) throw new Error("Lighthouse n\xE3o retornou lhr");
+    const lhr = runnerResult.lhr;
+    const audits = lhr.audits ?? {};
+    const scores = {
+      performance: Math.round((lhr.categories?.performance?.score ?? 0) * 100),
+      seo: Math.round((lhr.categories?.seo?.score ?? 0) * 100),
+      accessibility: Math.round((lhr.categories?.accessibility?.score ?? 0) * 100),
+      bestPractices: Math.round((lhr.categories?.["best-practices"]?.score ?? 0) * 100)
+    };
+    const metrics = {
+      lcpMs: Math.round(audits["largest-contentful-paint"]?.numericValue ?? 0),
+      cls: Number((audits["cumulative-layout-shift"]?.numericValue ?? 0).toFixed(3)),
+      tbtMs: Math.round(audits["total-blocking-time"]?.numericValue ?? 0),
+      ttiMs: Math.round(audits["interactive"]?.numericValue ?? 0),
+      speedIndexMs: Math.round(audits["speed-index"]?.numericValue ?? 0)
+    };
+    const networkItemsRaw = audits["network-requests"]?.details?.items ?? [];
+    const requests = Array.isArray(networkItemsRaw) ? networkItemsRaw.length : null;
+    const totalByteWeight = Math.round(audits["total-byte-weight"]?.numericValue ?? 0);
+    const runWarnings = Array.isArray(lhr.runWarnings) ? lhr.runWarnings : [];
+    const lcpElItem = audits["largest-contentful-paint-element"]?.details?.items?.[0];
+    const lcp = {
+      elementSelector: lcpElItem?.node?.selector ?? null,
+      elementSnippet: lcpElItem?.node?.snippet ?? null,
+      elementUrl: lcpElItem?.url ?? null
+    };
+    const normalized = Array.isArray(networkItemsRaw) ? networkItemsRaw.map((it) => {
+      const u = String(it?.url ?? "");
+      if (!u) return null;
+      return {
+        url: u,
+        hostname: safeHost(u),
+        resourceType: it?.resourceType ?? null,
+        transferSize: toNumberOrNull(it?.transferSize),
+        duration: toNumberOrNull(it?.duration)
+      };
+    }).filter(Boolean) : [];
+    const topBySize = [...normalized].sort((a, b) => (b.transferSize ?? 0) - (a.transferSize ?? 0)).slice(0, 10);
+    const topByTime = [...normalized].sort((a, b) => (b.duration ?? 0) - (a.duration ?? 0)).slice(0, 10);
+    const domainMap = /* @__PURE__ */ new Map();
+    for (const it of normalized) {
+      const key = it.hostname || "unknown";
+      const prev = domainMap.get(key) ?? { hostname: key, requests: 0, transferSize: 0 };
+      prev.requests += 1;
+      prev.transferSize += it.transferSize ?? 0;
+      domainMap.set(key, prev);
+    }
+    const topDomains = [...domainMap.values()].sort((a, b) => b.transferSize - a.transferSize).slice(0, 10);
+    return {
+      url: url2,
+      device: device2,
+      scores,
+      metrics,
+      requests,
+      totalByteWeight,
+      runWarnings,
+      lcp,
+      network: { topBySize, topByTime, topDomains },
+      lhr
+    };
+  } finally {
+    await chrome.kill();
+  }
+}
+
+// src/audit/seo.ts
+import puppeteer from "puppeteer";
+async function fetchText(url2) {
+  const res = await fetch(url2, { redirect: "follow" });
+  return { status: res.status, text: await res.text() };
+}
+async function runSeoChecks(url2) {
+  const issues = [];
+  const browser = await puppeteer.launch({
+    headless: true,
+    args: ["--no-sandbox", "--disable-setuid-sandbox"]
+  });
+  try {
+    const page = await browser.newPage();
+    await page.setViewport({ width: 390, height: 844 });
+    await page.goto(url2, { waitUntil: "networkidle2", timeout: 9e4 });
+    const data = await page.evaluate(() => {
+      const title = document.title || "";
+      const desc = document.querySelector('meta[name="description"]')?.getAttribute("content") || "";
+      const canonical = document.querySelector('link[rel="canonical"]')?.getAttribute("href") || "";
+      const robots2 = document.querySelector('meta[name="robots"]')?.getAttribute("content") || "";
+      const h1s = Array.from(document.querySelectorAll("h1")).map((h) => (h.textContent || "").trim()).filter(Boolean);
+      const imgs = Array.from(document.querySelectorAll("img")).map((img) => ({
+        alt: (img.getAttribute("alt") || "").trim(),
+        src: img.getAttribute("src") || img.getAttribute("data-src") || ""
+      }));
+      const ldjson = Array.from(
+        document.querySelectorAll('script[type="application/ld+json"]')
+      ).map((s) => s.textContent || "").filter(Boolean);
+      return { title, desc, canonical, robots: robots2, h1s, imgs, ldjson };
+    });
+    if (!data.title.trim())
+      issues.push({ level: "error", message: "Sem <title>." });
+    else if (data.title.length > 65)
+      issues.push({
+        level: "warn",
+        message: `<title> muito longo (${data.title.length} chars).`
+      });
+    if (!data.desc.trim())
+      issues.push({ level: "warn", message: "Sem meta description." });
+    else if (data.desc.length > 160)
+      issues.push({
+        level: "warn",
+        message: `Description muito longa (${data.desc.length} chars).`
+      });
+    if (data.robots.toLowerCase().includes("noindex"))
+      issues.push({ level: "error", message: "Meta robots cont\xE9m NOINDEX." });
+    if (!data.canonical)
+      issues.push({ level: "warn", message: "Sem canonical." });
+    else {
+      try {
+        const c = new URL(data.canonical, url2);
+        const u = new URL(url2);
+        if (c.host !== u.host)
+          issues.push({
+            level: "warn",
+            message: `Canonical aponta para outro dom\xEDnio: ${c.host}`
+          });
+      } catch {
+        issues.push({ level: "warn", message: "Canonical inv\xE1lido." });
+      }
+    }
+    if (data.h1s.length === 0)
+      issues.push({ level: "warn", message: "Sem H1." });
+    if (data.h1s.length > 1)
+      issues.push({
+        level: "warn",
+        message: `M\xFAltiplos H1 (${data.h1s.length}).`
+      });
+    const imgsNoAlt = data.imgs.filter((i) => i.src && !i.alt);
+    if (imgsNoAlt.length)
+      issues.push({
+        level: "warn",
+        message: `${imgsNoAlt.length} imagens sem alt.`
+      });
+    let ldOk = 0;
+    let ldBad = 0;
+    for (const chunk of data.ldjson) {
+      try {
+        JSON.parse(chunk);
+        ldOk++;
+      } catch {
+        ldBad++;
+      }
+    }
+    if (ldBad)
+      issues.push({
+        level: "warn",
+        message: `JSON-LD inv\xE1lido em ${ldBad} bloco(s).`
+      });
+    if (!data.ldjson.length)
+      issues.push({ level: "warn", message: "Nenhum JSON-LD encontrado." });
+    const base = new URL(url2);
+    const robotsUrl = `${base.origin}/robots.txt`;
+    const sitemapUrl = `${base.origin}/sitemap.xml`;
+    const robots = await fetchText(robotsUrl);
+    if (robots.status >= 400)
+      issues.push({
+        level: "warn",
+        message: `robots.txt n\xE3o acess\xEDvel (HTTP ${robots.status}).`
+      });
+    const sitemap = await fetchText(sitemapUrl);
+    if (sitemap.status >= 400)
+      issues.push({
+        level: "warn",
+        message: `sitemap.xml n\xE3o acess\xEDvel (HTTP ${sitemap.status}).`
+      });
+    else if (!sitemap.text.includes("<urlset") && !sitemap.text.includes("<sitemapindex")) {
+      issues.push({
+        level: "warn",
+        message: "sitemap.xml existe mas n\xE3o parece v\xE1lido (sem urlset/sitemapindex)."
+      });
+    }
+    return { url: url2, issues, snapshot: data };
+  } finally {
+    await browser.close();
+  }
+}
+
+// src/audit/budgets.ts
+import fs from "fs";
+import { z } from "zod";
+var BudgetSchema = z.object({
+  performanceMinScore: z.number().optional(),
+  seoMinScore: z.number().optional(),
+  maxTotalKB: z.number().optional(),
+  maxRequests: z.number().optional(),
+  maxLCPms: z.number().optional(),
+  maxCLS: z.number().optional(),
+  maxTBTms: z.number().optional()
+});
+function loadBudget(path2) {
+  const raw = JSON.parse(fs.readFileSync(path2, "utf-8"));
+  const parsed = BudgetSchema.safeParse(raw);
+  if (!parsed.success) throw new Error("budget.json inv\xE1lido");
+  return parsed.data;
+}
+function evaluateBudget(input, budget) {
+  if (!budget) return { ok: true, failures: [] };
+  const failures = [];
+  const lh = input.lighthouse;
+  const totalKB = Math.round((lh.totalByteWeight ?? 0) / 1024);
+  const requests = lh.pageStats?.requests ?? null;
+  if (budget.performanceMinScore != null && lh.scores.performance < budget.performanceMinScore)
+    failures.push(`Performance score ${lh.scores.performance} < ${budget.performanceMinScore}`);
+  if (budget.seoMinScore != null && lh.scores.seo < budget.seoMinScore)
+    failures.push(`SEO score ${lh.scores.seo} < ${budget.seoMinScore}`);
+  if (budget.maxTotalKB != null && totalKB > budget.maxTotalKB)
+    failures.push(`Total weight ${totalKB}KB > ${budget.maxTotalKB}KB`);
+  if (budget.maxRequests != null && requests != null && requests > budget.maxRequests)
+    failures.push(`Requests ${requests} > ${budget.maxRequests}`);
+  if (budget.maxLCPms != null && lh.metrics.lcpMs > budget.maxLCPms)
+    failures.push(`LCP ${lh.metrics.lcpMs}ms > ${budget.maxLCPms}ms`);
+  if (budget.maxCLS != null && lh.metrics.cls > budget.maxCLS)
+    failures.push(`CLS ${lh.metrics.cls} > ${budget.maxCLS}`);
+  if (budget.maxTBTms != null && lh.metrics.tbtMs > budget.maxTBTms)
+    failures.push(`TBT ${lh.metrics.tbtMs}ms > ${budget.maxTBTms}ms`);
+  const noindex = input.seo.issues.some((i) => i.level === "error" && i.message.includes("NOINDEX"));
+  if (noindex) failures.push("Meta robots NOINDEX");
+  return { ok: failures.length === 0, failures };
+}
+
+// src/audit/report.ts
+import fs2 from "fs";
+import path from "path";
+async function saveReports(params) {
+  fs2.mkdirSync(params.outDir, { recursive: true });
+  const outBase = path.join(params.outDir, `${params.device}-${new URL(params.url).hostname}`);
+  if (params.wantJson) {
+    fs2.writeFileSync(
+      `${outBase}.json`,
+      JSON.stringify(
+        {
+          url: params.url,
+          device: params.device,
+          scores: params.lighthouse.scores,
+          metrics: params.lighthouse.metrics,
+          evaluation: params.evaluation,
+          seo: params.seo,
+          lighthouse: params.lighthouse.lhr
+        },
+        null,
+        2
+      )
+    );
+  }
+  if (params.wantHtml) {
+    fs2.writeFileSync(`${outBase}.html`, "<!-- implementar output html do lighthouse -->");
+  }
+}
+
+// src/index.ts
+function normalizeUrl(url2) {
+  const u = new URL(url2);
+  u.hash = "";
+  return u.toString();
+}
+function ms(v) {
+  if (v == null || !Number.isFinite(v)) return "-";
+  if (v >= 1e3) return `${(v / 1e3).toFixed(2)}s`;
+  return `${Math.round(v)}ms`;
+}
+function scoreBadge(n) {
+  if (n >= 90) return chalk.green(String(n));
+  if (n >= 70) return chalk.yellow(String(n));
+  return chalk.red(String(n));
+}
+function shortUrl(u, max = 90) {
+  if (u.length <= max) return u;
+  return u.slice(0, max - 1) + "\u2026";
+}
+function isThirdPartyDomain(host, siteHost) {
+  if (!host) return false;
+  if (host === siteHost) return false;
+  const vtexLike = ["vtexassets.com", "vteximg.com.br", "myvtex.com", "vtex.com", "vtexcommerce"];
+  if (vtexLike.some((x) => host.includes(x))) return false;
+  return true;
+}
+function likelyFixes(res) {
+  const fixes = [];
+  const host = new URL(res.url).hostname;
+  const lcpUrl = res.lcp.elementUrl ?? "";
+  const lcpIsImage = !!lcpUrl && /\.(png|jpe?g|webp|avif)(\?|$)/i.test(lcpUrl);
+  if (res.metrics.lcpMs > 4e3) {
+    if (lcpIsImage) {
+      fixes.push("LCP alto e parece ser imagem: priorize o banner/hero (evitar lazy no 1\xBA banner) e reduza o peso (WebP/AVIF + dimens\xF5es mobile).");
+    } else {
+      fixes.push("LCP alto: verifique render-blocking (CSS/JS), hidrata\xE7\xE3o/React acima do fold e scripts no head.");
+    }
+  }
+  if ((res.requests ?? 0) > 140) {
+    fixes.push("Requests altos: revise apps e scripts globais (pixels/chat/reviews), condicione por p\xE1gina e adie carregamento onde poss\xEDvel.");
+  }
+  const thirdParty = res.network.topDomains.filter((d) => isThirdPartyDomain(d.hostname, host));
+  if (thirdParty.length) {
+    fixes.push(`Terceiros pesando na rede: investigue dom\xEDnios como ${thirdParty.slice(0, 3).map((d) => d.hostname).join(", ")} (tags, pixels, chat, A/B).`);
+  }
+  if (res.scores.bestPractices < 70) {
+    fixes.push("Best Practices baixo: costuma envolver imagens/cookies/HTTPS/console errors. Veja o relat\xF3rio JSON para os audits com falha.");
+  }
+  return fixes;
+}
+var program = new Command();
+program.name("vtex-audit").description("Audita uma URL p\xFAblica (Lighthouse + checks) com sa\xEDda amig\xE1vel.").requiredOption("--url <url>", "URL p\xFAblica para auditar (https://...)").option("--device <device>", "mobile|desktop (default: mobile)", "mobile").option("--budget <path>", "Arquivo budget.json").option("--json", "Salvar relat\xF3rio JSON").option("--html", "Salvar relat\xF3rio HTML do Lighthouse").option("--out <dir>", "Diret\xF3rio de sa\xEDda (default: ./vtex-audit)", "./vtex-audit").option("--verbose", "Mostra warnings e detalhes extras").parse(process.argv);
+var opts = program.opts();
+var url = normalizeUrl(opts.url);
+var device = opts.device === "desktop" ? "desktop" : "mobile";
+(async () => {
+  console.log(
+    boxen(
+      `${chalk.cyan.bold("VTEX Audit")}
+${chalk.gray("Device:")} ${chalk.white(device)}
+${chalk.gray("URL:")} ${chalk.white(url)}`,
+      { padding: 1, borderStyle: "round", borderColor: "cyan" }
+    )
+  );
+  const budget = opts.budget ? loadBudget(opts.budget) : null;
+  const sp1 = ora("Rodando Lighthouse\u2026").start();
+  const t0 = Date.now();
+  const lighthouseRes = await runLighthouse(url, device);
+  sp1.succeed(`Lighthouse conclu\xEDdo (${((Date.now() - t0) / 1e3).toFixed(1)}s)`);
+  const sp2 = ora("Executando checks de SEO\u2026").start();
+  const t1 = Date.now();
+  const seoRes = await runSeoChecks(url);
+  sp2.succeed(`Checks de SEO conclu\xEDdos (${((Date.now() - t1) / 1e3).toFixed(1)}s)`);
+  const sp3 = ora("Avaliando budget/limites\u2026").start();
+  const evaluation = evaluateBudget({ lighthouse: lighthouseRes, seo: seoRes }, budget);
+  sp3.succeed("Budget avaliado");
+  const scoreTable = new Table({
+    head: [chalk.bold("Categoria"), chalk.bold("Score")],
+    style: { head: [], border: [] }
+  });
+  scoreTable.push(
+    ["Performance", scoreBadge(lighthouseRes.scores.performance)],
+    ["SEO", scoreBadge(lighthouseRes.scores.seo)],
+    ["A11y", scoreBadge(lighthouseRes.scores.accessibility)],
+    ["Best Practices", scoreBadge(lighthouseRes.scores.bestPractices)]
+  );
+  console.log(chalk.bold("\nScores (Lighthouse)"));
+  console.log(scoreTable.toString());
+  const metricsTable = new Table({
+    head: [chalk.bold("M\xE9trica"), chalk.bold("Valor")],
+    style: { head: [], border: [] }
+  });
+  metricsTable.push(
+    ["LCP", ms(lighthouseRes.metrics.lcpMs)],
+    ["CLS", String(lighthouseRes.metrics.cls)],
+    ["TBT", ms(lighthouseRes.metrics.tbtMs)],
+    ["TTI", ms(lighthouseRes.metrics.ttiMs)],
+    ["Speed Index", ms(lighthouseRes.metrics.speedIndexMs)],
+    ["Requests", lighthouseRes.requests ?? "-"],
+    ["Total weight", prettyBytes(lighthouseRes.totalByteWeight)]
+  );
+  console.log(chalk.bold("\nCore metrics"));
+  console.log(metricsTable.toString());
+  console.log(chalk.bold("\nLCP details"));
+  if (lighthouseRes.lcp.elementSelector || lighthouseRes.lcp.elementUrl) {
+    console.log(`- Element: ${lighthouseRes.lcp.elementSelector ?? "(sem selector)"}`);
+    if (lighthouseRes.lcp.elementUrl) console.log(`- Asset:   ${chalk.gray(lighthouseRes.lcp.elementUrl)}`);
+  } else {
+    console.log(chalk.yellow("- Element: (n\xE3o identificado no relat\xF3rio)"));
+  }
+  console.log(chalk.bold("\nTop culprits"));
+  const topSizeTable = new Table({
+    head: [chalk.bold("KB"), chalk.bold("Type"), chalk.bold("Host"), chalk.bold("URL")],
+    colWidths: [8, 10, 24, 90],
+    style: { head: [], border: [] },
+    wordWrap: true
+  });
+  for (const it of lighthouseRes.network.topBySize) {
+    topSizeTable.push([
+      it.transferSize != null ? String(Math.round(it.transferSize / 1024)) : "-",
+      it.resourceType ?? "-",
+      it.hostname,
+      shortUrl(it.url)
+    ]);
+  }
+  console.log(chalk.gray("\nLargest transfers (Top 10)"));
+  console.log(topSizeTable.toString());
+  const topTimeTable = new Table({
+    head: [chalk.bold("Time"), chalk.bold("Type"), chalk.bold("Host"), chalk.bold("URL")],
+    colWidths: [10, 10, 24, 90],
+    style: { head: [], border: [] },
+    wordWrap: true
+  });
+  for (const it of lighthouseRes.network.topByTime) {
+    topTimeTable.push([
+      ms(it.duration),
+      it.resourceType ?? "-",
+      it.hostname,
+      shortUrl(it.url)
+    ]);
+  }
+  console.log(chalk.gray("\nSlowest requests (Top 10)"));
+  console.log(topTimeTable.toString());
+  const domainsTable = new Table({
+    head: [chalk.bold("Host"), chalk.bold("Req"), chalk.bold("KB")],
+    colWidths: [42, 8, 10],
+    style: { head: [], border: [] }
+  });
+  const siteHost = new URL(url).hostname;
+  for (const d of lighthouseRes.network.topDomains) {
+    const hostLabel = isThirdPartyDomain(d.hostname, siteHost) ? chalk.yellow(d.hostname) : d.hostname;
+    domainsTable.push([hostLabel, String(d.requests), String(Math.round(d.transferSize / 1024))]);
+  }
+  console.log(chalk.gray("\nTop domains by transfer"));
+  console.log(domainsTable.toString());
+  console.log(chalk.gray("(dom\xEDnios amarelos = prov\xE1vel 3rd-party)"));
+  const fixes = likelyFixes(lighthouseRes);
+  if (fixes.length) {
+    console.log(chalk.bold("\nLikely fixes (VTEX IO)"));
+    for (const f of fixes) console.log(`- ${chalk.cyan("\u2192")} ${f}`);
+  }
+  console.log(chalk.bold("\nSEO checks"));
+  for (const i of seoRes.issues.slice(0, 12)) {
+    const tag = i.level === "error" ? chalk.red("\u2716") : chalk.yellow("\u25B2");
+    console.log(`${tag} ${i.message}`);
+  }
+  if (seoRes.issues.length > 12) console.log(chalk.gray(`\u2026 +${seoRes.issues.length - 12} itens`));
+  if (opts.verbose && lighthouseRes.runWarnings?.length) {
+    console.log(chalk.bold("\nLighthouse warnings"));
+    for (const w of lighthouseRes.runWarnings) console.log(chalk.yellow(`\u25B2 ${w}`));
+  }
+  const sp4 = ora("Salvando relat\xF3rios\u2026").start();
+  await saveReports({
+    outDir: opts.out,
+    url,
+    device,
+    wantJson: !!opts.json,
+    wantHtml: !!opts.html,
+    lighthouse: lighthouseRes,
+    seo: seoRes,
+    evaluation
+  });
+  sp4.succeed(`Relat\xF3rios salvos em: ${chalk.gray(opts.out)}`);
+  if (!evaluation.ok) {
+    console.log(chalk.red("\nFalhou no budget/limites."));
+    if (evaluation.failures?.length) for (const f of evaluation.failures) console.log(chalk.red(`- ${f}`));
+    process.exit(1);
+  }
+  console.log(chalk.green("\n\u2714 Passou."));
+  process.exit(0);
+})().catch((err) => {
+  console.error(chalk.red("\nErro inesperado:"), err);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "vtex-audit",
+  "version": "0.1.0",
+  "description": "Professional VTEX IO audit CLI (Performance, SEO, LCP, Lighthouse) with actionable diagnostics.",
+  "type": "module",
+  "bin": {
+    "vtex-audit": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+"scripts": {
+  "build": "tsup",
+  "prepare": "npm run build"
+},
+  "keywords": [
+    "vtex",
+    "vtex-io",
+    "lighthouse",
+    "seo",
+    "performance",
+    "audit",
+    "ecommerce",
+    "cli"
+  ],
+  "author": "Denis Palhares Gonçalves",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/SEU_USUARIO/vtex-audit.git"
+  },
+  "bugs": {
+    "url": "https://github.com/SEU_USUARIO/vtex-audit/issues"
+  },
+  "homepage": "https://github.com/SEU_USUARIO/vtex-audit#readme",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "boxen": "^8.0.1",
+    "chalk": "^5.3.0",
+    "chrome-launcher": "^1.1.0",
+    "cli-table3": "^0.6.5",
+    "commander": "^12.1.0",
+    "lighthouse": "^12.0.0",
+    "ora": "^9.1.0",
+    "pretty-bytes": "^7.1.0",
+    "puppeteer": "^23.0.0",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "tsup": "^8.2.4",
+    "typescript": "^5.9.3"
+  }
+}