avorelo 0.3.8 → 0.4.0-rc.2

package/scripts/lib/brand-boundary.js

@@ -0,0 +1,424 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const brand = require("./brand");
+
+const DEFAULT_CONFIG_PATH = path.join(__dirname, "..", "brand-boundary.config.json");
+const TEXT_EXTENSIONS = new Set([
+  ".js",
+  ".cjs",
+  ".mjs",
+  ".ts",
+  ".tsx",
+  ".jsx",
+  ".json",
+  ".md",
+  ".html",
+  ".css",
+  ".txt",
+  ".yml",
+  ".yaml",
+]);
+const CONDITIONAL_TEXT_EXTENSIONS = new Set([".md", ".txt", ".html", ".htm"]);
+
+function normalizeSlashes(value) {
+  return String(value || "").replace(/\\/g, "/");
+}
+
+function escapeRegExp(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function loadBrandBoundaryConfig(configPath = DEFAULT_CONFIG_PATH) {
+  try {
+    return JSON.parse(fs.readFileSync(configPath, "utf8"));
+  } catch (error) {
+    const wrapped = new Error(`Could not load brand boundary config at ${configPath}: ${error.message}`);
+    wrapped.code = "BRAND_CONFIG_ERROR";
+    throw wrapped;
+  }
+}
+
+function resolveReplacementValue(token) {
+  return brand[token] || token;
+}
+
+function matchesPathPrefix(relPath, candidate) {
+  const normalizedPath = normalizeSlashes(relPath);
+  const normalizedCandidate = normalizeSlashes(candidate).replace(/\/+$/, "");
+  return normalizedPath === normalizedCandidate || normalizedPath.startsWith(`${normalizedCandidate}/`);
+}
+
+function isIgnoredPath(relPath, config) {
+  return (config.ignoredPaths || []).some((candidate) => matchesPathPrefix(relPath, candidate));
+}
+
+function isTextFile(relPath) {
+  return TEXT_EXTENSIONS.has(path.extname(relPath).toLowerCase());
+}
+
+function shouldCheckConditionalTerm(relPath) {
+  return CONDITIONAL_TEXT_EXTENSIONS.has(path.extname(relPath).toLowerCase());
+}
+
+function collectPath(rootDir, relPath, config, bucket) {
+  const absPath = path.join(rootDir, relPath);
+  if (!fs.existsSync(absPath)) return;
+  const stat = fs.statSync(absPath);
+
+  if (isIgnoredPath(relPath, config)) {
+    return;
+  }
+
+  if (stat.isDirectory()) {
+    fs.readdirSync(absPath)
+      .sort()
+      .forEach((entry) => collectPath(rootDir, path.posix.join(normalizeSlashes(relPath), entry), config, bucket));
+    return;
+  }
+
+  if (stat.isFile() && isTextFile(relPath)) {
+    bucket.push({
+      relPath: normalizeSlashes(relPath),
+      absPath,
+    });
+  }
+}
+
+function resolveCustomerFacingFiles(rootDir, config) {
+  const files = [];
+  (config.customerFacingPaths || []).forEach((entry) => {
+    collectPath(rootDir, normalizeSlashes(entry), config, files);
+  });
+  const deduped = new Map();
+  files.forEach((file) => {
+    deduped.set(file.relPath, file);
+  });
+  return Array.from(deduped.values()).sort((a, b) => a.relPath.localeCompare(b.relPath));
+}
+
+function isAllowlisted(relPath, term, config) {
+  return (config.allowedLegacyOccurrences || []).find((entry) => {
+    return normalizeSlashes(entry.path) === normalizeSlashes(relPath) && entry.term === term;
+  }) || null;
+}
+
+function hasAllowlistedFile(relPath, config) {
+  return (config.allowedLegacyOccurrences || []).some((entry) => {
+    return normalizeSlashes(entry.path) === normalizeSlashes(relPath);
+  });
+}
+
+function buildSuggestionMap(config) {
+  const map = new Map();
+  (config.replacementRules || []).forEach((rule) => {
+    map.set(rule.term, resolveReplacementValue(rule.replaceWith));
+  });
+  map.set("getwuz.com", brand.PUBLIC_DOMAIN);
+  map.set("usewuz.com", brand.PUBLIC_DOMAIN);
+  map.set("wuz.ai", brand.PUBLIC_DOMAIN);
+  map.set("wuz.dev", brand.PUBLIC_DOMAIN);
+  const supportEmail = config.supportEmail || brand.SUPPORT_EMAIL;
+  if (supportEmail) {
+    map.set("SUPPORT_EMAIL", supportEmail);
+  }
+  return map;
+}
+
+function addMatchesFromRegex(leaks, { relPath, lines, term, regex, config, suggestionMap, reason }) {
+  lines.forEach((line, index) => {
+    regex.lastIndex = 0;
+    if (!regex.test(line)) return;
+    if (isAllowlisted(relPath, term, config)) return;
+    leaks.push({
+      path: relPath,
+      line: index + 1,
+      term,
+      excerpt: line.trim(),
+      suggestedReplacement: suggestionMap.get(term) || null,
+      reason,
+      allowlistReason: null,
+    });
+  });
+}
+
+function buildForbiddenRegex(term) {
+  if (String(term).startsWith("/")) {
+    return new RegExp(`(?<!\\.)${escapeRegExp(term)}\\b`, "g");
+  }
+  if (term === "cco-init") {
+    return /\bcco-init\b/g;
+  }
+  return new RegExp(escapeRegExp(term), "g");
+}
+
+function scanText({ relPath, text, config }) {
+  const lines = String(text).split(/\r?\n/);
+  const suggestionMap = buildSuggestionMap(config);
+  const leaks = [];
+
+  (config.forbiddenTerms || []).forEach((term) => {
+    if (term === "wuz" && !shouldCheckConditionalTerm(relPath)) {
+      return;
+    }
+    const regex = buildForbiddenRegex(term);
+    addMatchesFromRegex(leaks, {
+      relPath,
+      lines,
+      term,
+      regex,
+      config,
+      suggestionMap,
+      reason: "customer-facing surfaces must use the Avorelo public brand.",
+    });
+  });
+
+  (config.forbiddenDomains || []).forEach((term) => {
+    const regex = new RegExp(escapeRegExp(term), "g");
+    addMatchesFromRegex(leaks, {
+      relPath,
+      lines,
+      term,
+      regex,
+      config,
+      suggestionMap,
+      reason: "customer-facing surfaces must use avorelo.com where the public domain is expected.",
+    });
+  });
+
+  if (shouldCheckConditionalTerm(relPath)) {
+    (config.conditionalForbiddenTerms || [])
+      .filter((entry) => entry.forbiddenWhenCustomerFacing)
+      .forEach((entry) => {
+        const term = entry.term;
+        const regex = new RegExp(`\\b${escapeRegExp(term)}\\b`, "g");
+        addMatchesFromRegex(leaks, {
+          relPath,
+          lines,
+          term,
+          regex,
+          config,
+          suggestionMap,
+          reason: "customer-facing lowercase cco is ambiguous and must be removed or allowlisted with a reason.",
+        });
+      });
+  }
+
+  const supportEmail = String(config.supportEmail || brand.SUPPORT_EMAIL || "").trim().toLowerCase();
+  const supportAddressRegex = /\b(?:support|contact|hello|info)@[a-z0-9.-]+\.[a-z]{2,}\b/gi;
+  lines.forEach((line, index) => {
+    const matches = line.match(supportAddressRegex) || [];
+    matches.forEach((match) => {
+      const normalized = String(match).toLowerCase();
+      if (normalized === supportEmail) return;
+      if (isAllowlisted(relPath, match, config)) return;
+      leaks.push({
+        path: relPath,
+        line: index + 1,
+        term: match,
+        excerpt: line.trim(),
+        suggestedReplacement: supportEmail || null,
+        reason: "customer-facing support and contact surfaces must use support@avorelo.com.",
+        allowlistReason: null,
+      });
+    });
+  });
+
+  return leaks;
+}
+
+function scanCustomerFacingFiles(rootDir, config = loadBrandBoundaryConfig()) {
+  const files = resolveCustomerFacingFiles(rootDir, config);
+  const leaks = [];
+
+  files.forEach((file) => {
+    const text = fs.readFileSync(file.absPath, "utf8");
+    leaks.push(...scanText({ relPath: file.relPath, text, config }));
+  });
+
+  return {
+    files,
+    leaks,
+  };
+}
+
+function formatLeak(leak) {
+  const suggested = leak.suggestedReplacement ? `Suggested replacement: ${leak.suggestedReplacement}\n` : "";
+  return [
+    "Forbidden legacy brand found:",
+    `File: ${leak.path}`,
+    `Line: ${leak.line}`,
+    `Term: ${leak.term}`,
+    `Excerpt: ${leak.excerpt}`,
+    suggested.trimEnd(),
+    `Reason: ${leak.reason}`,
+    "Action: run npm run brand:fix or edit manually.",
+  ].filter(Boolean).join("\n");
+}
+
+function applyLiteralReplacement(content, term, replacement) {
+  const regex = new RegExp(escapeRegExp(term), "g");
+  const matches = content.match(regex);
+  if (!matches) {
+    return { content, count: 0 };
+  }
+  return {
+    content: content.replace(regex, replacement),
+    count: matches.length,
+  };
+}
+
+function applySafeLowercaseWuz(content) {
+  const patterns = [
+    { regex: /\bnpx wuz@latest\b/g, replacement: "npx avorelo@latest", term: "wuz" },
+    { regex: /\bUsage: wuz\b/g, replacement: "Usage: avorelo", term: "wuz" },
+    { regex: /\[wuz\]/g, replacement: "[avorelo]", term: "wuz" },
+    { regex: /\bwuz verify\b/g, replacement: "avorelo verify", term: "wuz" },
+    { regex: /^wuz$/gm, replacement: "avorelo", term: "wuz" },
+    { regex: /\bwuz 1\.[0-9.]+\b/g, replacement: (match) => match.replace(/\bwuz\b/, "avorelo"), term: "wuz" },
+  ];
+
+  let next = content;
+  let count = 0;
+  patterns.forEach(({ regex, replacement }) => {
+    const matches = next.match(regex);
+    if (!matches) return;
+    next = next.replace(regex, replacement);
+    count += matches.length;
+  });
+  return { content: next, count };
+}
+
+function findAmbiguousTerms(relPath, text, config) {
+  const ambiguous = [];
+  const lines = String(text).split(/\r?\n/);
+
+  if (shouldCheckConditionalTerm(relPath)) {
+    lines.forEach((line, index) => {
+      if (/\bcco\b/.test(line) && !isAllowlisted(relPath, "cco", config)) {
+        ambiguous.push({
+          path: relPath,
+          line: index + 1,
+          term: "cco",
+          excerpt: line.trim(),
+          reason: "customer-facing lowercase cco should be replaced manually or allowlisted if intentionally internal.",
+        });
+      }
+    });
+  }
+
+  if (shouldCheckConditionalTerm(relPath)) {
+    lines.forEach((line, index) => {
+      if (/\bwuz\b/.test(line) && !/npx wuz@latest|Usage: wuz|\[wuz\]|\bwuz verify\b|^wuz$|\bwuz 1\.[0-9.]+\b/.test(line) && !isAllowlisted(relPath, "wuz", config)) {
+        ambiguous.push({
+          path: relPath,
+          line: index + 1,
+          term: "wuz",
+          excerpt: line.trim(),
+          reason: "lowercase wuz was not auto-fixed because the replacement depends on context.",
+        });
+      }
+    });
+  }
+
+  return ambiguous;
+}
+
+function applyReplacementRules(relPath, input, config) {
+  let content = String(input);
+  const replacementCounts = {};
+  const ambiguous = [];
+
+  (config.replacementRules || [])
+    .filter((rule) => !rule.onlyWhenSafe && rule.term !== "wuz")
+    .forEach((rule) => {
+      const replacement = resolveReplacementValue(rule.replaceWith);
+      const result = applyLiteralReplacement(content, rule.term, replacement);
+      content = result.content;
+      if (result.count > 0) {
+        replacementCounts[rule.term] = (replacementCounts[rule.term] || 0) + result.count;
+      }
+    });
+
+  ["getwuz.com", "usewuz.com", "wuz.ai", "wuz.dev"].forEach((term) => {
+    const result = applyLiteralReplacement(content, term, brand.PUBLIC_DOMAIN);
+    content = result.content;
+    if (result.count > 0) {
+      replacementCounts[term] = (replacementCounts[term] || 0) + result.count;
+    }
+  });
+
+  const safeWuz = applySafeLowercaseWuz(content);
+  content = safeWuz.content;
+  if (safeWuz.count > 0) {
+    replacementCounts.wuz = (replacementCounts.wuz || 0) + safeWuz.count;
+  }
+
+  const supportEmail = String(config.supportEmail || brand.SUPPORT_EMAIL || "").trim();
+  if (supportEmail) {
+    const supportAddressRegex = /\b(?:support|contact|hello|info)@[a-z0-9.-]+\.[a-z]{2,}\b/gi;
+    const matches = content.match(supportAddressRegex) || [];
+    const wrongMatches = matches.filter((match) => String(match).toLowerCase() !== supportEmail.toLowerCase());
+    if (wrongMatches.length > 0) {
+      content = content.replace(supportAddressRegex, (match) => {
+        return String(match).toLowerCase() === supportEmail.toLowerCase() ? match : supportEmail;
+      });
+      replacementCounts.supportEmail = (replacementCounts.supportEmail || 0) + wrongMatches.length;
+    }
+  }
+
+  ambiguous.push(...findAmbiguousTerms(relPath, content, config));
+
+  return {
+    content,
+    changed: content !== input,
+    replacementCounts,
+    ambiguous,
+  };
+}
+
+function runAutofix(rootDir, config = loadBrandBoundaryConfig(), options = {}) {
+  const files = resolveCustomerFacingFiles(rootDir, config);
+  const write = options.write === true;
+  const changedFiles = [];
+  const ambiguous = [];
+  const replacementCounts = {};
+
+  files.forEach((file) => {
+    const before = fs.readFileSync(file.absPath, "utf8");
+    if (hasAllowlistedFile(file.relPath, config)) {
+      return;
+    }
+    const result = applyReplacementRules(file.relPath, before, config);
+
+    Object.entries(result.replacementCounts).forEach(([term, count]) => {
+      replacementCounts[term] = (replacementCounts[term] || 0) + count;
+    });
+    ambiguous.push(...result.ambiguous);
+
+    if (write && result.changed) {
+      fs.writeFileSync(file.absPath, result.content, "utf8");
+      changedFiles.push(file.relPath);
+    }
+  });
+
+  return {
+    filesScanned: files.length,
+    changedFiles,
+    replacementCounts,
+    ambiguous,
+    write,
+  };
+}
+
+module.exports = {
+  DEFAULT_CONFIG_PATH,
+  loadBrandBoundaryConfig,
+  resolveCustomerFacingFiles,
+  scanText,
+  scanCustomerFacingFiles,
+  formatLeak,
+  runAutofix,
+  applyReplacementRules,
+};

package/scripts/lib/brand.js

@@ -0,0 +1,74 @@
+"use strict";
+
+const PRODUCT_NAME = "Avorelo";
+const CLI_NAME = "avorelo";
+const PUBLIC_INIT_COMMAND = "/avorelo-init";
+const PUBLIC_DOMAIN = "avorelo.com";
+const PUBLIC_SITE_URL = "https://avorelo.com";
+const SUPPORT_EMAIL = "support@avorelo.com";
+
+const LEGACY_PRODUCT_NAME = "Wuz";
+const LEGACY_CLI_NAME = "wuz";
+const LEGACY_FULL_NAME = "ClaudeCode Optimizer";
+const LEGACY_PACKAGE_NAME = "ClaudeCode-Optimizer";
+
+const INTERNAL_NAMESPACE = "cco";
+const INTERNAL_INIT_COMMAND = "/cco-init";
+
+function getBrand() {
+  return {
+    PRODUCT_NAME,
+    CLI_NAME,
+    PUBLIC_INIT_COMMAND,
+    PUBLIC_DOMAIN,
+    PUBLIC_SITE_URL,
+    SUPPORT_EMAIL,
+    LEGACY_PRODUCT_NAME,
+    LEGACY_CLI_NAME,
+    LEGACY_FULL_NAME,
+    LEGACY_PACKAGE_NAME,
+    INTERNAL_NAMESPACE,
+    INTERNAL_INIT_COMMAND,
+  };
+}
+
+function formatProductName() {
+  return PRODUCT_NAME;
+}
+
+function formatCliCommand(command) {
+  const tail = String(command || "").trim().replace(/^\//, "");
+  return tail ? `${CLI_NAME} ${tail}` : CLI_NAME;
+}
+
+function formatInitCommand() {
+  return PUBLIC_INIT_COMMAND;
+}
+
+function formatPublicUrl(pathname) {
+  if (!pathname) return PUBLIC_SITE_URL;
+  const suffix = String(pathname).trim();
+  if (!suffix) return PUBLIC_SITE_URL;
+  if (/^https?:\/\//i.test(suffix)) return suffix;
+  return `${PUBLIC_SITE_URL}/${suffix.replace(/^\/+/, "")}`;
+}
+
+module.exports = {
+  PRODUCT_NAME,
+  CLI_NAME,
+  PUBLIC_INIT_COMMAND,
+  PUBLIC_DOMAIN,
+  PUBLIC_SITE_URL,
+  SUPPORT_EMAIL,
+  LEGACY_PRODUCT_NAME,
+  LEGACY_CLI_NAME,
+  LEGACY_FULL_NAME,
+  LEGACY_PACKAGE_NAME,
+  INTERNAL_NAMESPACE,
+  INTERNAL_INIT_COMMAND,
+  getBrand,
+  formatProductName,
+  formatCliCommand,
+  formatInitCommand,
+  formatPublicUrl,
+};