@bacano/sdk 1.0.1 → 1.1.8

package/skills/bacano-web/scripts/audit-http.mjs

@@ -0,0 +1,284 @@
+#!/usr/bin/env node
+
+const args = process.argv.slice(2);
+const baseArg = args[0];
+
+if (!baseArg || baseArg === "--help") {
+  console.log(
+    "Usage: node audit-http.mjs <origin-or-url> [--sitemap <url>] [--preview <path-or-url>] [--max <n>] [--delay <ms>]",
+  );
+  process.exit(baseArg ? 0 : 1);
+}
+
+function option(name, fallback) {
+  const index = args.indexOf(name);
+  return index >= 0 && args[index + 1] ? args[index + 1] : fallback;
+}
+
+const startUrl = new URL(baseArg);
+const maxRoutes = Math.max(1, Number(option("--max", "500")) || 500);
+const delayMs = Math.max(0, Number(option("--delay", "250")) || 0);
+const explicitSitemap = option("--sitemap", null);
+const explicitPreview = option("--preview", null);
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function fetchResult(url) {
+  const startedAt = Date.now();
+  try {
+    const response = await fetch(url, {
+      redirect: "follow",
+      headers: { "user-agent": "bacano-web-readiness/1" },
+    });
+    return {
+      requestedUrl: url,
+      finalUrl: response.url,
+      status: response.status,
+      durationMs: Date.now() - startedAt,
+      headers: Object.fromEntries(response.headers.entries()),
+      body: await response.text(),
+    };
+  } catch (error) {
+    return {
+      requestedUrl: url,
+      finalUrl: null,
+      status: null,
+      durationMs: Date.now() - startedAt,
+      headers: {},
+      body: "",
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+function sitemapUrls(xml) {
+  return [...xml.matchAll(/<loc>\s*([^<]+?)\s*<\/loc>/gi)].map((match) =>
+    match[1].replaceAll("&amp;", "&"),
+  );
+}
+
+function pageUrls(html, base) {
+  const urls = [];
+  for (const match of html.matchAll(
+    /<a\b[^>]*href\s*=\s*["']([^"']+)["'][^>]*>/gi,
+  )) {
+    try {
+      const url = new URL(match[1], base);
+      url.hash = "";
+      if (url.origin === startUrl.origin) urls.push(url.href);
+    } catch {
+      // Ignore malformed or unsupported links.
+    }
+  }
+  return urls;
+}
+
+function sameOrigin(url) {
+  try {
+    return new URL(url).origin === startUrl.origin;
+  } catch {
+    return false;
+  }
+}
+
+function comparableRoute(url) {
+  const parsed = new URL(url, startUrl);
+  const pathname = parsed.pathname.replace(/\/+$/, "") || "/";
+  return `${parsed.origin}${pathname}`;
+}
+
+function tagAttribute(tag, name) {
+  const match = tag.match(
+    new RegExp(`\\b${name}\\s*=\\s*(?:"([^"]*)"|'([^']*)'|([^\\s>]+))`, "i"),
+  );
+  return match?.[1] ?? match?.[2] ?? match?.[3] ?? null;
+}
+
+function findMeta(html, key, value) {
+  const tags = html.match(/<meta\b[^>]*>/gi) ?? [];
+  const normalized = value.toLowerCase();
+  for (const tag of tags) {
+    if (tagAttribute(tag, key)?.toLowerCase() === normalized) {
+      return tagAttribute(tag, "content");
+    }
+  }
+  return null;
+}
+
+function findLink(html, rel) {
+  const tags = html.match(/<link\b[^>]*>/gi) ?? [];
+  const normalized = rel.toLowerCase();
+  for (const tag of tags) {
+    const rels = tagAttribute(tag, "rel")?.toLowerCase().split(/\s+/) ?? [];
+    if (rels.includes(normalized)) return tagAttribute(tag, "href");
+  }
+  return null;
+}
+
+function stripMarkup(html) {
+  return html
+    .replace(/<script\b[\s\S]*?<\/script>/gi, " ")
+    .replace(/<style\b[\s\S]*?<\/style>/gi, " ")
+    .replace(/<[^>]+>/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function auditHtml(html) {
+  const title =
+    html.match(/<title\b[^>]*>([\s\S]*?)<\/title>/i)?.[1]?.trim() ?? null;
+  const visibleText = stripMarkup(html);
+  const placeholders = [
+    ...new Set(
+      visibleText.match(
+        /\[[A-ZÁÉÍÓÚÜÑ][A-ZÁÉÍÓÚÜÑ0-9 ._/-]{2,}\]|\b(?:TODO|FIXME|LOREM IPSUM)\b/gi,
+      ) ?? [],
+    ),
+  ].slice(0, 20);
+
+  return {
+    title,
+    description: findMeta(html, "name", "description"),
+    canonical: findLink(html, "canonical"),
+    robots: findMeta(html, "name", "robots"),
+    openGraphTitle: findMeta(html, "property", "og:title"),
+    openGraphImage: findMeta(html, "property", "og:image"),
+    twitterCard: findMeta(html, "name", "twitter:card"),
+    h1Count: (html.match(/<h1\b/gi) ?? []).length,
+    jsonLdCount: (
+      html.match(/<script\b[^>]*type=["']application\/ld\+json["'][^>]*>/gi) ??
+      []
+    ).length,
+    visibleTextLength: visibleText.length,
+    placeholders,
+  };
+}
+
+const home = await fetchResult(startUrl.href);
+const sitemapCandidates = explicitSitemap
+  ? [new URL(explicitSitemap, startUrl).href]
+  : [new URL("/sitemap.xml", startUrl).href];
+
+const routes = new Set([startUrl.href]);
+const sitemapPageUrls = new Set();
+const sitemapReports = [];
+
+for (const url of pageUrls(home.body, startUrl)) {
+  if (routes.size < maxRoutes) routes.add(url);
+}
+
+const visitedSitemaps = new Set();
+while (sitemapCandidates.length > 0) {
+  const candidate = sitemapCandidates.shift();
+  if (!candidate || visitedSitemaps.has(candidate)) continue;
+  visitedSitemaps.add(candidate);
+  const report = await fetchResult(candidate);
+  sitemapReports.push({ url: candidate, status: report.status });
+  if (report.status !== 200) continue;
+
+  const urls = sitemapUrls(report.body);
+  if (/<sitemapindex\b/i.test(report.body)) {
+    for (const url of urls) {
+      if (sameOrigin(url)) sitemapCandidates.push(url);
+    }
+    continue;
+  }
+
+  for (const url of urls) {
+    if (!sameOrigin(url)) continue;
+    sitemapPageUrls.add(url);
+    if (routes.size < maxRoutes) routes.add(url);
+  }
+}
+
+const pages = [];
+for (const url of routes) {
+  if (url === startUrl.href) {
+    pages.push({
+      url,
+      finalUrl: home.finalUrl,
+      status: home.status,
+      durationMs: home.durationMs,
+      error: home.error,
+      html: auditHtml(home.body),
+    });
+  } else {
+    if (delayMs) await sleep(delayMs);
+    const report = await fetchResult(url);
+    pages.push({
+      url,
+      finalUrl: report.finalUrl,
+      status: report.status,
+      durationMs: report.durationMs,
+      error: report.error,
+      html: auditHtml(report.body),
+    });
+  }
+}
+
+const requiredHeaders = [
+  "content-security-policy",
+  "strict-transport-security",
+  "x-content-type-options",
+  "referrer-policy",
+  "permissions-policy",
+];
+
+let previewAudit = null;
+if (explicitPreview) {
+  const previewUrl = new URL(explicitPreview, startUrl).href;
+  if (!sameOrigin(previewUrl)) {
+    throw new Error("--preview must belong to the audited origin");
+  }
+  if (delayMs) await sleep(delayMs);
+  const preview = await fetchResult(previewUrl);
+  const html = auditHtml(preview.body);
+  const robots = html.robots?.toLowerCase() ?? "";
+  const sitemapRoutes = new Set(
+    [...sitemapPageUrls].map((url) => comparableRoute(url)),
+  );
+
+  previewAudit = {
+    url: previewUrl,
+    finalUrl: preview.finalUrl,
+    status: preview.status,
+    error: preview.error,
+    robots: html.robots,
+    noindex: /(?:^|,)\s*noindex(?:\s|,|$)/.test(robots),
+    nofollow: /(?:^|,)\s*nofollow(?:\s|,|$)/.test(robots),
+    inSitemap: sitemapRoutes.has(comparableRoute(previewUrl)),
+  };
+}
+
+const output = {
+  auditedAt: new Date().toISOString(),
+  origin: startUrl.origin,
+  discoveredRoutes: routes.size,
+  sitemapReports,
+  previewAudit,
+  summary: {
+    successful: pages.filter((page) => page.status === 200).length,
+    redirectsOrOther: pages.filter(
+      (page) => page.status && page.status !== 200 && page.status < 400,
+    ).length,
+    failed: pages.filter((page) => !page.status || page.status >= 400).length,
+    productRoutes: pages.filter((page) =>
+      new URL(page.url).pathname.startsWith("/producto/"),
+    ).length,
+    missingTitle: pages.filter((page) => !page.html.title).length,
+    missingDescription: pages.filter((page) => !page.html.description).length,
+    missingCanonical: pages.filter((page) => !page.html.canonical).length,
+    invalidH1Count: pages.filter((page) => page.html.h1Count !== 1).length,
+    pagesWithPlaceholders: pages.filter(
+      (page) => page.html.placeholders.length > 0,
+    ).length,
+  },
+  homeSecurityHeaders: Object.fromEntries(
+    requiredHeaders.map((header) => [header, home.headers[header] ?? null]),
+  ),
+  pages,
+};
+
+console.log(JSON.stringify(output, null, 2));

package/skills/bacano-web/scripts/cli.mjs

@@ -0,0 +1,222 @@
+#!/usr/bin/env node
+
+import { createHash } from "node:crypto";
+import {
+  cpSync,
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  readFileSync,
+  readlinkSync,
+  rmSync,
+  symlinkSync,
+} from "node:fs";
+import { dirname, relative, resolve } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { fileURLToPath } from "node:url";
+
+const scriptDirectory = dirname(fileURLToPath(import.meta.url));
+const sourceSkill = resolve(scriptDirectory, "..");
+const sourceSkillFile = resolve(sourceSkill, "SKILL.md");
+const projectRoot = process.cwd();
+const canonicalSkill = resolve(projectRoot, ".agents", "skills", "bacano-web");
+
+const adapterPaths = {
+  antigravity: canonicalSkill,
+  claude: resolve(projectRoot, ".claude", "skills", "bacano-web"),
+  codex: resolve(projectRoot, ".codex", "skills", "bacano-web"),
+};
+
+function usage() {
+  console.log(`Bacano Web readiness skill
+
+Usage:
+  bacano-web install [--agent antigravity|claude|codex|all] [--force]
+  bacano-web check
+
+The canonical project copy lives at .agents/skills/bacano-web.
+Claude and Codex receive links to that same copy.`);
+}
+
+function option(name) {
+  const index = process.argv.indexOf(name);
+  return index >= 0 ? process.argv[index + 1] : null;
+}
+
+function hash(file) {
+  return createHash("sha256").update(readFileSync(file)).digest("hex");
+}
+
+function skillFile(directory) {
+  return resolve(directory, "SKILL.md");
+}
+
+function relativeDisplay(path) {
+  const value = relative(projectRoot, path);
+  return value || ".";
+}
+
+function removeExisting(path, force) {
+  if (!existsSync(path)) return;
+  if (!force) {
+    throw new Error(
+      `${relativeDisplay(path)} ya existe. Usa --force para reemplazarlo.`,
+    );
+  }
+  rmSync(path, { recursive: true, force: true });
+}
+
+function installCanonical(force) {
+  if (resolve(sourceSkill) === canonicalSkill) return;
+
+  if (existsSync(skillFile(canonicalSkill))) {
+    if (hash(skillFile(canonicalSkill)) === hash(sourceSkillFile)) return;
+    removeExisting(canonicalSkill, force);
+  } else if (existsSync(canonicalSkill)) {
+    removeExisting(canonicalSkill, force);
+  }
+
+  mkdirSync(dirname(canonicalSkill), { recursive: true });
+  cpSync(sourceSkill, canonicalSkill, { recursive: true });
+}
+
+function installAdapter(agent, force) {
+  const target = adapterPaths[agent];
+  if (!target || target === canonicalSkill) return;
+
+  if (existsSync(target)) {
+    const stat = lstatSync(target);
+    if (stat.isSymbolicLink()) {
+      const resolvedLink = resolve(dirname(target), readlinkSync(target));
+      if (resolvedLink === canonicalSkill) return;
+    }
+    removeExisting(target, force);
+  }
+
+  mkdirSync(dirname(target), { recursive: true });
+  const targetReference =
+    process.platform === "win32"
+      ? canonicalSkill
+      : relative(dirname(target), canonicalSkill);
+  symlinkSync(
+    targetReference,
+    target,
+    process.platform === "win32" ? "junction" : "dir",
+  );
+}
+
+async function chooseAgent() {
+  const explicit = option("--agent");
+  if (explicit) return explicit;
+
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    throw new Error(
+      "Indica --agent antigravity, --agent claude, --agent codex o --agent all.",
+    );
+  }
+
+  const prompt = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+  const answer = await prompt.question(
+    "¿Qué agente usará la skill? [1] Antigravity [2] Claude Code [3] Codex [4] Todos: ",
+  );
+  prompt.close();
+
+  return (
+    { 1: "antigravity", 2: "claude", 3: "codex", 4: "all" }[answer.trim()] ??
+    answer.trim().toLowerCase()
+  );
+}
+
+function validateAgent(agent) {
+  if (!["antigravity", "claude", "codex", "all"].includes(agent)) {
+    throw new Error(`Agente no reconocido: ${agent || "(vacío)"}.`);
+  }
+}
+
+async function install() {
+  const agent = await chooseAgent();
+  validateAgent(agent);
+  const force = process.argv.includes("--force");
+
+  installCanonical(force);
+  if (agent === "all") {
+    installAdapter("claude", force);
+    installAdapter("codex", force);
+  } else {
+    installAdapter(agent, force);
+  }
+
+  console.log("Skill Bacano Web instalada.");
+  console.log(`Fuente canónica: ${relativeDisplay(canonicalSkill)}`);
+  if (agent === "claude" || agent === "all") {
+    console.log(`Claude Code: ${relativeDisplay(adapterPaths.claude)}`);
+  }
+  if (agent === "codex" || agent === "all") {
+    console.log(`Codex: ${relativeDisplay(adapterPaths.codex)}`);
+  }
+  console.log("Ejecuta bacano-web check para verificarla.");
+}
+
+function checkPath(name, path) {
+  if (!existsSync(path))
+    return { name, path: relativeDisplay(path), status: "missing" };
+  const file = skillFile(path);
+  if (!existsSync(file)) {
+    return { name, path: relativeDisplay(path), status: "invalid" };
+  }
+  return {
+    name,
+    path: relativeDisplay(path),
+    status: hash(file) === hash(sourceSkillFile) ? "current" : "outdated",
+    link: lstatSync(path).isSymbolicLink(),
+  };
+}
+
+function check() {
+  const results = [
+    checkPath("canonical", canonicalSkill),
+    checkPath("antigravity", adapterPaths.antigravity),
+    checkPath("claude", adapterPaths.claude),
+    checkPath("codex", adapterPaths.codex),
+  ];
+  const unique = results.filter(
+    (result, index) =>
+      results.findIndex((candidate) => candidate.path === result.path) ===
+      index,
+  );
+
+  console.table(unique);
+  const canonical = results[0];
+  if (canonical.status !== "current") {
+    console.error(
+      "Bacano Web no está instalada o está desactualizada. Ejecuta bacano-web install.",
+    );
+    process.exitCode = 1;
+    return;
+  }
+
+  const adapters = results
+    .slice(2)
+    .filter((result) => result.status !== "missing");
+  if (adapters.some((result) => !result.link)) {
+    console.warn(
+      "Se detectaron copias físicas en adaptadores. Reinstala con --force para evitar divergencias.",
+    );
+  }
+  if (unique.some((result) => result.status === "outdated"))
+    process.exitCode = 1;
+}
+
+const command = process.argv[2] ?? "help";
+
+try {
+  if (command === "install") await install();
+  else if (command === "check") check();
+  else usage();
+} catch (error) {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exitCode = 1;
+}

package/skills/bacano-web/scripts/postinstall.mjs

@@ -0,0 +1,8 @@
+if (!process.env.CI && process.env.BACANO_SDK_HIDE_SKILL_NOTICE !== "1") {
+  console.log(`
+@bacano/sdk incluye la skill Bacano Web para evaluar sitios antes de producción.
+Instálala una vez:       pnpm exec bacano-web install --agent all
+Verifica su estado:      pnpm exec bacano-web check
+Luego invócala desde tu agente para iniciar la auditoría.
+`);
+}