@ainyc/canonry 2.5.1 → 2.8.2

package/dist/cli.js

@@ -1,4 +1,23 @@
 #!/usr/bin/env node --import tsx
+import {
+  coerceAgentProvider,
+  computeCompetitorOverlap,
+  createServer,
+  determineCitationState,
+  extractRecommendedCompetitors,
+  formatAuditFactorScore,
+  getOrCreateAnonymousId,
+  isFirstRun,
+  isTelemetryEnabled,
+  listAgentProviders,
+  reparseStoredResult,
+  reparseStoredResult2,
+  reparseStoredResult3,
+  reparseStoredResult4,
+  setGoogleAuthConfig,
+  showFirstRunNotice,
+  trackEvent
+} from "./chunk-MGBXRWLX.js";
 import {
   CcReleaseSyncStatuses,
   CliError,
@@ -6,39 +25,22 @@ import {
   ProviderNames,
   RunKinds,
   RunStatuses,
-  coerceAgentProvider,
-  computeCompetitorOverlap,
   configExists,
   createApiClient,
-  createServer,
   determineAnswerMentioned,
-  determineCitationState,
   effectiveDomains,
-  extractRecommendedCompetitors,
-  formatAuditFactorScore,
   getConfigDir,
   getConfigPath,
-  getOrCreateAnonymousId,
   isEndpointMissing,
-  isFirstRun,
-  isTelemetryEnabled,
-  listAgentProviders,
   loadConfig,
   notificationEventSchema,
   printCliError,
   providerQuotaPolicySchema,
-  reparseStoredResult,
-  reparseStoredResult2,
-  reparseStoredResult3,
-  reparseStoredResult4,
   resolveProviderInput,
   saveConfig,
   saveConfigPatch,
-  setGoogleAuthConfig,
-  showFirstRunNotice,
-  trackEvent,
   usageError
-} from "./chunk-CFS35BKX.js";
+} from "./chunk-FPZUQADO.js";
 import {
   apiKeys,
   competitors,
@@ -48,7 +50,8 @@ import {
   projects,
   querySnapshots,
   runs
-} from "./chunk-32YTAZBL.js";
+} from "./chunk-PYHANJ3B.js";
+import "./chunk-MLKGABMK.js";
 
 // src/cli.ts
 import { pathToFileURL } from "url";
@@ -58,9 +61,9 @@ import { parseArgs } from "util";
 function commandId(spec) {
   return spec.path.join(".");
 }
