@canonry/canonry 7.77.1 → 7.78.0

package/dist/{chunk-FCGYYZHL.js → chunk-PM2DB3HE.js}

@@ -13524,6 +13524,8 @@ var STORED_READ_OPERATIONS = /* @__PURE__ */ new Set([
   "GET /api/v1/projects/{name}/seo/keyword-metrics",
   "GET /api/v1/projects/{name}/seo/domain-intelligence",
   "GET /api/v1/projects/{name}/seo/ranked-keywords",
+  "GET /api/v1/projects/{name}/seo/competitors",
+  "GET /api/v1/projects/{name}/seo/keyword-gaps",
   "GET /api/v1/projects/{name}/seo/market-rankings",
   "GET /api/v1/projects/{name}/seo/market-rankings/summary",
   "GET /api/v1/projects/{name}/gbp/local-post-attempt",
@@ -21270,7 +21272,7 @@ function uncheckedSourcesLabel(value) {
 
 // ../contracts/src/seo.ts
 import { z as z66 } from "zod";
-var seoCapabilitySchema = z66.enum(["keyword-metrics", "domain-intelligence", "ranked-keywords", "market-rankings"]);
+var seoCapabilitySchema = z66.enum(["keyword-metrics", "domain-intelligence", "ranked-keywords", "market-rankings", "competitor-discovery", "keyword-gaps"]);
 var SeoCapabilities = seoCapabilitySchema.enum;
 var seoProviderSchema = z66.enum(["dataforseo"]);
 var SeoProviders = seoProviderSchema.enum;
@@ -21318,8 +21320,10 @@ var seoRankingSettingsSchema = z66.object({
 var seoProfileInputSchema = z66.object({
   name: z66.string().trim().min(1).max(120),
   connectionId: z66.string().min(1).max(100),
-  capabilities: z66.array(seoCapabilitySchema).min(1).max(4),
+  capabilities: z66.array(seoCapabilitySchema).min(1).max(6),
   targets: z66.array(seoTargetSchema).max(20),
+  /** Explicit comparison domains; saving them never starts provider work. */
+  competitors: z66.array(seoTargetSchema).max(5).optional(),
   keywords: z66.array(z66.string().trim().min(1).max(80).regex(/^\S+(?:\s+\S+){0,9}$/, "Use at most 10 words per keyword.")).max(700),
   locationCode: z66.number().int().positive(),
   languageCode: z66.string().min(2).max(10),
@@ -21431,6 +21435,41 @@ var seoRankedKeywordSchema = z66.object({
   serpFeatures: z66.array(z66.string()),
   provenance: seoProvenanceSchema
 }).strict();
+var seoCompetitorSchema = z66.object({
+  target: seoTargetSchema,
+  domain: z66.string(),
+  sharedKeywords: z66.number().int().nonnegative().nullable(),
+  /** The competitor's average organic position across shared searches. */
+  averagePosition: z66.number().nonnegative().nullable(),
+  organicKeywords: z66.number().int().nonnegative().nullable(),
+  estimatedOrganicTraffic: z66.number().nonnegative().nullable(),
+  provenance: seoProvenanceSchema
+}).strict();
+var seoKeywordGapModeSchema = z66.enum(["shared", "missing"]);
+var SeoKeywordGapModes = seoKeywordGapModeSchema.enum;
+var seoKeywordGapKindSchema = z66.enum(["shared", "missing", "outranked"]);
+var SeoKeywordGapKinds = seoKeywordGapKindSchema.enum;
+var seoKeywordGapSchema = z66.object({
+  target: seoTargetSchema,
+  competitor: seoTargetSchema,
+  keyword: z66.string(),
+  targetRankOrganic: z66.number().int().positive().nullable(),
+  competitorRankOrganic: z66.number().int().positive(),
+  targetUrl: z66.string().nullable(),
+  competitorUrl: z66.string().nullable(),
+  searchVolume: z66.number().int().nonnegative().nullable(),
+  keywordDifficulty: z66.number().min(0).max(100).nullable().describe("Provider difficulty score on a 0\u2013100 scale; not a percentage."),
+  cpcUsd: z66.number().nonnegative().nullable(),
+  kind: seoKeywordGapKindSchema,
+  /** Target organic position minus competitor position; positive means the competitor is ahead. Null when the target is absent. */
+  rankGap: z66.number().int().nullable(),
+  provenance: seoProvenanceSchema
+}).strict();
+function seoKeywordGapComparison(targetRankOrganic, competitorRankOrganic) {
+  if (targetRankOrganic === null) return { kind: SeoKeywordGapKinds.missing, rankGap: null };
+  const rankGap = targetRankOrganic - competitorRankOrganic;
+  return { kind: rankGap > 0 ? SeoKeywordGapKinds.outranked : SeoKeywordGapKinds.shared, rankGap };
+}
 var seoMarketRankingContextSchema = z66.object({
   marketKey: z66.string(),
   marketLabel: z66.string(),
@@ -21465,16 +21504,21 @@ var SeoMarketRankingOutcomes = seoMarketRankingOutcomeSchema.enum;
 var seoMarketRankingRowSchema = seoMarketRankingSchema.extend({
   outcome: seoMarketRankingOutcomeSchema,
   /** A tracked competitor ranks above the target in these results, or ranks while the target is not in them. */
-  rivalAhead: z66.boolean()
+  rivalAhead: z66.boolean(),
+  topCompetitor: seoMarketRankingCompetitorSchema.nullable(),
+  /** Target position minus the best tracked competitor's position; null if either position is unavailable. */
+  rankGap: z66.number().int().nullable()
 }).strict();
 var seoResultsSchema = z66.object({
   keywordMetrics: z66.array(seoKeywordMetricsSchema),
   domainIntelligence: z66.array(seoDomainIntelligenceSchema),
   rankedKeywords: z66.array(seoRankedKeywordSchema),
-  marketRankings: z66.array(seoMarketRankingSchema)
+  marketRankings: z66.array(seoMarketRankingSchema),
+  competitors: z66.array(seoCompetitorSchema),
+  keywordGaps: z66.array(seoKeywordGapSchema)
 }).strict();
 function emptySeoResults() {
-  return { keywordMetrics: [], domainIntelligence: [], rankedKeywords: [], marketRankings: [] };
+  return { keywordMetrics: [], domainIntelligence: [], rankedKeywords: [], marketRankings: [], competitors: [], keywordGaps: [] };
 }
 function marketRegionName(marketLabel) {
   const comma = marketLabel.lastIndexOf(",");
@@ -21514,6 +21558,8 @@ var seoTaskSchema = z66.object({
   id: z66.string(),
   capability: seoCapabilitySchema,
   target: seoTargetSchema.nullable(),
+  /** Keyword gaps: the comparison domain and shared/missing population, including failed tasks. */
+  comparison: z66.object({ competitor: seoTargetSchema, mode: seoKeywordGapModeSchema }).strict().nullable(),
   status: seoRunStatusSchema,
   error: z66.string().nullable(),
   remoteTaskId: z66.string().nullable(),
@@ -21527,7 +21573,9 @@ var seoResultCountsSchema = z66.object({
   keywordMetrics: z66.number().int().nonnegative(),
   domainIntelligence: z66.number().int().nonnegative(),
   rankedKeywords: z66.number().int().nonnegative(),
-  marketRankings: z66.number().int().nonnegative()
+  marketRankings: z66.number().int().nonnegative(),
+  competitors: z66.number().int().nonnegative(),
+  keywordGaps: z66.number().int().nonnegative()
 }).strict();
 var seoRunDetailSchema = seoRunSchema.extend({
   tasks: z66.array(seoTaskSchema),
@@ -21551,6 +21599,18 @@ var seoPageShape = {
 var seoKeywordMetricsListSchema = z66.object({ ...seoPageShape, items: z66.array(seoKeywordMetricsSchema) }).strict();
 var seoDomainIntelligenceListSchema = z66.object({ ...seoPageShape, items: z66.array(seoDomainIntelligenceSchema) }).strict();
 var seoRankedKeywordListSchema = z66.object({ ...seoPageShape, items: z66.array(seoRankedKeywordSchema) }).strict();
+var seoCompetitorListSchema = z66.object({ ...seoPageShape, items: z66.array(seoCompetitorSchema) }).strict();
+var seoKeywordGapListSchema = z66.object({ ...seoPageShape, items: z66.array(seoKeywordGapSchema) }).strict();
+var seoCompetitorSortSchema = z66.enum(["domain", "-domain", "shared", "-shared", "position", "-position", "traffic", "-traffic"]);
+var SeoCompetitorSorts = seoCompetitorSortSchema.enum;
+var seoKeywordGapSortSchema = z66.enum(["keyword", "-keyword", "kind", "-kind", "target-rank", "-target-rank", "competitor-rank", "-competitor-rank", "rank-gap", "-rank-gap", "volume", "-volume"]);
+var SeoKeywordGapSorts = seoKeywordGapSortSchema.enum;
+var seoCompetitorQuerySchema = seoEvidenceQuerySchema.extend({ sort: seoCompetitorSortSchema.optional() }).strict();
+var seoKeywordGapQuerySchema = seoEvidenceQuerySchema.extend({
+  /** Shared includes the outranked subset; missing and outranked select their exact category. */
+  kind: seoKeywordGapKindSchema.optional(),
+  sort: seoKeywordGapSortSchema.optional()
+}).strict();
 var seoMarketRankingFilterSchema = z66.enum(["needs-work", "page-1", "ranks-11-20", "ranks-21-plus", "not-ranked", "partly-checked", "rival-ahead", "failed", "cancelled"]);
 var SeoMarketRankingFilters = seoMarketRankingFilterSchema.enum;
 var seoMarketRankingSortSchema = z66.enum(["market", "rank", "-rank", "query", "-query"]);
@@ -21619,7 +21679,9 @@ var seoOverviewSchema = z66.object({
   domainIntelligenceCount: z66.number().int().nonnegative(),
   rankedKeywordCount: z66.number().int().nonnegative(),
   /** Rows the market-rankings read returns for the evidence refresh, searches that failed or never ran included. */
-  marketRankingCount: z66.number().int().nonnegative()
+  marketRankingCount: z66.number().int().nonnegative(),
+  competitorCount: z66.number().int().nonnegative(),
+  keywordGapCount: z66.number().int().nonnegative()
 }).strict();
 var seoMicrosSchema = z66.number().int().min(0).max(Number.MAX_SAFE_INTEGER);
 var seoOperatorTaskSchema = z66.object({
@@ -26325,8 +26387,16 @@ function outcomeOf(row) {
   }
 }
 function marketRankingRow(row) {
-  const best = bestCompetitorRank(row.competitors);
-  return { ...row, outcome: outcomeOf(row), rivalAhead: best !== null && (row.rankOrganic === null || best < row.rankOrganic) };
+  const hasResult = row.searchStatus === SeoMarketRankingSearchStatuses.completed || row.searchStatus === SeoMarketRankingSearchStatuses.partial;
+  const topCompetitor = hasResult ? [...row.competitors].sort((a, b) => a.rankOrganic - b.rankOrganic || compareText(a.domain, b.domain))[0] ?? null : null;
+  const best = topCompetitor?.rankOrganic ?? null;
+  return {
+    ...row,
+    outcome: outcomeOf(row),
+    rivalAhead: best !== null && (row.rankOrganic === null || best < row.rankOrganic),
+    topCompetitor,
+    rankGap: row.rankOrganic === null || best === null ? null : row.rankOrganic - best
+  };
 }
 function matchesMarketRankingFilter(row, filter) {
   switch (filter) {
@@ -26455,6 +26525,77 @@ function groupMarketRankings(rows, scope) {
   return [...groups.values()].map((group) => ({ key: group.key, label: group.label, kind: group.kind, counts: countMarketRankings(group.rows) })).sort((a, b) => b.counts.ranks11To20 - a.counts.ranks11To20 || b.counts.ranks21Plus - a.counts.ranks21Plus || compareText(a.label, b.label) || compareText(a.key, b.key));
 }
 
+// ../contracts/src/seo-research-sort.ts
+function numberOrder(value, direction, identity) {
+  return (a, b) => {
+    const left = value(a);
+    const right = value(b);
+    if (left === null || right === null) return left === right ? identity(a, b) : left === null ? 1 : -1;
+    return direction * (left - right) || identity(a, b);
+  };
+}
+function textOrder(value, direction, identity) {
+  return (a, b) => direction * compareText(value(a).toLowerCase(), value(b).toLowerCase()) || identity(a, b);
+}
+var competitorIdentity = (a, b) => compareText(a.target.value, b.target.value) || compareText(a.domain, b.domain);
+var gapIdentity = (a, b) => compareText(a.target.value, b.target.value) || compareText(a.competitor.value, b.competitor.value) || compareText(a.keyword, b.keyword);
+function compareSeoCompetitorsBy(sort) {
+  switch (sort) {
+    case SeoCompetitorSorts.domain:
+      return textOrder((row) => row.domain, 1, competitorIdentity);
+    case SeoCompetitorSorts["-domain"]:
+      return textOrder((row) => row.domain, -1, competitorIdentity);
+    case SeoCompetitorSorts.shared:
+      return numberOrder((row) => row.sharedKeywords, 1, competitorIdentity);
+    case SeoCompetitorSorts["-shared"]:
+      return numberOrder((row) => row.sharedKeywords, -1, competitorIdentity);
+    case SeoCompetitorSorts.position:
+      return numberOrder((row) => row.averagePosition, 1, competitorIdentity);
+    case SeoCompetitorSorts["-position"]:
+      return numberOrder((row) => row.averagePosition, -1, competitorIdentity);
+    case SeoCompetitorSorts.traffic:
+      return numberOrder((row) => row.estimatedOrganicTraffic, 1, competitorIdentity);
+    case SeoCompetitorSorts["-traffic"]:
+      return numberOrder((row) => row.estimatedOrganicTraffic, -1, competitorIdentity);
+    default: {
+      const unknown = sort;
+      return unknown;
+    }
+  }
+}
+function compareSeoKeywordGapsBy(sort) {
+  switch (sort) {
+    case SeoKeywordGapSorts.keyword:
+      return textOrder((row) => row.keyword, 1, gapIdentity);
+    case SeoKeywordGapSorts["-keyword"]:
+      return textOrder((row) => row.keyword, -1, gapIdentity);
+    case SeoKeywordGapSorts.kind:
+      return textOrder((row) => row.kind, 1, gapIdentity);
+    case SeoKeywordGapSorts["-kind"]:
+      return textOrder((row) => row.kind, -1, gapIdentity);
+    case SeoKeywordGapSorts["target-rank"]:
+      return numberOrder((row) => row.targetRankOrganic, 1, gapIdentity);
+    case SeoKeywordGapSorts["-target-rank"]:
+      return numberOrder((row) => row.targetRankOrganic, -1, gapIdentity);
+    case SeoKeywordGapSorts["competitor-rank"]:
+      return numberOrder((row) => row.competitorRankOrganic, 1, gapIdentity);
+    case SeoKeywordGapSorts["-competitor-rank"]:
+      return numberOrder((row) => row.competitorRankOrganic, -1, gapIdentity);
+    case SeoKeywordGapSorts["rank-gap"]:
+      return numberOrder((row) => row.rankGap, 1, gapIdentity);
+    case SeoKeywordGapSorts["-rank-gap"]:
+      return numberOrder((row) => row.rankGap, -1, gapIdentity);
+    case SeoKeywordGapSorts.volume:
+      return numberOrder((row) => row.searchVolume, 1, gapIdentity);
+    case SeoKeywordGapSorts["-volume"]:
+      return numberOrder((row) => row.searchVolume, -1, gapIdentity);
+    default: {
+      const unknown = sort;
+      return unknown;
+    }
+  }
+}
+
 export {
   GBP_POSTS_WRITE_SCOPE,
   GBP_LIVE_READ_SCOPE,
@@ -27699,6 +27840,11 @@ export {
   seoRefreshIntentInputSchema,
   seoQuoteSchema,
   seoSyncInputSchema,
+  seoKeywordGapModeSchema,
+  SeoKeywordGapModes,
+  seoKeywordGapKindSchema,
+  SeoKeywordGapKinds,
+  seoKeywordGapComparison,
   SeoMarketRankingSearchStatuses,
   SeoMarketRankingOutcomes,
   emptySeoResults,
@@ -27710,6 +27856,12 @@ export {
   seoKeywordMetricsListSchema,
   seoDomainIntelligenceListSchema,
   seoRankedKeywordListSchema,
+  seoCompetitorListSchema,
+  seoKeywordGapListSchema,
+  seoCompetitorSortSchema,
+  seoKeywordGapSortSchema,
+  seoCompetitorQuerySchema,
+  seoKeywordGapQuerySchema,
   seoMarketRankingFilterSchema,
   seoMarketRankingSortSchema,
   SeoMarketRankingSorts,
@@ -27728,5 +27880,7 @@ export {
   compareMarketRankingsBy,
   marketRankingBands,
   countMarketRankings,
-  groupMarketRankings
+  groupMarketRankings,
+  compareSeoCompetitorsBy,
+  compareSeoKeywordGapsBy
 };

package/dist/{chunk-TRW4XLQK.js → chunk-QXSOXDUR.js}

@@ -4,14 +4,14 @@ import {
 } from "./chunk-VJWDBFSL.js";
 import {
   createApiClient
-} from "./chunk-X7UC755Q.js";
+} from "./chunk-C5WSQXP5.js";
 import {
   CliError,
   isMachineFormat
 } from "./chunk-HGMYEDAQ.js";
 import {
   describeError
-} from "./chunk-FCGYYZHL.js";
+} from "./chunk-PM2DB3HE.js";
 
 // src/commands/mcp.ts
 import fs from "fs";

package/dist/{chunk-2SCPPWRW.js → chunk-RSVANBNW.js}

@@ -2,16 +2,16 @@ import {
   CANONRY_MCP_TOOLKITS,
   CANONRY_MCP_TOOLKIT_NAMES,
   isCanonryMcpToolkitName
-} from "./chunk-NDTU7FGL.js";
+} from "./chunk-WVCDUKJ2.js";
 import {
   createApiClient,
   runWithUsageTags
-} from "./chunk-X7UC755Q.js";
+} from "./chunk-C5WSQXP5.js";
 import {
   canonryMcpTools,
   mcpOutputSchema,
   toolOperationAccess
-} from "./chunk-4QHTXT4A.js";
+} from "./chunk-MUYTDD35.js";
 import {
   PACKAGE_VERSION
 } from "./chunk-AOJU5LKX.js";
@@ -24,7 +24,7 @@ import {
   isReadOnlyKey,
   restrictedWriteScopes,
   upgradeCaveatFor
-} from "./chunk-FCGYYZHL.js";
+} from "./chunk-PM2DB3HE.js";
 
 // src/mcp/server.ts
 import { randomUUID } from "crypto";

package/dist/{chunk-UB65XBH2.js → chunk-SAHH2FXO.js}

@@ -1,13 +1,13 @@
 import {
   createApiClient
-} from "./chunk-X7UC755Q.js";
+} from "./chunk-C5WSQXP5.js";
 import {
   emitJsonl
 } from "./chunk-Z7IUAJOF.js";
 import {
   measurementDraftOperationSchema,
   runMeasurementDraftAction
-} from "./chunk-5QR7D4RQ.js";
+} from "./chunk-7HB6QLX4.js";
 import {
   isMachineFormat,
   systemError
@@ -37,7 +37,7 @@ import {
   unattributedAnswersLabel,
   uncheckedSourcesLabel,
   visibilityReportRequestSchema
-} from "./chunk-FCGYYZHL.js";
+} from "./chunk-PM2DB3HE.js";
 
 // src/commands/measurement-plan.ts
 import crypto from "crypto";

package/dist/{chunk-46KV7CZU.js → chunk-SOQVI7EZ.js}

@@ -5,7 +5,7 @@ import {
   siteCrawlGraphNodes,
   siteCrawlPages,
   siteCrawlSnapshots
-} from "./chunk-D5XPB7MM.js";
+} from "./chunk-6VBLPCCX.js";
 import {
   SITE_CRAWL_GRAPH_MAX_EDGES,
   SITE_CRAWL_GRAPH_MAX_NODES,
@@ -15,7 +15,7 @@ import {
   factorStatusFromDistribution,
   factorStatusFromScore,
   roundPreservingTotal
-} from "./chunk-FCGYYZHL.js";
+} from "./chunk-PM2DB3HE.js";
 
 // src/site-audit-factors.ts
 function recordedSharePct(factor) {

package/dist/{chunk-Z2FY6AGZ.js → chunk-TZRYVW75.js}

@@ -1,11 +1,11 @@
 import {
   getRequestContext
-} from "./chunk-JPOIDGGF.js";
+} from "./chunk-3MGM3U6V.js";
 import {
   diagnosticIdentity,
   redactLogString,
   redactLogValue
-} from "./chunk-FCGYYZHL.js";
+} from "./chunk-PM2DB3HE.js";
 
 // ../api-routes/src/runtime-logger.ts
 import { format } from "util";

package/dist/{chunk-C3UFOS7J.js → chunk-UH44UCRM.js}

@@ -1,6 +1,6 @@
 import {
   parseJsonColumn
-} from "./chunk-D5XPB7MM.js";
+} from "./chunk-6VBLPCCX.js";
 import {
   AI_ENGINE_DOMAINS,
   AI_ENGINE_SELF_DOMAINS,
@@ -26,7 +26,7 @@ import {
   retryAfterDelayMs,
   usageCount,
   withRetry
-} from "./chunk-FCGYYZHL.js";
+} from "./chunk-PM2DB3HE.js";
 
 // ../provider-openai/src/normalize.ts
 import OpenAI from "openai";

package/dist/{chunk-TJYS2XCI.js → chunk-UQOC5ZQE.js}

@@ -2,13 +2,13 @@ import {
   bucketCliCommandDuration,
   isTelemetryEnabled,
   trackEvent
-} from "./chunk-YMOQSEO3.js";
+} from "./chunk-6PRFVLIK.js";
 import {
   getConfigDir
-} from "./chunk-2BRVGCVU.js";
+} from "./chunk-VLOCDWCS.js";
 import {
   currentOutcomeAttribution
-} from "./chunk-JPOIDGGF.js";
+} from "./chunk-3MGM3U6V.js";
 import {
   AGENT_NONE,
   OutcomeSurfaces,
@@ -19,7 +19,7 @@ import {
   integrationConnectionPropertiesSchema,
   normalizeAgentSlug,
   usageSurfaceSchema
-} from "./chunk-FCGYYZHL.js";
+} from "./chunk-PM2DB3HE.js";
 
 // src/outcome-telemetry.ts
 import fs from "fs";

package/dist/{chunk-2BRVGCVU.js → chunk-VLOCDWCS.js}

@@ -20,7 +20,7 @@ import {
   resolveProviderModel,
   schedulableRunKindSchema,
   sentimentEvaluatorProviderSchema
-} from "./chunk-FCGYYZHL.js";
+} from "./chunk-PM2DB3HE.js";
 
 // ../config/src/index.ts
 import { z as z5 } from "zod";
@@ -1011,6 +1011,10 @@ function getConfigDir() {
 function getConfigPath() {
   return path.join(getConfigDir(), "config.yaml");
 }
+var loadedConfigPaths = /* @__PURE__ */ new WeakMap();
+function loadedConfigPath(config) {
+  return loadedConfigPaths.get(config);
+}
 function loadConfig(configPath = getConfigPath()) {
   if (!fs.existsSync(configPath)) {
     throw new Error(
@@ -1159,6 +1163,7 @@ Do not use "canonry init --force" for recovery. It replaces credentials without
   if (parsedExternalMcp) {
     parsed.externalMcpServers = parsedExternalMcp;
   }
+  loadedConfigPaths.set(parsed, path.resolve(configPath));
   return parsed;
 }
 function parseExternalMcpEnv(raw) {
@@ -1354,6 +1359,7 @@ export {
   providersWithUnsupportedBatch,
   getConfigDir,
   getConfigPath,
+  loadedConfigPath,
   loadConfig,
   loadConfigRaw,
   saveConfig,