avorelo 0.1.0 → 0.3.0

package/scripts/lib/brand-boundary.js

@@ -1,424 +0,0 @@
-"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

@@ -1,74 +0,0 @@
-"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,
-};