-function matchesPath(args, path6) {
-  if (args.length < path6.length) return false;
-  return path6.every((segment, index) => args[index] === segment);
+function matchesPath(args, path8) {
+  if (args.length < path8.length) return false;
+  return path8.every((segment, index) => args[index] === segment);
 }
 function withFormatOption(options) {
   if (!options) {
@@ -295,7 +298,7 @@ async function backfillAnswerVisibilityCommand(opts) {
   console.log(`  Errors:   ${providerErrors}`);
 }
 async function backfillInsightsCommand(project, opts) {
-  const { IntelligenceService } = await import("./intelligence-service-U7YQ4NXV.js");
+  const { IntelligenceService } = await import("./intelligence-service-2ZABHNR4.js");
   const config = loadConfig();
   const db = createClient(config.database);
   migrate(db);
@@ -1566,9 +1569,9 @@ async function gaConnect(project, opts) {
     propertyId: opts.propertyId
   };
   if (opts.keyFile) {
-    const fs8 = await import("fs");
+    const fs9 = await import("fs");
     try {
-      const content = fs8.readFileSync(opts.keyFile, "utf-8");
+      const content = fs9.readFileSync(opts.keyFile, "utf-8");
       JSON.parse(content);
       body.keyJson = content;
     } catch (e) {
@@ -2184,13 +2187,15 @@ async function addCompetitors(project, domains, format) {
   const client = getClient5();
   const existing = await client.listCompetitors(project);
   const existingDomains = existing.map((c) => c.domain);
-  const addedDomains = domains.filter((domain) => !existingDomains.includes(domain));
-  const allDomains = [.../* @__PURE__ */ new Set([...existingDomains, ...domains])];
-  await client.putCompetitors(project, allDomains);
+  const existingSet = new Set(existingDomains);
+  const requested = new Set(uniqueStrings(domains));
+  const current = await client.appendCompetitors(project, domains);
+  const currentDomains = current.map((c) => c.domain);
+  const addedDomains = currentDomains.filter((domain) => requested.has(domain) && !existingSet.has(domain));
   if (format === "json") {
     console.log(JSON.stringify({
       project,
-      domains: allDomains,
+      domains: currentDomains,
       addedDomains,
       addedCount: addedDomains.length
     }, null, 2));
@@ -2202,6 +2207,35 @@ async function addCompetitors(project, domains, format) {
     console.log(`Added ${addedDomains.length} competitor(s) to "${project}".`);
   }
 }
+async function removeCompetitors(project, domains, format) {
+  const client = getClient5();
+  const existing = await client.listCompetitors(project);
+  const existingDomains = existing.map((c) => c.domain);
+  const requested = new Set(uniqueStrings(domains));
+  const current = await client.deleteCompetitors(project, domains);
+  const currentSet = new Set(current.map((c) => c.domain));
+  const removedDomains = existingDomains.filter((domain) => requested.has(domain) && !currentSet.has(domain));
+  if (format === "json") {
+    console.log(JSON.stringify({
+      project,
+      domains: current.map((c) => c.domain),
+      removedDomains,
+      removedCount: removedDomains.length
+    }, null, 2));
+    return;
+  }
+  console.log(`Removed ${removedDomains.length} competitor(s) from "${project}".`);
+}
+function uniqueStrings(values) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const value of values) {
+    if (seen.has(value)) continue;
+    seen.add(value);
+    result.push(value);
+  }
+  return result;
+}
 async function listCompetitors(project, format) {
   const client = getClient5();
   const comps = await client.listCompetitors(project);
@@ -2240,6 +2274,42 @@ var COMPETITOR_CLI_COMMANDS = [
       await addCompetitors(project, domains, input.format);
     }
   },
+  {
+    path: ["competitor", "remove"],
+    usage: "canonry competitor remove <project> <domain...> [--format json]",
+    run: async (input) => {
+      const project = requireProject(input, "competitor.remove", "canonry competitor remove <project> <domain...> [--format json]");
+      const domains = input.positionals.slice(1);
+      if (domains.length === 0) {
+        throw usageError("Error: project name and at least one domain required\nUsage: canonry competitor remove <project> <domain...> [--format json]", {
+          message: "project name and at least one domain required",
+          details: {
+            command: "competitor.remove",
+            usage: "canonry competitor remove <project> <domain...> [--format json]"
+          }
+        });
+      }
+      await removeCompetitors(project, domains, input.format);
+    }
+  },
+  {
+    path: ["competitor", "delete"],
+    usage: "canonry competitor delete <project> <domain...> [--format json]",
+    run: async (input) => {
+      const project = requireProject(input, "competitor.delete", "canonry competitor delete <project> <domain...> [--format json]");
+      const domains = input.positionals.slice(1);
+      if (domains.length === 0) {
+        throw usageError("Error: project name and at least one domain required\nUsage: canonry competitor delete <project> <domain...> [--format json]", {
+          message: "project name and at least one domain required",
+          details: {
+            command: "competitor.delete",
+            usage: "canonry competitor delete <project> <domain...> [--format json]"
+          }
+        });
+      }
+      await removeCompetitors(project, domains, input.format);
+    }
+  },
   {
     path: ["competitor", "list"],
     usage: "canonry competitor list <project> [--format json]",
@@ -2250,12 +2320,12 @@ var COMPETITOR_CLI_COMMANDS = [
   },
   {
     path: ["competitor"],
-    usage: "canonry competitor <add|list> <project> [args]",
+    usage: "canonry competitor <add|remove|delete|list> <project> [args]",
     run: async (input) => {
       unknownSubcommand(input.positionals[0], {
         command: "competitor",
-        usage: "canonry competitor <add|list> <project> [args]",
-        available: ["add", "list"]
+        usage: "canonry competitor <add|remove|delete|list> <project> [args]",
+        available: ["add", "remove", "delete", "list"]
       });
     }
   }
@@ -3121,6 +3191,19 @@ async function addKeywords(project, keywords, format) {
   }
   console.log(`Added ${keywords.length} key phrase(s) to "${project}".`);
 }
+async function replaceKeywords(project, keywords, format) {
+  const client = getClient7();
+  await client.putKeywords(project, keywords);
+  if (format === "json") {
+    console.log(JSON.stringify({
+      project,
+      keywords,
+      replacedCount: keywords.length
+    }, null, 2));
+    return;
+  }
+  console.log(`Set ${keywords.length} key phrase(s) for "${project}".`);
+}
 async function removeKeywords(project, keywords, format) {
   const client = getClient7();
   const existing = await client.listKeywords(project);
@@ -3249,6 +3332,24 @@ var KEYWORD_CLI_COMMANDS = [
       await addKeywords(project, keywords, input.format);
     }
   },
+  {
+    path: ["keyword", "replace"],
+    usage: "canonry keyword replace <project> <kw...> [--format json]",
+    run: async (input) => {
+      const project = requireProject(input, "keyword.replace", "canonry keyword replace <project> <kw...> [--format json]");
+      const keywords = input.positionals.slice(1);
+      if (keywords.length === 0) {
+        throw usageError("Error: project name and at least one key phrase required\nUsage: canonry keyword replace <project> <kw...> [--format json]", {
+          message: "project name and at least one key phrase required",
+          details: {
+            command: "keyword.replace",
+            usage: "canonry keyword replace <project> <kw...> [--format json]"
+          }
+        });
+      }
+      await replaceKeywords(project, keywords, input.format);
+    }
+  },
   {
     path: ["keyword", "remove"],
     usage: "canonry keyword remove <project> <kw...> [--format json]",
@@ -3338,12 +3439,324 @@ var KEYWORD_CLI_COMMANDS = [
   },
   {
     path: ["keyword"],
-    usage: "canonry keyword <add|remove|delete|list|import|generate> <project> [args]",
+    usage: "canonry keyword <add|replace|remove|delete|list|import|generate> <project> [args]",
     run: async (input) => {
       unknownSubcommand(input.positionals[0], {
         command: "keyword",
-        usage: "canonry keyword <add|remove|delete|list|import|generate> <project> [args]",
-        available: ["add", "remove", "delete", "list", "import", "generate"]
+        usage: "canonry keyword <add|replace|remove|delete|list|import|generate> <project> [args]",
+        available: ["add", "replace", "remove", "delete", "list", "import", "generate"]
+      });
+    }
+  }
+];
+
+// src/commands/mcp.ts
+import fs2 from "fs";
+import path2 from "path";
+import { createRequire } from "module";
+
+// src/mcp-clients.ts
+import os from "os";
+import path from "path";
+var CLAUDE_DESKTOP_CONFIG_FILENAME = "claude_desktop_config.json";
+function homeRelative(...segments) {
+  return path.join(os.homedir(), ...segments);
+}
+function claudeDesktopConfigPath() {
+  switch (process.platform) {
+    case "darwin":
+      return homeRelative("Library", "Application Support", "Claude", CLAUDE_DESKTOP_CONFIG_FILENAME);
+    case "win32": {
+      const appData = process.env.APPDATA ?? homeRelative("AppData", "Roaming");
+      return path.join(appData, "Claude", CLAUDE_DESKTOP_CONFIG_FILENAME);
+    }
+    default:
+      return homeRelative(".config", "Claude", CLAUDE_DESKTOP_CONFIG_FILENAME);
+  }
+}
+function cursorConfigPath() {
+  return homeRelative(".cursor", "mcp.json");
+}
+function codexConfigPath() {
+  return homeRelative(".codex", "config.toml");
+}
+var SUPPORTED_MCP_CLIENTS = [
+  {
+    id: "claude-desktop",
+    label: "Claude Desktop",
+    format: "json-mcp-servers",
+    configPath: claudeDesktopConfigPath,
+    installSupported: true
+  },
+  {
+    id: "cursor",
+    label: "Cursor",
+    format: "json-mcp-servers",
+    configPath: cursorConfigPath,
+    installSupported: true
+  },
+  {
+    id: "codex",
+    label: "Codex CLI",
+    format: "toml-mcp-servers",
+    configPath: codexConfigPath,
+    installSupported: false
+  }
+];
+function findMcpClient(id) {
+  return SUPPORTED_MCP_CLIENTS.find((client) => client.id === id);
+}
+function listMcpClientIds() {
+  return SUPPORTED_MCP_CLIENTS.map((client) => client.id);
+}
+
+// src/commands/mcp.ts
+var _require = createRequire(import.meta.url);
+function resolveCanonryMcpBin() {
+  const packageJsonPath = _require.resolve("../package.json");
+  const packageRoot = path2.dirname(packageJsonPath);
+  const pkg = _require("../package.json");
+  const relativeBin = pkg.bin?.["canonry-mcp"];
+  if (!relativeBin) {
+    throw new CliError({
+      code: "INTERNAL_ERROR",
+      message: "Could not resolve canonry-mcp bin path from package.json",
+      exitCode: 2
+    });
+  }
+  return path2.resolve(packageRoot, relativeBin);
+}
+function buildEntry(opts) {
+  const target = opts.binPath ?? resolveCanonryMcpBin();
+  const flagArgs = opts.readOnly ? ["--read-only"] : [];
+  const platform = opts.platform ?? process.platform;
+  if (platform === "win32" && target.toLowerCase().endsWith(".mjs")) {
+    return { command: "node", args: [target, ...flagArgs] };
+  }
+  return { command: target, args: flagArgs };
+}
+function entryArgs(entry) {
+  return Array.isArray(entry.args) ? entry.args : [];
+}
+function entriesEqual(a, b) {
+  if (a.command !== b.command) return false;
+  const aArgs = entryArgs(a);
+  const bArgs = entryArgs(b);
+  return aArgs.length === bArgs.length && aArgs.every((arg, i) => arg === bArgs[i]);
+}
+function renderJsonSnippet(serverName, entry, format) {
+  const key = format === "json-context-servers" ? "context_servers" : "mcpServers";
+  return JSON.stringify({ [key]: { [serverName]: entry } }, null, 2);
+}
+function renderTomlSnippet(serverName, entry) {
+  const argsLine = entry.args.length ? `args = [${entry.args.map((arg) => JSON.stringify(arg)).join(", ")}]` : "args = []";
+  return [`[mcp_servers.${serverName}]`, `command = ${JSON.stringify(entry.command)}`, argsLine, ""].join("\n");
+}
+function renderClientSnippet(client, serverName, entry) {
+  if (client.format === "toml-mcp-servers") return renderTomlSnippet(serverName, entry);
+  return renderJsonSnippet(serverName, entry, client.format);
+}
+function readJsonConfig(configPath) {
+  if (!fs2.existsSync(configPath)) return {};
+  const raw = fs2.readFileSync(configPath, "utf-8").trim();
+  if (!raw) return {};
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new Error("Config root must be a JSON object");
+    }
+    return parsed;
+  } catch (err) {
+    throw new CliError({
+      code: "VALIDATION_ERROR",
+      message: `Failed to parse ${configPath}: ${err instanceof Error ? err.message : String(err)}`,
+      exitCode: 1,
+      details: { configPath }
+    });
+  }
+}
+function writeJsonConfig(configPath, value) {
+  fs2.mkdirSync(path2.dirname(configPath), { recursive: true });
+  fs2.writeFileSync(configPath, `${JSON.stringify(value, null, 2)}
+`, "utf-8");
+}
+function backupConfigIfPresent(configPath) {
+  if (!fs2.existsSync(configPath)) return void 0;
+  const backupPath = `${configPath}.canonry.bak`;
+  fs2.copyFileSync(configPath, backupPath);
+  return backupPath;
+}
+function findClientOrThrow(id) {
+  const client = findMcpClient(id);
+  if (client) return client;
+  throw new CliError({
+    code: "VALIDATION_ERROR",
+    message: `Unknown MCP client "${id}". Supported: ${listMcpClientIds().join(", ")}`,
+    exitCode: 1,
+    details: { client: id, supportedClients: listMcpClientIds() }
+  });
+}
+async function installMcp(opts) {
+  const client = findClientOrThrow(opts.client);
+  const serverName = opts.name?.trim() || "canonry";
+  const configPath = opts.configPath ?? client.configPath();
+  const entry = buildEntry({ binPath: opts.binPath, readOnly: opts.readOnly, platform: opts.platform });
+  if (!client.installSupported) {
+    const snippet = renderClientSnippet(client, serverName, entry);
+    const result2 = {
+      client: client.id,
+      configPath,
+      serverName,
+      entry,
+      status: "snippet-only",
+      snippet,
+      message: `Auto-install is not supported for ${client.label}. Add the snippet below to ${configPath}.`
+    };
+    emitInstallResult(result2, opts.format);
+    return result2;
+  }
+  const containerKey = client.format === "json-context-servers" ? "context_servers" : "mcpServers";
+  const existing = readJsonConfig(configPath);
+  const existingContainer = existing[containerKey] ?? {};
+  const existingEntry = existingContainer[serverName];
+  if (existingEntry && entriesEqual(existingEntry, entry)) {
+    const result2 = {
+      client: client.id,
+      configPath,
+      serverName,
+      entry,
+      status: "already-installed",
+      message: `${client.label} already has a "${serverName}" entry pointing to canonry-mcp.`
+    };
+    emitInstallResult(result2, opts.format);
+    return result2;
+  }
+  const status = existingEntry ? "updated" : "installed";
+  if (opts.dryRun) {
+    const result2 = {
+      client: client.id,
+      configPath,
+      serverName,
+      entry,
+      status: "dry-run",
+      snippet: renderClientSnippet(client, serverName, entry),
+      message: `Would ${status === "installed" ? "install" : "update"} "${serverName}" in ${configPath}.`
+    };
+    emitInstallResult(result2, opts.format);
+    return result2;
+  }
+  const backupPath = backupConfigIfPresent(configPath);
+  const next = {
+    ...existing,
+    [containerKey]: { ...existingContainer, [serverName]: entry }
+  };
+  writeJsonConfig(configPath, next);
+  const result = {
+    client: client.id,
+    configPath,
+    serverName,
+    entry,
+    status,
+    backupPath,
+    message: `${status === "installed" ? "Installed" : "Updated"} "${serverName}" in ${client.label} at ${configPath}. Restart ${client.label} to load it.`
+  };
+  emitInstallResult(result, opts.format);
+  return result;
+}
+async function printMcpConfig(opts) {
+  const client = findClientOrThrow(opts.client);
+  const serverName = opts.name?.trim() || "canonry";
+  const entry = buildEntry({ binPath: opts.binPath, readOnly: opts.readOnly, platform: opts.platform });
+  const snippet = renderClientSnippet(client, serverName, entry);
+  if (opts.format === "json") {
+    console.log(JSON.stringify({
+      client: client.id,
+      configPath: client.configPath(),
+      serverName,
+      entry,
+      snippet
+    }, null, 2));
+    return;
+  }
+  console.log(`# ${client.label} \u2014 paste into ${client.configPath()}`);
+  console.log(snippet);
+}
+function emitInstallResult(result, format) {
+  if (format === "json") {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  console.log(result.message);
+  if (result.backupPath) console.log(`Backup: ${result.backupPath}`);
+  if (result.snippet && (result.status === "snippet-only" || result.status === "dry-run")) {
+    console.log();
+    console.log(result.snippet);
+  }
+}
+
+// src/cli-commands/mcp.ts
+var CLIENT_LIST = listMcpClientIds().join("|");
+var MCP_CLI_COMMANDS = [
+  {
+    path: ["mcp", "install"],
+    usage: `canonry mcp install --client ${CLIENT_LIST} [--name <server>] [--read-only] [--dry-run] [--config-path <path>] [--format json]`,
+    options: {
+      client: stringOption(),
+      name: stringOption(),
+      "read-only": { type: "boolean" },
+      "dry-run": { type: "boolean" },
+      "config-path": stringOption()
+    },
+    run: async (input) => {
+      const usage = `canonry mcp install --client ${CLIENT_LIST} [--name <server>] [--read-only] [--dry-run] [--config-path <path>] [--format json]`;
+      const client = requireStringOption(input, "client", {
+        command: "mcp.install",
+        usage,
+        message: "--client is required",
+        details: { flag: "client", supportedClients: listMcpClientIds() }
+      });
+      await installMcp({
+        client,
+        name: getString(input.values, "name"),
+        readOnly: getBoolean(input.values, "read-only"),
+        dryRun: getBoolean(input.values, "dry-run"),
+        configPath: getString(input.values, "config-path"),
+        format: input.format
+      });
+    }
+  },
+  {
+    path: ["mcp", "config"],
+    usage: `canonry mcp config --client ${CLIENT_LIST} [--name <server>] [--read-only] [--format json]`,
+    options: {
+      client: stringOption(),
+      name: stringOption(),
+      "read-only": { type: "boolean" }
+    },
+    run: async (input) => {
+      const usage = `canonry mcp config --client ${CLIENT_LIST} [--name <server>] [--read-only] [--format json]`;
+      const client = requireStringOption(input, "client", {
+        command: "mcp.config",
+        usage,
+        message: "--client is required",
+        details: { flag: "client", supportedClients: listMcpClientIds() }
+      });
+      await printMcpConfig({
+        client,
+        name: getString(input.values, "name"),
+        readOnly: getBoolean(input.values, "read-only"),
+        format: input.format
+      });
+    }
+  },
+  {
+    path: ["mcp"],
+    usage: "canonry mcp <install|config> [args]",
+    run: async (input) => {
+      unknownSubcommand(input.positionals[0], {
+        command: "mcp",
+        usage: "canonry mcp <install|config> [args]",
+        available: ["install", "config"]
       });
     }
   }
@@ -3517,13 +3930,13 @@ var NOTIFY_CLI_COMMANDS = [
 ];
 
 // src/commands/apply.ts
-import fs2 from "fs";
+import fs3 from "fs";
 import { parseAllDocuments } from "yaml";
 async function applyConfigFile(filePath) {
-  if (!fs2.existsSync(filePath)) {
+  if (!fs3.existsSync(filePath)) {
     throw new Error(`File not found: ${filePath}`);
   }
-  const content = fs2.readFileSync(filePath, "utf-8");
+  const content = fs3.readFileSync(filePath, "utf-8");
   const docs = parseAllDocuments(content);
   const client = createApiClient();
   const errors = [];
@@ -4967,12 +5380,12 @@ Usage: canonry settings provider ${name} --api-key <key> [--model <model>] [--ma
 ];
 
 // src/commands/snapshot.ts
-import fs4 from "fs";
-import path2 from "path";
+import fs5 from "fs";
+import path4 from "path";
 
 // src/snapshot-pdf.ts
-import fs3 from "fs";
-import path from "path";
+import fs4 from "fs";
+import path3 from "path";
 import { PDFDocument, StandardFonts, rgb } from "pdf-lib";
 var PAGE_WIDTH = 612;
 var PAGE_HEIGHT = 792;
@@ -5181,9 +5594,9 @@ async function writeSnapshotPdf(report, outputPath) {
   renderCompetitors(pdf, report);
   renderQueries(pdf, report);
   const bytes = await doc.save();
-  const resolvedPath = path.resolve(outputPath);
-  fs3.mkdirSync(path.dirname(resolvedPath), { recursive: true });
-  fs3.writeFileSync(resolvedPath, bytes);
+  const resolvedPath = path3.resolve(outputPath);
+  fs4.mkdirSync(path3.dirname(resolvedPath), { recursive: true });
+  fs4.writeFileSync(resolvedPath, bytes);
   return resolvedPath;
 }
 function renderCover(pdf, report) {
@@ -5341,9 +5754,9 @@ Markdown saved: ${savedMdPath}`);
 PDF saved: ${savedPdfPath}`);
 }
 function writeSnapshotMarkdown(report, outputPath) {
-  const resolvedPath = path2.resolve(outputPath);
-  fs4.mkdirSync(path2.dirname(resolvedPath), { recursive: true });
-  fs4.writeFileSync(resolvedPath, formatSnapshotMarkdown(report), "utf-8");
+  const resolvedPath = path4.resolve(outputPath);
+  fs5.mkdirSync(path4.dirname(resolvedPath), { recursive: true });
+  fs5.writeFileSync(resolvedPath, formatSnapshotMarkdown(report), "utf-8");
   return resolvedPath;
 }
 function formatSnapshotMarkdown(report) {
@@ -5652,7 +6065,7 @@ var INTELLIGENCE_CLI_COMMANDS = [
 
 // src/commands/bootstrap.ts
 import crypto from "crypto";
-import path3 from "path";
+import path5 from "path";
 import { eq as eq2 } from "drizzle-orm";
 
 // ../config/src/index.ts
@@ -5799,7 +6212,7 @@ async function bootstrapCommand(_opts) {
     );
   }
   const configDir = getConfigDir();
-  const databasePath = env.databasePath || path3.join(configDir, "data.db");
+  const databasePath = env.databasePath || path5.join(configDir, "data.db");
   const existing = configExists();
   const existingConfig = existing ? loadConfig() : void 0;
   let rawApiKey;
@@ -5869,10 +6282,10 @@ async function bootstrapCommand(_opts) {
 
 // src/commands/daemon.ts
 import { spawn } from "child_process";
-import fs5 from "fs";
-import path4 from "path";
+import fs6 from "fs";
+import path6 from "path";
 function getPidPath() {
-  return path4.join(getConfigDir(), "canonry.pid");
+  return path6.join(getConfigDir(), "canonry.pid");
 }
 function isProcessAlive(pid) {
   try {
@@ -5899,8 +6312,8 @@ async function waitForReady(host, port, maxMs = 1e4) {
 async function startDaemon(opts) {
   const pidPath = getPidPath();
   const format = opts.format ?? "text";
-  if (fs5.existsSync(pidPath)) {
-    const existingPid = parseInt(fs5.readFileSync(pidPath, "utf-8").trim(), 10);
+  if (fs6.existsSync(pidPath)) {
+    const existingPid = parseInt(fs6.readFileSync(pidPath, "utf-8").trim(), 10);
     if (!isNaN(existingPid) && isProcessAlive(existingPid)) {
       throw new CliError({
         code: "DAEMON_ALREADY_RUNNING",
@@ -5911,9 +6324,9 @@ async function startDaemon(opts) {
         }
       });
     }
-    fs5.unlinkSync(pidPath);
+    fs6.unlinkSync(pidPath);
   }
-  const cliPath = path4.resolve(new URL(import.meta.url).pathname);
+  const cliPath = path6.resolve(new URL(import.meta.url).pathname);
   const inSourceMode = new URL(import.meta.url).pathname.endsWith(".ts");
   const args = inSourceMode ? ["--import", "tsx", cliPath, "serve"] : [cliPath, "serve"];
   if (opts.port) args.push("--port", opts.port);
@@ -5932,10 +6345,10 @@ async function startDaemon(opts) {
     });
   }
   const configDir = getConfigDir();
-  if (!fs5.existsSync(configDir)) {
-    fs5.mkdirSync(configDir, { recursive: true });
+  if (!fs6.existsSync(configDir)) {
+    fs6.mkdirSync(configDir, { recursive: true });
   }
-  fs5.writeFileSync(pidPath, String(child.pid), "utf-8");
+  fs6.writeFileSync(pidPath, String(child.pid), "utf-8");
   const port = opts.port ?? "4100";
   const host = opts.host ?? "127.0.0.1";
   if (format !== "json") {
@@ -5944,7 +6357,7 @@ async function startDaemon(opts) {
   const ready = await waitForReady(host, port);
   if (!ready) {
     try {
-      fs5.unlinkSync(pidPath);
+      fs6.unlinkSync(pidPath);
     } catch {
     }
     throw new CliError({
@@ -5976,7 +6389,7 @@ async function startDaemon(opts) {
 }
 function stopDaemon(format = "text") {
   const pidPath = getPidPath();
-  if (!fs5.existsSync(pidPath)) {
+  if (!fs6.existsSync(pidPath)) {
     if (format === "json") {
       console.log(JSON.stringify({
         stopped: false,
@@ -5987,7 +6400,7 @@ function stopDaemon(format = "text") {
     console.log("Canonry is not running (no PID file found)");
     return;
   }
-  const pid = parseInt(fs5.readFileSync(pidPath, "utf-8").trim(), 10);
+  const pid = parseInt(fs6.readFileSync(pidPath, "utf-8").trim(), 10);
   if (isNaN(pid)) {
     if (format === "json") {
       console.log(JSON.stringify({
@@ -5998,7 +6411,7 @@ function stopDaemon(format = "text") {
     } else {
       console.error("Invalid PID file. Removing it.");
     }
-    fs5.unlinkSync(pidPath);
+    fs6.unlinkSync(pidPath);
     return;
   }
   if (!isProcessAlive(pid)) {
@@ -6012,12 +6425,12 @@ function stopDaemon(format = "text") {
     } else {
       console.log(`Canonry is not running (stale PID: ${pid}). Cleaning up.`);
     }
-    fs5.unlinkSync(pidPath);
+    fs6.unlinkSync(pidPath);
     return;
   }
   try {
     process.kill(pid, "SIGTERM");
-    fs5.unlinkSync(pidPath);
+    fs6.unlinkSync(pidPath);
     if (format === "json") {
       console.log(JSON.stringify({
         stopped: true,
@@ -6041,9 +6454,9 @@ function stopDaemon(format = "text") {
 
 // src/commands/init.ts
 import crypto2 from "crypto";
-import fs6 from "fs";
+import fs7 from "fs";
 import readline from "readline";
-import path5 from "path";
+import path7 from "path";
 function prompt(question) {
   const rl = readline.createInterface({
     input: process.stdin,
@@ -6089,8 +6502,8 @@ async function initCommand(opts) {
     return void 0;
   }
   const configDir = getConfigDir();
-  if (!fs6.existsSync(configDir)) {
-    fs6.mkdirSync(configDir, { recursive: true });
+  if (!fs7.existsSync(configDir)) {
+    fs7.mkdirSync(configDir, { recursive: true });
   }
   const bootstrapEnv = getBootstrapEnv(process.env, {
     GEMINI_API_KEY: opts?.geminiKey,
@@ -6205,7 +6618,7 @@ async function initCommand(opts) {
   const rawApiKey = `cnry_${crypto2.randomBytes(16).toString("hex")}`;
   const keyHash = crypto2.createHash("sha256").update(rawApiKey).digest("hex");
   const keyPrefix = rawApiKey.slice(0, 9);
-  const databasePath = path5.join(configDir, "data.db");
+  const databasePath = path7.join(configDir, "data.db");
   const db = createClient(databasePath);
   migrate(db);
   db.insert(apiKeys).values({
@@ -6599,7 +7012,7 @@ var SYSTEM_CLI_COMMANDS = [
 ];
 
 // src/cli-commands/wordpress.ts
-import fs7 from "fs";
+import fs8 from "fs";
 
 // src/commands/wordpress.ts
 function getClient18() {
@@ -6835,12 +7248,12 @@ async function wordpressSetMeta(project, body) {
   printPageDetail(result);
 }
 async function wordpressBulkSetMeta(project, opts) {
-  const fs8 = await import("fs/promises");
-  const path6 = await import("path");
-  const filePath = path6.resolve(opts.from);
+  const fs9 = await import("fs/promises");
+  const path8 = await import("path");
+  const filePath = path8.resolve(opts.from);
   let raw;
   try {
-    raw = await fs8.readFile(filePath, "utf8");
+    raw = await fs9.readFile(filePath, "utf8");
   } catch {
     throw new CliError({
       code: "FILE_READ_ERROR",
@@ -6937,13 +7350,13 @@ async function wordpressSetSchema(project, body) {
   printManualAssist(`Schema update for "${body.slug}"`, result);
 }
 async function wordpressSchemaDeploy(project, opts) {
-  const fs8 = await import("fs/promises");
-  const path6 = await import("path");
+  const fs9 = await import("fs/promises");
+  const path8 = await import("path");
   const yaml = await import("yaml").catch(() => null);
-  const filePath = path6.resolve(opts.profile);
+  const filePath = path8.resolve(opts.profile);
   let raw;
   try {
-    raw = await fs8.readFile(filePath, "utf8");
+    raw = await fs9.readFile(filePath, "utf8");
   } catch {
     throw new CliError({
       code: "FILE_READ_ERROR",
@@ -7048,13 +7461,13 @@ async function wordpressOnboard(project, opts) {
   }
   let profileData;
   if (opts.profile) {
-    const fs8 = await import("fs/promises");
-    const path6 = await import("path");
+    const fs9 = await import("fs/promises");
+    const path8 = await import("path");
     const yaml = await import("yaml").catch(() => null);
-    const filePath = path6.resolve(opts.profile);
+    const filePath = path8.resolve(opts.profile);
     let raw;
     try {
-      raw = await fs8.readFile(filePath, "utf8");
+      raw = await fs9.readFile(filePath, "utf8");
     } catch {
       throw new CliError({
         code: "FILE_READ_ERROR",
@@ -7203,7 +7616,7 @@ function resolveContent(input, command, usage, options) {
   }
   if (contentFile) {
     try {
-      return fs7.readFileSync(contentFile, "utf-8");
+      return fs8.readFileSync(contentFile, "utf-8");
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       throw usageError(`Error: could not read --content-file "${contentFile}": ${message}`, {
@@ -8139,11 +8552,12 @@ var REGISTERED_CLI_COMMANDS = [
   ...CDP_CLI_COMMANDS,
   ...GA_CLI_COMMANDS,
   ...INTELLIGENCE_CLI_COMMANDS,
-  ...AGENT_CLI_COMMANDS
+  ...AGENT_CLI_COMMANDS,
+  ...MCP_CLI_COMMANDS
 ];
 
 // src/cli.ts
-import { createRequire } from "module";
+import { createRequire as createRequire2 } from "module";
 var USAGE = `
 canonry \u2014 AEO monitoring CLI
 
@@ -8157,8 +8571,8 @@ Setup:
 
 Projects:
   project               Create, update, list, show, delete projects
-  keyword               Add, remove, list, import, generate key phrases
-  competitor            Add, list competitors
+  keyword               Add, replace, remove, list, import, generate key phrases
+  competitor            Add, remove, list competitors
 
 Monitoring:
   run                   Trigger visibility sweeps
@@ -8195,8 +8609,8 @@ Global options:
 
 Run 'canonry <command> --help' for details on a specific command.
 `.trim();
-var _require = createRequire(import.meta.url);
-var { version: VERSION } = _require("../package.json");
+var _require2 = createRequire2(import.meta.url);
+var { version: VERSION } = _require2("../package.json");
 function extractFormat(cmdArgs) {
   const idx = cmdArgs.indexOf("--format");
   if (idx !== -1 && cmdArgs[idx + 1] === "json") return "json";