@reddoorla/maintenance 0.87.0 → 0.88.3

package/dist/{chunk-HSI6Q7MI.js → chunk-CEW5PEHZ.js}

@@ -1,6 +1,6 @@
 import {
   isPrivateOrLoopbackHost
-} from "./chunk-EVBCK2KC.js";
+} from "./chunk-RARREDQE.js";
 
 // src/prospect/crawl.ts
 import { parse as parse2, NodeType as NodeType2 } from "node-html-parser";
@@ -264,6 +264,17 @@ function decodeXmlText(s) {
 function parseSitemapLocs(xml) {
   return [...xml.matchAll(/<(?:[\w-]+:)?loc\b[^>]*>([\s\S]*?)<\/(?:[\w-]+:)?loc>/gi)].map((m) => decodeXmlText(m[1] ?? "").trim()).filter(Boolean);
 }
+function isSafeNestedSitemap(child, origin) {
+  let url;
+  try {
+    url = new URL(child, origin);
+  } catch {
+    return false;
+  }
+  if (url.protocol !== "https:" && url.protocol !== "http:") return false;
+  if (url.origin !== origin) return false;
+  return !isPrivateOrLoopbackHost(url.hostname);
+}
 function isSitemapIndex(xml) {
   return /<(?:[\w-]+:)?sitemapindex[\s>]/i.test(xml);
 }
@@ -347,7 +358,8 @@ async function fetchSidecars(origin, deps) {
   if (sitemap.res && /<(urlset|sitemapindex)[\s>]/i.test(sitemap.res.body)) {
     sitemapPresent = true;
     if (isSitemapIndex(sitemap.res.body)) {
-      for (const child of parseSitemapLocs(sitemap.res.body).slice(0, 3)) {
+      const children = parseSitemapLocs(sitemap.res.body).filter((child) => isSafeNestedSitemap(child, origin)).slice(0, 3);
+      for (const child of children) {
         const nested = await optional(deps, child);
         if (nested.res) sitemapUrls.push(...parseSitemapLocs(nested.res.body));
       }
@@ -369,6 +381,14 @@ async function crawlSite(rawUrl, deps) {
   start.hash = "";
   start.username = "";
   start.password = "";
+  if (isPrivateOrLoopbackHost(start.hostname)) {
+    throw Object.assign(
+      new Error(
+        `${start.toString()} is a private address (${start.hostname}) \u2014 refusing to crawl it.`
+      ),
+      { exitCode: 1 }
+    );
+  }
   let home;
   try {
     home = await deps.fetchUrl(start.toString());
@@ -787,10 +807,16 @@ Return:
   the site answers it (yes/partial/no), whether there is a passage an AI could quote verbatim, the page
   it lives on, and the evidence quote. evidence must be an EXACT substring of that page's quoted text \u2014
   copied verbatim, never paraphrased or invented \u2014 or null when no exact quote supports the answer.
-- categoryQueries: 3-5 searches a buyer types BEFORE they have heard of this company, chosen so that
-  this company deserves to appear in the results. Each one is sent verbatim to a live answer engine on
-  its own, with no other context, so it must stand alone: name the service and the place or the
-  qualifier a buyer would use ("packaging design agency Los Angeles", "how much does a rebrand cost").
+- categoryQueries: 5 searches a buyer types BEFORE they have heard of this company, chosen so that this
+  company could PLAUSIBLY RANK for them today \u2014 not ones it arguably deserves. A broad head term
+  ("branding agency Los Angeles") returns directories and listicles, which is where small firms are
+  aggregated rather than surfaced, so a query like that measures nothing about this company. Give a
+  spread: at most ONE head term, and at least THREE that are long-tail \u2014 a specific service, a
+  narrower niche or industry, a smaller locality, or a question phrased the way a buyer types it.
+  Prefer the specific over the impressive. Each one is sent verbatim to a live answer engine on its
+  own, with no other context, so it must stand alone: name the service and the place or the qualifier
+  a buyer would use ("trade show booth design for medical device companies", "how much does a rebrand
+  cost for a B2B company", "packaging design studio San Antonio").
   Never refer to the company \u2014 not by name, and not as "this agency", "they", "them" or "you". A query
   that names the company measures nothing (the engine just echoes the name back); a query that points
   at it with a pronoun has no antecedent and the engine will answer that it does not know who is meant.
@@ -902,16 +928,19 @@ function verifyEvidence(result, crawl) {
     if (view) textByUrl.set(p.url, view.text);
   }
   const buyerQuestions = result.buyerQuestions.map((q) => {
-    if (q.page === null) {
-      return q.evidence === null ? q : { ...q, evidence: null };
-    }
-    if (!crawledUrls.has(q.page)) {
-      return { ...q, page: null, evidence: null };
-    }
-    if (q.evidence === null) return q;
-    const pageText = textByUrl.get(q.page) ?? "";
-    const verified = normalizeWhitespace(pageText).includes(normalizeWhitespace(q.evidence));
-    return verified ? q : { ...q, evidence: null };
+    const verified = (() => {
+      if (q.page === null) {
+        return q.evidence === null ? q : { ...q, evidence: null };
+      }
+      if (!crawledUrls.has(q.page)) {
+        return { ...q, page: null, evidence: null };
+      }
+      if (q.evidence === null) return q;
+      const pageText = textByUrl.get(q.page) ?? "";
+      const quoted = normalizeWhitespace(pageText).includes(normalizeWhitespace(q.evidence));
+      return quoted ? q : { ...q, evidence: null };
+    })();
+    return verified.evidence === null && verified.answered !== "no" ? { ...verified, answered: "no" } : verified;
   });
   return { ...result, buyerQuestions };
 }
@@ -922,7 +951,7 @@ async function analyzeSite(url, crawl, checks, deps = defaultAnalyzeDeps()) {
 }
 
 // src/prospect/probes.ts
-var MAX_QUERIES = 8;
+var MAX_QUERIES = 9;
 var SNIPPET_CHARS = 300;
 var PROBE_MODEL = "claude-sonnet-5";
 function domainOf(raw) {
@@ -937,11 +966,13 @@ function isSameSite(cited, prospect) {
   return cited === prospect || cited.endsWith(`.${prospect}`) || prospect.endsWith(`.${cited}`);
 }
 var MAX_NAME_CHARS = 60;
+var NAME_ABBREVIATIONS = /\b(st|mt|ft|dr|mr|mrs|ms|jr|sr|co|inc|ltd|llc|corp|assoc|bros|dept|ave|blvd|rd)\.\s/gi;
+var INITIALS = /\b[a-z]\.\s/gi;
 function resolveBusinessName(business, url) {
   const trimmed = business.trim();
-  if (!trimmed || trimmed.length > MAX_NAME_CHARS || /\.\s/.test(trimmed)) {
-    return domainOf(url);
-  }
+  if (!trimmed || trimmed.length > MAX_NAME_CHARS) return domainOf(url);
+  const withoutAbbreviations = trimmed.replace(NAME_ABBREVIATIONS, "").replace(INITIALS, "");
+  if (/\.\s/.test(withoutAbbreviations)) return domainOf(url);
   return trimmed;
 }
 function buildQueries(input) {
@@ -949,7 +980,11 @@ function buildQueries(input) {
   const candidates = [
     { query: `who is ${name}`, kind: "branded" },
     { query: `${name} reviews`, kind: "branded" },
-    ...input.categoryQueries.slice(0, 3).map((query) => ({ query, kind: "category" })),
+    // All five, not three. The schema asks the model for up to five and we were
+    // paying to generate them, then discarding two — which also pinned the
+    // denominator at 3, making visibilityScore a four-valued {0,33,67,100}
+    // rendered on a 0-100 card. Five halves the step to 20 points.
+    ...input.categoryQueries.slice(0, 5).map((query) => ({ query, kind: "category" })),
     ...input.competitors.slice(0, 2).map((c) => ({ query: `${name} vs ${c}`, kind: "competitor" }))
   ];
   const seen = /* @__PURE__ */ new Set();
@@ -964,12 +999,106 @@ function buildQueries(input) {
 function escapeRegExp(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+var LEGAL_SUFFIX = /\b(llc|inc|incorporated|ltd|limited|corp|corporation|plc|llp|lp|pllc|pc)\b/g;
+function normalizeForMatch(s) {
+  return s.toLowerCase().replace(/&/g, " and ").replace(/[‐-―]/g, " ").replace(/[^a-z0-9]+/g, " ").replace(LEGAL_SUFFIX, " ").replace(/\s+/g, " ").trim();
+}
 function mentionsBrand(answer, brand) {
-  if (!brand) return false;
-  return new RegExp(`(^|[^a-z0-9])${escapeRegExp(brand)}($|[^a-z0-9])`, "i").test(answer);
+  const needle = normalizeForMatch(brand);
+  if (!needle) return false;
+  return new RegExp(`(^| )${escapeRegExp(needle)}( |$)`).test(normalizeForMatch(answer));
 }
+var CATEGORY_WORDS = /* @__PURE__ */ new Set([
+  // articles and joiners
+  "the",
+  "a",
+  "an",
+  "and",
+  "of",
+  "for",
+  "at",
+  "by",
+  // company words
+  "co",
+  "company",
+  "group",
+  "collective",
+  "partners",
+  "associates",
+  "works",
+  "lab",
+  "labs",
+  "studio",
+  "studios",
+  "agency",
+  "agencies",
+  "firm",
+  "practice",
+  "shop",
+  "house",
+  "office",
+  // sector words
+  "design",
+  "designs",
+  "creative",
+  "creatives",
+  "brand",
+  "branding",
+  "marketing",
+  "media",
+  "digital",
+  "solutions",
+  "services",
+  "consulting",
+  "consultants",
+  "advisors",
+  "strategy",
+  "dental",
+  "dentistry",
+  "orthodontics",
+  "law",
+  "legal",
+  "clinic",
+  "care",
+  "health",
+  "medical",
+  "roofing",
+  "construction",
+  "builders",
+  "contracting",
+  "plumbing",
+  "electric",
+  "landscaping",
+  "interiors",
+  "architects",
+  "photography",
+  "films",
+  "productions",
+  "printing",
+  "packaging",
+  // adjectives that market rather than identify
+  "modern",
+  "premier",
+  "elite",
+  "first",
+  "best",
+  "local",
+  "family",
+  "advanced",
+  "complete",
+  "quality",
+  "professional",
+  "trusted",
+  "expert",
+  "affordable",
+  "custom",
+  "creative"
+]);
 function isDistinctiveName(brand) {
-  return /\s/.test(brand) || brand.includes(".");
+  if (brand.includes(".")) return true;
+  const tokens = normalizeForMatch(brand).split(" ").filter(Boolean);
+  if (tokens.length < 2) return false;
+  return tokens.some((t) => !CATEGORY_WORDS.has(t));
 }
 function isRateLimited(err) {
   const message = err instanceof Error ? err.message : String(err);
@@ -983,13 +1112,18 @@ async function runVisibilityProbes(input, engines, opts = {}) {
   const queries = buildQueries(input);
   const prospect = domainOf(input.url);
   const brand = resolveBusinessName(input.business, input.url).toLowerCase();
+  const nameIsDistinctive = isDistinctiveName(brand);
   const answers = [];
   const competitorCounts = /* @__PURE__ */ new Map();
+  const perEngine = /* @__PURE__ */ new Map();
   for (const engine of engines) {
+    const tally = { categoryAttempted: 0, answeredAny: false };
+    perEngine.set(engine.name, tally);
     await pacedEach(
       queries,
       delayMs,
       async ({ query, kind }) => {
+        if (kind === "category") tally.categoryAttempted += 1;
         let reply;
         try {
           reply = await engine.ask(query);
@@ -1002,6 +1136,7 @@ async function runVisibilityProbes(input, engines, opts = {}) {
             return;
           }
         }
+        tally.answeredAny = true;
         const citedDomains = reply.citedDomains.map(domainOf);
         const domainCited = citedDomains.some((d) => isSameSite(d, prospect));
         const brandMentioned = mentionsBrand(reply.answer.toLowerCase(), brand);
@@ -1015,6 +1150,8 @@ async function runVisibilityProbes(input, engines, opts = {}) {
           kind,
           domainCited,
           brandMentioned,
+          // The same expression the score uses below — written once, read twice.
+          countedAsVisible: domainCited || brandMentioned && nameIsDistinctive,
           citedDomains,
           snippet: reply.answer.slice(0, SNIPPET_CHARS),
           truncated: reply.answer.length > SNIPPET_CHARS,
@@ -1028,17 +1165,16 @@ async function runVisibilityProbes(input, engines, opts = {}) {
     throw new Error("no visibility engine returned an answer");
   }
   const categoryAnswers = answers.filter((a) => a.kind === "category");
-  const nameIsDistinctive = isDistinctiveName(brand);
-  const visibleCategory = categoryAnswers.filter(
-    (a) => a.domainCited || a.brandMentioned && nameIsDistinctive
-  ).length;
-  const visibilityScore = categoryAnswers.length === 0 ? null : Math.round(visibleCategory / categoryAnswers.length * 100);
+  const visibleCategory = categoryAnswers.filter((a) => a.countedAsVisible).length;
+  const categoryAttempted = [...perEngine.values()].filter((t) => t.answeredAny).reduce((n, t) => n + t.categoryAttempted, 0);
+  const visibilityScore = categoryAttempted === 0 || categoryAnswers.length === 0 ? null : Math.round(visibleCategory / categoryAttempted * 100);
   const brandedRecognized = answers.some((a) => a.kind === "branded" && a.domainCited);
   return {
     answers,
     visibilityScore,
     brandedRecognized,
-    competitorsSeen: [...competitorCounts.entries()].map(([domain, count]) => ({ domain, count })).sort((a, b) => b.count - a.count).slice(0, 8)
+    competitorsSeen: [...competitorCounts.entries()].map(([domain, count]) => ({ domain, count })).sort((a, b) => b.count - a.count).slice(0, 8),
+    categoryProbes: { attempted: categoryAttempted, answered: categoryAnswers.length }
   };
 }
 function perplexityEngine(apiKey, fetchImpl = fetch) {
@@ -1231,8 +1367,9 @@ async function runProspectAudit(url, opts, deps = {}) {
 }
 
 export {
+  resolveBusinessName,
   PROBES_SKIPPED,
   ANALYZE_SKIPPED,
   runProspectAudit
 };
-//# sourceMappingURL=chunk-HSI6Q7MI.js.map
+//# sourceMappingURL=chunk-CEW5PEHZ.js.map