@ainyc/canonry 4.24.1 → 4.26.0

package/dist/{chunk-EUGCQSFC.js → chunk-HVW665A4.js}

@@ -88,7 +88,9 @@ var runKindSchema = z2.enum([
   "bing-inspect",
   "bing-inspect-sitemap",
   "backlink-extract",
-  "traffic-sync"
+  "traffic-sync",
+  "aeo-discover-seed",
+  "aeo-discover-probe"
 ]);
 var RunKinds = runKindSchema.enum;
 var runTriggerSchema = z2.enum(["manual", "scheduled", "config-apply", "backfill"]);
@@ -103,6 +105,7 @@ var runTriggerRequestSchema = z2.object({
   kind: z2.literal(RunKinds["answer-visibility"]).optional(),
   trigger: z2.literal(RunTriggers.manual).optional(),
   providers: z2.array(providerNameSchema).optional(),
+  queries: z2.array(z2.string().min(1)).min(1).optional(),
   location: z2.string().min(1).optional(),
   allLocations: z2.boolean().optional(),
   noLocation: z2.boolean().optional()
@@ -129,6 +132,7 @@ var runDtoSchema = z2.object({
   status: runStatusSchema,
   trigger: runTriggerSchema.default("manual"),
   location: z2.string().nullable().optional(),
+  queries: z2.array(z2.string()).nullable().optional(),
   startedAt: z2.string().nullable().optional(),
   finishedAt: z2.string().nullable().optional(),
   error: runErrorSchema.nullable().optional(),
@@ -2348,6 +2352,128 @@ var trafficEventsResponseSchema = z20.object({
   events: z20.array(trafficEventEntrySchema)
 });
 
+// ../contracts/src/discovery.ts
+import { z as z21 } from "zod";
+var discoveryBucketSchema = z21.enum(["cited", "aspirational", "wasted-surface"]);
+var DiscoveryBuckets = discoveryBucketSchema.enum;
+var discoverySessionStatusSchema = z21.enum(["queued", "seeding", "probing", "completed", "failed"]);
+var DiscoverySessionStatuses = discoverySessionStatusSchema.enum;
+var discoveryCompetitorMapEntrySchema = z21.object({
+  domain: z21.string().min(1),
+  hits: z21.number().int().positive()
+});
+var discoveryProbeDtoSchema = z21.object({
+  id: z21.string(),
+  sessionId: z21.string(),
+  projectId: z21.string(),
+  query: z21.string(),
+  bucket: discoveryBucketSchema.nullable().default(null),
+  citationState: citationStateSchema,
+  citedDomains: z21.array(z21.string()).default([]),
+  createdAt: z21.string()
+});
+var discoverySessionDtoSchema = z21.object({
+  id: z21.string(),
+  projectId: z21.string(),
+  status: discoverySessionStatusSchema,
+  icpDescription: z21.string().nullable().optional(),
+  seedProvider: z21.string().nullable().optional(),
+  seedCountRaw: z21.number().int().nullable().optional(),
+  seedCount: z21.number().int().nullable().optional(),
+  dedupThreshold: z21.number().nullable().optional(),
+  probeCount: z21.number().int().nullable().optional(),
+  citedCount: z21.number().int().nullable().default(null),
+  aspirationalCount: z21.number().int().nullable().default(null),
+  wastedCount: z21.number().int().nullable().default(null),
+  competitorMap: z21.array(discoveryCompetitorMapEntrySchema).default([]),
+  error: z21.string().nullable().optional(),
+  startedAt: z21.string().nullable().optional(),
+  finishedAt: z21.string().nullable().optional(),
+  createdAt: z21.string()
+});
+var discoverySessionDetailDtoSchema = discoverySessionDtoSchema.extend({
+  probes: z21.array(discoveryProbeDtoSchema).default([])
+});
+var DISCOVERY_MAX_PROBES_CAP = 500;
+var discoveryRunRequestSchema = z21.object({
+  icpDescription: z21.string().min(1).optional(),
+  dedupThreshold: z21.number().min(0).max(1).optional(),
+  maxProbes: z21.number().int().positive().max(DISCOVERY_MAX_PROBES_CAP).optional()
+});
+var queryProvenanceSchema = z21.union([
+  z21.literal("cli"),
+  z21.string().regex(/^discovery:.+$/)
+]);
+
+// ../contracts/src/embeddings.ts
+function cosineSimilarity(a, b) {
+  if (a.length === 0 || b.length === 0) {
+    throw new Error("cosineSimilarity: vectors must be non-empty");
+  }
+  if (a.length !== b.length) {
+    throw new Error(`cosineSimilarity: vector length mismatch (${a.length} vs ${b.length})`);
+  }
+  let dot = 0;
+  let magA = 0;
+  let magB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    magA += a[i] * a[i];
+    magB += b[i] * b[i];
+  }
+  if (magA === 0 || magB === 0) return 0;
+  return dot / (Math.sqrt(magA) * Math.sqrt(magB));
+}
+function clusterByCosine(items, vectors, threshold) {
+  if (threshold < 0 || threshold > 1) {
+    throw new Error(`clusterByCosine: threshold must be in [0, 1], got ${threshold}`);
+  }
+  if (items.length !== vectors.length) {
+    throw new Error(`clusterByCosine: items/vectors length mismatch (${items.length} vs ${vectors.length})`);
+  }
+  if (items.length === 0) return [];
+  const parent = items.map((_, i) => i);
+  const find = (x) => {
+    let root = x;
+    while (parent[root] !== root) root = parent[root];
+    let cur = x;
+    while (parent[cur] !== root) {
+      const next = parent[cur];
+      parent[cur] = root;
+      cur = next;
+    }
+    return root;
+  };
+  const union = (a, b) => {
+    const ra = find(a);
+    const rb = find(b);
+    if (ra !== rb) parent[ra] = rb;
+  };
+  for (let i = 0; i < items.length; i++) {
+    for (let j = i + 1; j < items.length; j++) {
+      if (cosineSimilarity(vectors[i], vectors[j]) >= threshold) {
+        union(i, j);
+      }
+    }
+  }
+  const byRoot = /* @__PURE__ */ new Map();
+  for (let i = 0; i < items.length; i++) {
+    const root = find(i);
+    const existing = byRoot.get(root);
+    if (existing) existing.push(i);
+    else byRoot.set(root, [i]);
+  }
+  return Array.from(byRoot.values()).map((indices) => indices.map((idx) => items[idx]));
+}
+function pickClusterRepresentative(cluster) {
+  if (cluster.length === 0) throw new Error("pickClusterRepresentative: cluster is empty");
+  let best = cluster[0];
+  for (let i = 1; i < cluster.length; i++) {
+    if (cluster[i].length < best.length) best = cluster[i];
+  }
+  return best;
+}
+
 // ../contracts/src/formatting.ts
 function formatRatio(value) {
   if (!Number.isFinite(value) || value === 0) return "0%";
@@ -2451,6 +2577,7 @@ export {
   RunStatuses,
   RunKinds,
   RunTriggers,
+  citationStateSchema,
   CitationStates,
   runTriggerRequestSchema,
   parseRunError,
@@ -2508,6 +2635,13 @@ export {
   trafficConnectWordpressRequestSchema,
   trafficEventKindSchema,
   TrafficEventKinds,
+  discoveryBucketSchema,
+  DiscoveryBuckets,
+  DiscoverySessionStatuses,
+  DISCOVERY_MAX_PROBES_CAP,
+  discoveryRunRequestSchema,
+  clusterByCosine,
+  pickClusterRepresentative,
   formatRatio,
   formatNumber,
   formatDate,

package/dist/{chunk-OYYFXKRK.js → chunk-PN24DAGC.js}

@@ -8,7 +8,7 @@ import {
   categoryLabel,
   determineAnswerMentioned,
   normalizeProjectDomain
-} from "./chunk-EUGCQSFC.js";
+} from "./chunk-HVW665A4.js";
 
 // src/intelligence-service.ts
 import { eq, desc, asc, and, or, inArray } from "drizzle-orm";
@@ -36,6 +36,8 @@ __export(schema_exports, {
   ccReleaseSyncs: () => ccReleaseSyncs,
   competitors: () => competitors,
   crawlerEventsHourly: () => crawlerEventsHourly,
+  discoveryProbes: () => discoveryProbes,
+  discoverySessions: () => discoverySessions,
   gaAiReferrals: () => gaAiReferrals,
   gaConnections: () => gaConnections,
   gaSocialReferrals: () => gaSocialReferrals,
@@ -59,7 +61,7 @@ __export(schema_exports, {
   trafficSources: () => trafficSources,
   usageCounters: () => usageCounters
 });
-import { index, integer, primaryKey, sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core";
+import { index, integer, primaryKey, real, sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core";
 var projects = sqliteTable("projects", {
   id: text("id").primaryKey(),
   name: text("name").notNull().unique(),
@@ -76,6 +78,7 @@ var projects = sqliteTable("projects", {
   autoExtractBacklinks: integer("auto_extract_backlinks").notNull().default(0),
   configSource: text("config_source").notNull().default("cli"),
   configRevision: integer("config_revision").notNull().default(1),
+  icpDescription: text("icp_description"),
   createdAt: text("created_at").notNull(),
   updatedAt: text("updated_at").notNull()
 });
@@ -83,6 +86,7 @@ var queries = sqliteTable("queries", {
   id: text("id").primaryKey(),
   projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
   query: text("query").notNull(),
+  provenance: text("provenance"),
   createdAt: text("created_at").notNull()
 }, (table) => [
   index("idx_queries_project").on(table.projectId),
@@ -92,6 +96,7 @@ var competitors = sqliteTable("competitors", {
   id: text("id").primaryKey(),
   projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
   domain: text("domain").notNull(),
+  provenance: text("provenance"),
   createdAt: text("created_at").notNull()
 }, (table) => [
   index("idx_competitors_project").on(table.projectId),
@@ -104,6 +109,7 @@ var runs = sqliteTable("runs", {
   status: text("status").notNull().default("queued"),
   trigger: text("trigger").notNull().default("manual"),
   location: text("location"),
+  queries: text("queries"),
   sourceId: text("source_id"),
   startedAt: text("started_at"),
   finishedAt: text("finished_at"),
@@ -653,6 +659,43 @@ var rawEventSamples = sqliteTable("raw_event_samples", {
   index("idx_raw_event_samples_source_ts").on(table.sourceId, table.ts),
   index("idx_raw_event_samples_event_type").on(table.eventType)
 ]);
+var discoverySessions = sqliteTable("discovery_sessions", {
+  id: text("id").primaryKey(),
+  projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+  runId: text("run_id"),
+  status: text("status").notNull().default("queued"),
+  icpDescription: text("icp_description"),
+  seedProvider: text("seed_provider"),
+  seedCountRaw: integer("seed_count_raw"),
+  seedCount: integer("seed_count"),
+  dedupThreshold: real("dedup_threshold"),
+  probeCount: integer("probe_count"),
+  citedCount: integer("cited_count"),
+  aspirationalCount: integer("aspirational_count"),
+  wastedCount: integer("wasted_count"),
+  competitorMap: text("competitor_map").notNull().default("[]"),
+  error: text("error"),
+  startedAt: text("started_at"),
+  finishedAt: text("finished_at"),
+  createdAt: text("created_at").notNull()
+}, (table) => [
+  index("idx_discovery_sessions_project_created").on(table.projectId, table.createdAt),
+  index("idx_discovery_sessions_run").on(table.runId)
+]);
+var discoveryProbes = sqliteTable("discovery_probes", {
+  id: text("id").primaryKey(),
+  sessionId: text("session_id").notNull().references(() => discoverySessions.id, { onDelete: "cascade" }),
+  projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+  query: text("query").notNull(),
+  bucket: text("bucket"),
+  citationState: text("citation_state").notNull(),
+  citedDomains: text("cited_domains").notNull().default("[]"),
+  rawResponse: text("raw_response"),
+  createdAt: text("created_at").notNull()
+}, (table) => [
+  index("idx_discovery_probes_session").on(table.sessionId),
+  index("idx_discovery_probes_project").on(table.projectId)
+]);
 var migrationsTable = sqliteTable("_migrations", {
   version: integer("version").primaryKey(),
   name: text("name").notNull(),
@@ -1681,6 +1724,86 @@ var MIGRATION_VERSIONS = [
     statements: [
       `DROP INDEX IF EXISTS idx_schedules_project`
     ]
+  },
+  {
+    version: 55,
+    name: "discovery-foundation",
+    // Adds the three-ring discovery foundation: per-project ICP, query/competitor
+    // provenance (so we can trace adopted basket entries back to a discovery
+    // session), and the two tables that hold a discovery session's research
+    // output. No UNIQUE(session_id, query) on discovery_probes — v2 will probe
+    // the same query across multiple providers in the same session.
+    //
+    // `competitor_map` defaults to '[]' (JSON array) — see DTO
+    // `discoveryCompetitorMapEntrySchema` for the entry shape `{domain, hits}`.
+    // Backfill of `provenance='cli'` runs once: existing pre-v55 rows are
+    // attributed to manual CLI entry so a future NULL distinctly means
+    // "post-v55 row missing provenance" (a bug to catch in review).
+    statements: [
+      `ALTER TABLE projects ADD COLUMN icp_description TEXT`,
+      `ALTER TABLE queries ADD COLUMN provenance TEXT`,
+      `ALTER TABLE competitors ADD COLUMN provenance TEXT`,
+      `UPDATE queries SET provenance = 'cli' WHERE provenance IS NULL`,
+      `UPDATE competitors SET provenance = 'cli' WHERE provenance IS NULL`,
+      `CREATE TABLE IF NOT EXISTS discovery_sessions (
+         id                  TEXT PRIMARY KEY,
+         project_id          TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+         status              TEXT NOT NULL DEFAULT 'queued',
+         icp_description     TEXT,
+         seed_provider       TEXT,
+         seed_count_raw      INTEGER,
+         seed_count          INTEGER,
+         dedup_threshold     REAL,
+         probe_count         INTEGER,
+         cited_count         INTEGER,
+         aspirational_count  INTEGER,
+         wasted_count        INTEGER,
+         competitor_map      TEXT NOT NULL DEFAULT '[]',
+         error               TEXT,
+         started_at          TEXT,
+         finished_at         TEXT,
+         created_at          TEXT NOT NULL
+       )`,
+      // "Latest session per project" is the access pattern; SQLite walks the
+      // composite index backwards for ORDER BY created_at DESC.
+      `CREATE INDEX IF NOT EXISTS idx_discovery_sessions_project_created ON discovery_sessions(project_id, created_at)`,
+      `CREATE TABLE IF NOT EXISTS discovery_probes (
+         id              TEXT PRIMARY KEY,
+         session_id      TEXT NOT NULL REFERENCES discovery_sessions(id) ON DELETE CASCADE,
+         project_id      TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+         query           TEXT NOT NULL,
+         bucket          TEXT,
+         citation_state  TEXT NOT NULL,
+         cited_domains   TEXT NOT NULL DEFAULT '[]',
+         raw_response    TEXT,
+         created_at      TEXT NOT NULL
+       )`,
+      `CREATE INDEX IF NOT EXISTS idx_discovery_probes_session ON discovery_probes(session_id)`,
+      `CREATE INDEX IF NOT EXISTS idx_discovery_probes_project ON discovery_probes(project_id)`
+    ]
+  },
+  {
+    version: 56,
+    name: "discovery-sessions-run-id",
+    // Links a discovery_sessions row back to the runs row that drove it. Without
+    // this column the run-coordinator can't tell two concurrent discovery
+    // sessions apart for the same project — it would fall back to "latest
+    // non-queued session" and surface the wrong bucket counts to Aero.
+    statements: [
+      `ALTER TABLE discovery_sessions ADD COLUMN run_id TEXT`,
+      `CREATE INDEX IF NOT EXISTS idx_discovery_sessions_run ON discovery_sessions(run_id)`
+    ]
+  },
+  {
+    version: 57,
+    name: "runs-scoped-queries",
+    // Persists an optional subset of tracked queries to sweep on a per-run
+    // basis. NULL = full sweep (the default and only behavior pre-v57); a JSON
+    // array of query strings = scope. The job runner reads this to filter the
+    // query fetch via `inArray`.
+    statements: [
+      `ALTER TABLE runs ADD COLUMN queries TEXT`
+    ]
   }
 ];
 function isDuplicateColumnError(err) {
@@ -3519,6 +3642,8 @@ export {
   crawlerEventsHourly,
   aiReferralEventsHourly,
   rawEventSamples,
+  discoverySessions,
+  discoveryProbes,
   createClient,
   parseJsonColumn,
   extractLegacyCredentials,