@ainyc/canonry 4.55.1 → 4.55.3

package/dist/{chunk-UTM3FPAJ.js → chunk-XB6Y63NI.js}

@@ -9,8 +9,10 @@ import {
   categorizeSourceWithCompetitors,
   categoryLabel,
   determineAnswerMentioned,
-  normalizeProjectDomain
-} from "./chunk-OFY3Z2F7.js";
+  effectiveDomains,
+  normalizeProjectDomain,
+  registrableDomain
+} from "./chunk-XHU35P3S.js";
 
 // src/intelligence-service.ts
 import { eq, desc, asc, and, ne, or, inArray } from "drizzle-orm";
@@ -4156,6 +4158,172 @@ function createLogger(module) {
   };
 }
 
+// src/citation-utils.ts
+function domainMatches(domain, canonicalDomain) {
+  const normalized = normalizeProjectDomain(canonicalDomain);
+  const d = normalizeProjectDomain(domain);
+  return d === normalized || d.endsWith(`.${normalized}`);
+}
+function pickProjectCitedDomain(citedDomains, projectDomains) {
+  for (const cited of citedDomains) {
+    if (projectDomains.some((pd) => domainMatches(cited, pd))) return cited;
+  }
+  return void 0;
+}
+function determineCitationState(normalized, domains) {
+  for (const canonicalDomain of domains) {
+    const bareDomain = normalizeProjectDomain(canonicalDomain);
+    if (normalized.citedDomains.some((d) => domainMatches(d, bareDomain))) {
+      return "cited";
+    }
+    const lowerDomain = bareDomain.toLowerCase();
+    for (const source of normalized.groundingSources) {
+      try {
+        const uri = source.uri.toLowerCase();
+        if (lowerDomain.includes(".") && uri.includes(lowerDomain)) {
+          return "cited";
+        }
+      } catch {
+      }
+      if (source.title) {
+        const titleLower = source.title.toLowerCase().replace(/^www\./, "");
+        if (titleLower === lowerDomain || titleLower.endsWith(`.${lowerDomain}`)) {
+          return "cited";
+        }
+      }
+    }
+  }
+  return "not-cited";
+}
+function computeCompetitorOverlap(normalized, competitorDomains) {
+  const overlapSet = /* @__PURE__ */ new Set();
+  for (const d of normalized.citedDomains) {
+    for (const cd of competitorDomains) {
+      if (domainMatches(d, cd)) {
+        overlapSet.add(cd);
+      }
+    }
+  }
+  for (const source of normalized.groundingSources) {
+    const uri = source.uri.toLowerCase();
+    for (const cd of competitorDomains) {
+      if (uri.includes(cd.toLowerCase())) {
+        overlapSet.add(cd);
+      }
+    }
+  }
+  if (normalized.answerText) {
+    const lowerAnswer = normalized.answerText.toLowerCase();
+    for (const cd of competitorDomains) {
+      if (lowerAnswer.includes(cd.toLowerCase())) {
+        overlapSet.add(cd);
+      }
+      const brand = brandLabelFromDomain(cd);
+      if (brand.length >= 4 && new RegExp(`\\b${escapeRegExp(brand)}\\b`, "i").test(lowerAnswer)) {
+        overlapSet.add(cd);
+      }
+    }
+  }
+  return [...overlapSet];
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function extractRecommendedCompetitors(answerText, ownDomains, citedDomains, competitorDomains, ownBrandNames = []) {
+  if (!answerText || answerText.length < 20) return [];
+  const ownBrandKeys = new Set(
+    ownDomains.flatMap((domain) => collectBrandKeysFromDomain(domain))
+  );
+  for (const name of ownBrandNames) {
+    const key = brandKeyFromText(name);
+    if (key.length >= 4) ownBrandKeys.add(key);
+  }
+  const knownCompetitorKeys = new Set(
+    [...citedDomains, ...competitorDomains].flatMap((domain) => collectBrandKeysFromDomain(domain)).filter((key) => !ownBrandKeys.has(key))
+  );
+  if (knownCompetitorKeys.size === 0) return [];
+  const candidatePatterns = [
+    /^\s*(?:[-*]|\d+\.)\s+(?:\*\*)?([A-Z0-9][A-Za-z0-9][\w\s.&',/()-]{1,50}?)(?:\*\*)?\s*[:\u2014\u2013-]/gm,
+    /\*\*([A-Z0-9][A-Za-z0-9][\w\s.&',/()-]{1,50})\*\*/g,
+    /^#{1,4}\s+(?:\d+\.\s+)?(?:\*\*)?([A-Z0-9][A-Za-z0-9][\w\s.&',/()-]{1,50}?)(?:\*\*)?$/gm,
+    /\[([A-Z0-9][A-Za-z0-9][\w\s.&',/()-]{1,50})\]\(https?:\/\/[^\s)]+\)/g
+  ];
+  const genericKeys = /* @__PURE__ */ new Set([
+    "additional",
+    "best",
+    "benefits",
+    "bottomline",
+    "comparison",
+    "conclusion",
+    "directorylisting",
+    "example",
+    "expertise",
+    "features",
+    "finalthoughts",
+    "howitworks",
+    "important",
+    "keybenefits",
+    "keyfeatures",
+    "major",
+    "note",
+    "notable",
+    "option",
+    "other",
+    "overview",
+    "pricing",
+    "pros",
+    "reviews",
+    "step",
+    "summary",
+    "top",
+    "verdict",
+    "whattolookfor",
+    "whyitmatters",
+    "whyitstandsout",
+    "whywechoseit"
+  ]);
+  const seen = /* @__PURE__ */ new Map();
+  for (const pattern of candidatePatterns) {
+    let match;
+    while ((match = pattern.exec(answerText)) !== null) {
+      const candidate = cleanCandidateName(match[1] ?? "");
+      const candidateKey = brandKeyFromText(candidate);
+      if (!candidateKey) continue;
+      if (genericKeys.has(candidateKey)) continue;
+      if (candidate.split(/\s+/).length > 6) continue;
+      if (matchesBrandKey(candidateKey, ownBrandKeys)) continue;
+      if (!matchesBrandKey(candidateKey, knownCompetitorKeys)) continue;
+      if (!seen.has(candidateKey)) seen.set(candidateKey, candidate);
+    }
+  }
+  return [...seen.values()].slice(0, 10);
+}
+function cleanCandidateName(candidate) {
+  return candidate.replace(/^[\s"'`]+|[\s"'`.,:;!?]+$/g, "").replace(/\s+/g, " ").trim();
+}
+function collectBrandKeysFromDomain(domain) {
+  const reg = registrableDomain(domain);
+  if (!reg) {
+    const hostname = normalizeProjectDomain(domain).split("/")[0] ?? "";
+    const fallback = hostname.replace(/[^a-z0-9]/gi, "").toLowerCase();
+    return fallback.length >= 4 ? [fallback] : [];
+  }
+  const keys = /* @__PURE__ */ new Set();
+  const fullKey = reg.replace(/[^a-z0-9]/gi, "").toLowerCase();
+  if (fullKey.length >= 4) keys.add(fullKey);
+  const brand = brandLabelFromDomain(reg).replace(/[^a-z0-9]/gi, "").toLowerCase();
+  if (brand.length >= 4) keys.add(brand);
+  return [...keys];
+}
+function matchesBrandKey(candidateKey, brandKeys) {
+  for (const brandKey of brandKeys) {
+    if (candidateKey === brandKey) return true;
+    if (candidateKey.startsWith(brandKey) || candidateKey.endsWith(brandKey)) return true;
+    if (brandKey.startsWith(candidateKey) || brandKey.endsWith(candidateKey)) return true;
+  }
+  return false;
+}
+
 // src/intelligence-service.ts
 var RECURRENCE_LOOKBACK_RUNS = 5;
 var HISTORY_WINDOW_RUNS = Math.max(PERSISTENT_GAP_THRESHOLD, 5);
@@ -4537,6 +4705,11 @@ var IntelligenceService = class {
     });
   }
   buildRunData(runId, projectId, completedAt, location = null) {
+    const projectDomainRow = this.db.select({ canonicalDomain: projects.canonicalDomain, ownedDomains: projects.ownedDomains }).from(projects).where(eq(projects.id, projectId)).get();
+    const projectDomains = projectDomainRow ? effectiveDomains({
+      canonicalDomain: projectDomainRow.canonicalDomain,
+      ownedDomains: projectDomainRow.ownedDomains
+    }) : [];
     const rows = this.db.select({
       query: queries.query,
       // Denormalized query text persisted by v58 — the fallback when the
@@ -4563,7 +4736,9 @@ var IntelligenceService = class {
         query: resolvedQuery,
         provider: r.provider,
         cited: r.citationState === CitationStates.cited,
-        citationUrl: domains[0] ?? void 0,
+        // The project's OWN cited domain — never a co-cited competitor that
+        // happens to sort first in the full citedDomains set.
+        citationUrl: pickProjectCitedDomain(domains, projectDomains),
         // Snapshots carry their own location for downstream detectors. In
         // practice every snapshot in a single runId shares the run's
         // location; the per-row column is the same value duplicated, but
@@ -4629,6 +4804,9 @@ export {
   groupRunsByCreatedAt,
   pickGroupRepresentative,
   filterTrackedSnapshots,
+  determineCitationState,
+  computeCompetitorOverlap,
+  extractRecommendedCompetitors,
   isBlogShapedQuery,
   buildInventory,
   buildContentTargetRows,