@ainyc/canonry 1.39.4 → 1.40.0

package/dist/cli.js

@@ -1,12 +1,14 @@
 #!/usr/bin/env node --import tsx
 import {
-  IntelligenceService,
-  apiKeys,
+  ProviderNames,
+  RunKinds,
+  computeCompetitorOverlap,
   configExists,
-  createClient,
   createServer,
   determineAnswerMentioned,
+  determineCitationState,
   effectiveDomains,
+  extractRecommendedCompetitors,
   formatAuditFactorScore,
   getConfigDir,
   getConfigPath,
@@ -14,20 +16,29 @@ import {
   isFirstRun,
   isTelemetryEnabled,
   loadConfig,
-  migrate,
   notificationEventSchema,
-  parseJsonColumn,
-  projects,
   providerQuotaPolicySchema,
-  querySnapshots,
+  reparseStoredResult,
+  reparseStoredResult2,
+  reparseStoredResult3,
+  reparseStoredResult4,
   resolveProviderInput,
-  runs,
   saveConfig,
   saveConfigPatch,
   setGoogleAuthConfig,
   showFirstRunNotice,
   trackEvent
-} from "./chunk-H6FO4LHC.js";
+} from "./chunk-FXHVGU5S.js";
+import {
+  apiKeys,
+  competitors,
+  createClient,
+  migrate,
+  parseJsonColumn,
+  projects,
+  querySnapshots,
+  runs
+} from "./chunk-FOWWBLXD.js";
 
 // src/cli.ts
 import { pathToFileURL } from "url";
@@ -107,9 +118,9 @@ import { parseArgs } from "util";
 function commandId(spec) {
   return spec.path.join(".");
 }
-function matchesPath(args, path5) {
-  if (args.length < path5.length) return false;
-  return path5.every((segment, index) => args[index] === segment);
+function matchesPath(args, path6) {
+  if (args.length < path6.length) return false;
+  return path6.every((segment, index) => args[index] === segment);
 }
 function withFormatOption(options) {
   if (!options) {
@@ -202,7 +213,7 @@ Usage: ${spec.usage}`, {
 }
 
 // src/commands/backfill.ts
-import { eq, inArray } from "drizzle-orm";
+import { and, eq, inArray } from "drizzle-orm";
 var SNAPSHOT_BATCH_SIZE = 500;
 async function backfillAnswerVisibilityCommand(opts) {
   const config = loadConfig();
@@ -213,8 +224,13 @@ async function backfillAnswerVisibilityCommand(opts) {
   let examined = 0;
   let updated = 0;
   let visible = 0;
+  let reparsed = 0;
+  let providerErrors = 0;
   if (scopedProjects.length > 0) {
-    const runRows = projectFilter ? db.select({ id: runs.id, projectId: runs.projectId }).from(runs).where(inArray(runs.projectId, scopedProjects.map((project) => project.id))).all() : db.select({ id: runs.id, projectId: runs.projectId }).from(runs).all();
+    const runRows = projectFilter ? db.select({ id: runs.id, projectId: runs.projectId }).from(runs).where(and(
+      eq(runs.kind, RunKinds["answer-visibility"]),
+      inArray(runs.projectId, scopedProjects.map((project) => project.id))
+    )).all() : db.select({ id: runs.id, projectId: runs.projectId }).from(runs).where(eq(runs.kind, RunKinds["answer-visibility"])).all();
     const runIdsByProject = /* @__PURE__ */ new Map();
     for (const run of runRows) {
       const existing = runIdsByProject.get(run.projectId);
@@ -222,31 +238,95 @@ async function backfillAnswerVisibilityCommand(opts) {
       else runIdsByProject.set(run.projectId, [run.id]);
     }
     for (const project of scopedProjects) {
+      const competitorDomains = db.select({ domain: competitors.domain }).from(competitors).where(eq(competitors.projectId, project.id)).all().map((row) => row.domain);
       const runIds = runIdsByProject.get(project.id) ?? [];
       if (runIds.length === 0) continue;
+      const projectDomains = effectiveDomains({
+        canonicalDomain: project.canonicalDomain,
+        ownedDomains: parseJsonColumn(project.ownedDomains, [])
+      });
       for (let offset = 0; offset < runIds.length; offset += SNAPSHOT_BATCH_SIZE) {
         const batchRunIds = runIds.slice(offset, offset + SNAPSHOT_BATCH_SIZE);
         const snapshotRows = db.select({
           id: querySnapshots.id,
+          provider: querySnapshots.provider,
+          citationState: querySnapshots.citationState,
           answerMentioned: querySnapshots.answerMentioned,
-          answerText: querySnapshots.answerText
+          answerText: querySnapshots.answerText,
+          citedDomains: querySnapshots.citedDomains,
+          competitorOverlap: querySnapshots.competitorOverlap,
+          recommendedCompetitors: querySnapshots.recommendedCompetitors,
+          rawResponse: querySnapshots.rawResponse
         }).from(querySnapshots).where(inArray(querySnapshots.runId, batchRunIds)).all();
+        const pendingUpdates = [];
         for (const snapshot of snapshotRows) {
           examined++;
-          const nextValue = determineAnswerMentioned(
-            snapshot.answerText,
-            project.displayName,
-            effectiveDomains({
-              canonicalDomain: project.canonicalDomain,
-              ownedDomains: parseJsonColumn(project.ownedDomains, [])
-            })
-          );
+          const reparsedResult = reparseProviderSnapshot(snapshot.provider, snapshot.rawResponse);
+          if (reparsedResult) reparsed++;
+          if (reparsedResult?.providerError) providerErrors++;
+          const answerText = reparsedResult?.answerText ?? snapshot.answerText ?? "";
+          const nextValue = determineAnswerMentioned(answerText, project.displayName, projectDomains);
           if (nextValue) visible++;
+          const nextPatch = {};
           if (snapshot.answerMentioned !== nextValue) {
-            db.update(querySnapshots).set({ answerMentioned: nextValue }).where(eq(querySnapshots.id, snapshot.id)).run();
-            updated++;
+            nextPatch.answerMentioned = nextValue;
+          }
+          if ((snapshot.answerText ?? "") !== answerText) {
+            nextPatch.answerText = answerText;
+          }
+          if (reparsedResult) {
+            const normalized = {
+              provider: snapshot.provider,
+              answerText,
+              citedDomains: reparsedResult.citedDomains,
+              groundingSources: reparsedResult.groundingSources,
+              searchQueries: reparsedResult.searchQueries
+            };
+            const nextCitationState = determineCitationState(normalized, projectDomains);
+            const nextCitedDomains = JSON.stringify(reparsedResult.citedDomains);
+            const nextCompetitorOverlap = JSON.stringify(
+              computeCompetitorOverlap(normalized, competitorDomains)
+            );
+            const nextRecommendedCompetitors = JSON.stringify(
+              extractRecommendedCompetitors(
+                normalized.answerText,
+                projectDomains,
+                normalized.citedDomains,
+                competitorDomains
+              )
+            );
+            const nextRawResponse = stringifyStoredSnapshotEnvelope(
+              snapshot.rawResponse,
+              reparsedResult
+            );
+            if (snapshot.citationState !== nextCitationState) {
+              nextPatch.citationState = nextCitationState;
+            }
+            if (snapshot.citedDomains !== nextCitedDomains) {
+              nextPatch.citedDomains = nextCitedDomains;
+            }
+            if (snapshot.competitorOverlap !== nextCompetitorOverlap) {
+              nextPatch.competitorOverlap = nextCompetitorOverlap;
+            }
+            if (snapshot.recommendedCompetitors !== nextRecommendedCompetitors) {
+              nextPatch.recommendedCompetitors = nextRecommendedCompetitors;
+            }
+            if (snapshot.rawResponse !== nextRawResponse) {
+              nextPatch.rawResponse = nextRawResponse;
+            }
+          }
+          if (Object.keys(nextPatch).length > 0) {
+            pendingUpdates.push({ id: snapshot.id, patch: nextPatch });
           }
         }
+        if (pendingUpdates.length > 0) {
+          db.transaction((tx) => {
+            for (const update of pendingUpdates) {
+              tx.update(querySnapshots).set(update.patch).where(eq(querySnapshots.id, update.id)).run();
+            }
+          });
+          updated += pendingUpdates.length;
+        }
       }
     }
   }
@@ -255,7 +335,9 @@ async function backfillAnswerVisibilityCommand(opts) {
     projects: scopedProjects.length,
     examined,
     updated,
-    visible
+    visible,
+    reparsed,
+    providerErrors
   };
   if (opts?.format === "json") {
     console.log(JSON.stringify(result, null, 2));
@@ -269,8 +351,11 @@ async function backfillAnswerVisibilityCommand(opts) {
   console.log(`  Examined: ${examined}`);
   console.log(`  Updated:  ${updated}`);
   console.log(`  Visible:  ${visible}`);
+  console.log(`  Reparsed: ${reparsed}`);
+  console.log(`  Errors:   ${providerErrors}`);
 }
 async function backfillInsightsCommand(project, opts) {
+  const { IntelligenceService } = await import("./intelligence-service-PDZOIB7L.js");
   const config = loadConfig();
   const db = createClient(config.database);
   migrate(db);
@@ -305,6 +390,53 @@ Backfill complete.`);
   console.log(`  Skipped:   ${result.skipped}`);
   console.log(`  Insights:  ${result.totalInsights}`);
 }
+function reparseProviderSnapshot(provider, rawResponse) {
+  const envelope = parseJsonColumn(rawResponse, {});
+  const apiResponse = resolveStoredApiResponse(envelope);
+  if (!apiResponse) return null;
+  switch (provider) {
+    case ProviderNames.openai:
+      return reparseStoredResult(apiResponse);
+    case ProviderNames.claude:
+      return reparseStoredResult2(apiResponse);
+    case ProviderNames.gemini:
+      return reparseStoredResult3(apiResponse);
+    case ProviderNames.perplexity:
+      return reparseStoredResult4(apiResponse);
+    default:
+      return null;
+  }
+}
+function resolveStoredApiResponse(parsed) {
+  const nested = parsed.apiResponse;
+  if (nested !== null && typeof nested === "object" && !Array.isArray(nested)) {
+    return nested;
+  }
+  if (looksLikeProviderApiResponse(parsed)) {
+    return parsed;
+  }
+  return null;
+}
+function looksLikeProviderApiResponse(value) {
+  return Array.isArray(value.output) || Array.isArray(value.content) || Array.isArray(value.candidates) || Array.isArray(value.choices);
+}
+function stringifyStoredSnapshotEnvelope(rawResponse, reparsed) {
+  const parsed = parseJsonColumn(rawResponse, {});
+  const apiResponse = resolveStoredApiResponse(parsed);
+  const envelope = apiResponse === parsed ? {} : { ...parsed };
+  delete envelope.answerText;
+  delete envelope.citedDomains;
+  delete envelope.competitorOverlap;
+  delete envelope.recommendedCompetitors;
+  delete envelope.providerError;
+  return JSON.stringify({
+    ...envelope,
+    groundingSources: reparsed.groundingSources,
+    searchQueries: reparsed.searchQueries,
+    ...reparsed.providerError ? { providerError: reparsed.providerError } : {},
+    ...apiResponse ? { apiResponse } : {}
+  });
+}
 
 // src/cli-command-helpers.ts
 function getString(values, key) {
@@ -481,9 +613,9 @@ var ApiClient = class {
     }
     return this.probePromise;
   }
-  async request(method, path5, body) {
+  async request(method, path6, body) {
     await this.probeBasePath();
-    const url = `${this.baseUrl}${path5}`;
+    const url = `${this.baseUrl}${path6}`;
     const serializedBody = body != null ? JSON.stringify(body) : void 0;
     const headers = {
       "Authorization": `Bearer ${this.apiKey}`,
@@ -550,8 +682,8 @@ var ApiClient = class {
   async appendKeywords(project, keywords) {
     await this.request("POST", `/projects/${encodeURIComponent(project)}/keywords`, { keywords });
   }
-  async putCompetitors(project, competitors) {
-    await this.request("PUT", `/projects/${encodeURIComponent(project)}/competitors`, { competitors });
+  async putCompetitors(project, competitors2) {
+    await this.request("PUT", `/projects/${encodeURIComponent(project)}/competitors`, { competitors: competitors2 });
   }
   async listCompetitors(project) {
     return this.request("GET", `/projects/${encodeURIComponent(project)}/competitors`);
@@ -1509,9 +1641,9 @@ async function gaConnect(project, opts) {
     propertyId: opts.propertyId
   };
   if (opts.keyFile) {
-    const fs7 = await import("fs");
+    const fs8 = await import("fs");
     try {
-      const content = fs7.readFileSync(opts.keyFile, "utf-8");
+      const content = fs8.readFileSync(opts.keyFile, "utf-8");
       JSON.parse(content);
       body.keyJson = content;
     } catch (e) {
@@ -3259,10 +3391,10 @@ Brand Gap Analysis`);
     console.log(`
   Opportunity Gaps (competitors cited, you're not):`);
     for (const kw of data.gap) {
-      const competitors = kw.competitorsCiting.join(", ");
+      const competitors2 = kw.competitorsCiting.join(", ");
       const cons = kw.consistency.totalRuns > 0 ? ` [cited ${kw.consistency.citedRuns}/${kw.consistency.totalRuns} runs]` : "";
       console.log(`    \u2022 ${kw.keyword}${cons}`);
-      console.log(`      Competitors: ${competitors}`);
+      console.log(`      Competitors: ${competitors2}`);
     }
   }
   if (data.cited.length > 0) {
@@ -4525,6 +4657,10 @@ Usage: canonry settings provider ${name} --api-key <key> [--model <model>] [--ma
   }
 ];
 
+// src/commands/snapshot.ts
+import fs4 from "fs";
+import path2 from "path";
+
 // src/snapshot-pdf.ts
 import fs3 from "fs";
 import path from "path";
@@ -4806,8 +4942,8 @@ function renderQueries(pdf, report) {
     for (const result of query.providerResults) {
       const status = result.error ? "error" : result.mentioned ? result.cited ? "mentioned and cited" : "mentioned" : "not mentioned";
       const accuracy = result.describedAccurately === "not-mentioned" ? "" : `; accuracy: ${result.describedAccurately}`;
-      const competitors = result.recommendedCompetitors.length > 0 ? `; recommended instead: ${result.recommendedCompetitors.join(", ")}` : "";
-      const line = `${result.displayName}: ${status}${accuracy}${competitors}`;
+      const competitors2 = result.recommendedCompetitors.length > 0 ? `; recommended instead: ${result.recommendedCompetitors.join(", ")}` : "";
+      const line = `${result.displayName}: ${status}${accuracy}${competitors2}`;
       pdf.bullet(line);
       if (result.error) {
         pdf.paragraph(`Error: ${result.error}`, { size: 9, color: FAIL, lineHeight: 12 });
@@ -4856,6 +4992,13 @@ function wrapText(font, text, size, maxWidth) {
 function getClient16() {
   return createApiClient();
 }
+function slugify(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+function autoOutputPath(companyName, ext) {
+  const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  return `${slugify(companyName)}-snapshot-${date}.${ext}`;
+}
 async function createSnapshotReport(companyName, opts) {
   const client = getClient16();
   const report = await client.createSnapshot({
@@ -4864,23 +5007,110 @@ async function createSnapshotReport(companyName, opts) {
     ...opts.phrases && opts.phrases.length > 0 ? { phrases: opts.phrases } : {},
     ...opts.competitors && opts.competitors.length > 0 ? { competitors: opts.competitors } : {}
   });
+  let savedMdPath;
+  if (opts.md) {
+    const mdPath = opts.outputPath ?? autoOutputPath(companyName, "md");
+    savedMdPath = writeSnapshotMarkdown(report, mdPath);
+  }
   let savedPdfPath;
   if (opts.pdf) {
-    savedPdfPath = await writeSnapshotPdf(report, opts.pdf);
+    const pdfPath = opts.outputPath && !opts.md ? opts.outputPath : autoOutputPath(companyName, "pdf");
+    savedPdfPath = await writeSnapshotPdf(report, pdfPath);
   }
   if (opts.format === "json") {
     console.log(JSON.stringify(report, null, 2));
-    if (savedPdfPath) {
-      process.stderr.write(`Saved PDF: ${savedPdfPath}
+    if (savedMdPath) process.stderr.write(`Saved markdown: ${savedMdPath}
+`);
+    if (savedPdfPath) process.stderr.write(`Saved PDF: ${savedPdfPath}
 `);
-    }
     return;
   }
   console.log(formatSnapshotText(report));
-  if (savedPdfPath) {
-    console.log(`
+  if (savedMdPath) console.log(`
+Markdown saved: ${savedMdPath}`);
+  if (savedPdfPath) console.log(`
 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");
+  return resolvedPath;
+}
+function formatSnapshotMarkdown(report) {
+  const lines = [];
+  lines.push(`# AI Perception Snapshot: ${report.companyName}`);
+  lines.push("");
+  lines.push(`**Domain:** ${report.domain}`);
+  lines.push(`**Generated:** ${new Date(report.generatedAt).toLocaleString("en-US", { year: "numeric", month: "long", day: "numeric", hour: "numeric", minute: "2-digit" })}`);
+  lines.push(`**AEO Audit Score:** ${report.audit.overallScore}/100 (${report.audit.overallGrade})`);
+  lines.push("");
+  lines.push("## Visibility Gap");
+  lines.push("");
+  lines.push(report.summary.visibilityGap);
+  lines.push("");
+  if (report.summary.whatThisMeans.length > 0) {
+    lines.push("## What This Means");
+    lines.push("");
+    for (const item of report.summary.whatThisMeans) {
+      lines.push(`- ${item}`);
+    }
+    lines.push("");
+  }
+  if (report.summary.recommendedActions.length > 0) {
+    lines.push("## Recommended Actions");
+    lines.push("");
+    for (const action of report.summary.recommendedActions) {
+      lines.push(`- ${action}`);
+    }
+    lines.push("");
+  }
+  if (report.summary.topCompetitors.length > 0) {
+    lines.push("## Competitors AI Recommends Instead");
+    lines.push("");
+    lines.push("| Competitor | Mentions |");
+    lines.push("|------------|----------|");
+    for (const entry of report.summary.topCompetitors) {
+      lines.push(`| ${entry.name} | ${entry.count} |`);
+    }
+    lines.push("");
+  }
+  lines.push("## Provider Comparison");
+  lines.push("");
+  for (const query of report.queryResults) {
+    lines.push(`### "${query.phrase}"`);
+    lines.push("");
+    lines.push("| Provider | Mentioned | Cited | Accuracy | Competitors Recommended |");
+    lines.push("|----------|-----------|-------|----------|------------------------|");
+    for (const result of query.providerResults) {
+      if (result.error) {
+        lines.push(`| ${result.displayName} | ERROR | - | - | ${result.error} |`);
+        continue;
+      }
+      const mentioned = result.mentioned ? "Yes" : "No";
+      const cited = result.cited ? "Yes" : "No";
+      const accuracy = result.describedAccurately === "not-mentioned" ? "-" : result.describedAccurately;
+      const competitors2 = result.recommendedCompetitors.length > 0 ? result.recommendedCompetitors.join(", ") : "-";
+      lines.push(`| ${result.displayName} | ${mentioned} | ${cited} | ${accuracy} | ${competitors2} |`);
+    }
+    lines.push("");
+  }
+  if (report.audit.factors.length > 0) {
+    lines.push("## Audit Factors");
+    lines.push("");
+    lines.push(report.audit.summary);
+    lines.push("");
+    lines.push("| Factor | Score | Weight | Status |");
+    lines.push("|--------|-------|--------|--------|");
+    const sorted = [...report.audit.factors].sort((a, b) => a.score - b.score);
+    for (const factor of sorted) {
+      lines.push(`| ${factor.name} | ${factor.score} | ${factor.weight} | ${factor.status} |`);
+    }
+    lines.push("");
   }
+  lines.push("---");
+  lines.push(`*Generated by [Canonry](https://github.com/AINYC/canonry)*`);
+  return lines.join("\n");
 }
 function formatSnapshotText(report) {
   const lines = [];
@@ -4948,15 +5178,17 @@ function parseCsvOption(value) {
 var SNAPSHOT_CLI_COMMANDS = [
   {
     path: ["snapshot"],
-    usage: 'canonry snapshot <company-name> --domain <domain> [--phrases "a,b"] [--competitors "x,y"] [--pdf <path>] [--format table|json]',
+    usage: 'canonry snapshot <company-name> --domain <domain> [--phrases "a,b"] [--competitors "x,y"] [--md] [--output <path>] [--pdf] [--format table|json]',
     options: {
       domain: stringOption(),
       phrases: stringOption(),
       competitors: stringOption(),
-      pdf: stringOption()
+      md: { type: "boolean" },
+      pdf: { type: "boolean" },
+      output: stringOption()
     },
     run: async (input) => {
-      const usage = 'canonry snapshot <company-name> --domain <domain> [--phrases "a,b"] [--competitors "x,y"] [--pdf <path>] [--format table|json]';
+      const usage = 'canonry snapshot <company-name> --domain <domain> [--phrases "a,b"] [--competitors "x,y"] [--md] [--output <path>] [--pdf] [--format table|json]';
       const companyName = requirePositional(input, 0, {
         command: "snapshot",
         usage,
@@ -4967,11 +5199,17 @@ var SNAPSHOT_CLI_COMMANDS = [
         usage,
         message: "--domain is required"
       });
+      const outputPath = getString(input.values, "output");
+      const explicitMd = getBoolean(input.values, "md");
+      const wantsPdf = getBoolean(input.values, "pdf");
+      const wantsMd = explicitMd || !!outputPath && !wantsPdf;
       await createSnapshotReport(companyName, {
         domain,
         phrases: parseCsvOption(getString(input.values, "phrases")),
         competitors: parseCsvOption(getString(input.values, "competitors")),
-        pdf: getString(input.values, "pdf"),
+        md: wantsMd,
+        pdf: wantsPdf,
+        outputPath,
         format: input.format
       });
     }
@@ -5100,7 +5338,7 @@ var INTELLIGENCE_CLI_COMMANDS = [
 
 // src/commands/bootstrap.ts
 import crypto from "crypto";
-import path2 from "path";
+import path3 from "path";
 import { eq as eq2 } from "drizzle-orm";
 
 // ../config/src/index.ts
@@ -5247,7 +5485,7 @@ async function bootstrapCommand(_opts) {
     );
   }
   const configDir = getConfigDir();
-  const databasePath = env.databasePath || path2.join(configDir, "data.db");
+  const databasePath = env.databasePath || path3.join(configDir, "data.db");
   const existing = configExists();
   const existingConfig = existing ? loadConfig() : void 0;
   let rawApiKey;
@@ -5317,10 +5555,10 @@ async function bootstrapCommand(_opts) {
 
 // src/commands/daemon.ts
 import { spawn } from "child_process";
-import fs4 from "fs";
-import path3 from "path";
+import fs5 from "fs";
+import path4 from "path";
 function getPidPath() {
-  return path3.join(getConfigDir(), "canonry.pid");
+  return path4.join(getConfigDir(), "canonry.pid");
 }
 function isProcessAlive(pid) {
   try {
@@ -5347,8 +5585,8 @@ async function waitForReady(host, port, maxMs = 1e4) {
 async function startDaemon(opts) {
   const pidPath = getPidPath();
   const format = opts.format ?? "text";
-  if (fs4.existsSync(pidPath)) {
-    const existingPid = parseInt(fs4.readFileSync(pidPath, "utf-8").trim(), 10);
+  if (fs5.existsSync(pidPath)) {
+    const existingPid = parseInt(fs5.readFileSync(pidPath, "utf-8").trim(), 10);
     if (!isNaN(existingPid) && isProcessAlive(existingPid)) {
       throw new CliError({
         code: "DAEMON_ALREADY_RUNNING",
@@ -5359,9 +5597,9 @@ async function startDaemon(opts) {
         }
       });
     }
-    fs4.unlinkSync(pidPath);
+    fs5.unlinkSync(pidPath);
   }
-  const cliPath = path3.resolve(new URL(import.meta.url).pathname);
+  const cliPath = path4.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);
@@ -5380,10 +5618,10 @@ async function startDaemon(opts) {
     });
   }
   const configDir = getConfigDir();
-  if (!fs4.existsSync(configDir)) {
-    fs4.mkdirSync(configDir, { recursive: true });
+  if (!fs5.existsSync(configDir)) {
+    fs5.mkdirSync(configDir, { recursive: true });
   }
-  fs4.writeFileSync(pidPath, String(child.pid), "utf-8");
+  fs5.writeFileSync(pidPath, String(child.pid), "utf-8");
   const port = opts.port ?? "4100";
   const host = opts.host ?? "127.0.0.1";
   if (format !== "json") {
@@ -5392,7 +5630,7 @@ async function startDaemon(opts) {
   const ready = await waitForReady(host, port);
   if (!ready) {
     try {
-      fs4.unlinkSync(pidPath);
+      fs5.unlinkSync(pidPath);
     } catch {
     }
     throw new CliError({
@@ -5424,7 +5662,7 @@ async function startDaemon(opts) {
 }
 function stopDaemon(format = "text") {
   const pidPath = getPidPath();
-  if (!fs4.existsSync(pidPath)) {
+  if (!fs5.existsSync(pidPath)) {
     if (format === "json") {
       console.log(JSON.stringify({
         stopped: false,
@@ -5435,7 +5673,7 @@ function stopDaemon(format = "text") {
     console.log("Canonry is not running (no PID file found)");
     return;
   }
-  const pid = parseInt(fs4.readFileSync(pidPath, "utf-8").trim(), 10);
+  const pid = parseInt(fs5.readFileSync(pidPath, "utf-8").trim(), 10);
   if (isNaN(pid)) {
     if (format === "json") {
       console.log(JSON.stringify({
@@ -5446,7 +5684,7 @@ function stopDaemon(format = "text") {
     } else {
       console.error("Invalid PID file. Removing it.");
     }
-    fs4.unlinkSync(pidPath);
+    fs5.unlinkSync(pidPath);
     return;
   }
   if (!isProcessAlive(pid)) {
@@ -5460,12 +5698,12 @@ function stopDaemon(format = "text") {
     } else {
       console.log(`Canonry is not running (stale PID: ${pid}). Cleaning up.`);
     }
-    fs4.unlinkSync(pidPath);
+    fs5.unlinkSync(pidPath);
     return;
   }
   try {
     process.kill(pid, "SIGTERM");
-    fs4.unlinkSync(pidPath);
+    fs5.unlinkSync(pidPath);
     if (format === "json") {
       console.log(JSON.stringify({
         stopped: true,
@@ -5489,9 +5727,9 @@ function stopDaemon(format = "text") {
 
 // src/commands/init.ts
 import crypto2 from "crypto";
-import fs5 from "fs";
+import fs6 from "fs";
 import readline from "readline";
-import path4 from "path";
+import path5 from "path";
 function prompt(question) {
   const rl = readline.createInterface({
     input: process.stdin,
@@ -5528,8 +5766,8 @@ async function initCommand(opts) {
     return;
   }
   const configDir = getConfigDir();
-  if (!fs5.existsSync(configDir)) {
-    fs5.mkdirSync(configDir, { recursive: true });
+  if (!fs6.existsSync(configDir)) {
+    fs6.mkdirSync(configDir, { recursive: true });
   }
   const bootstrapEnv = getBootstrapEnv(process.env, {
     GEMINI_API_KEY: opts?.geminiKey,
@@ -5644,7 +5882,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 = path4.join(configDir, "data.db");
+  const databasePath = path5.join(configDir, "data.db");
   const db = createClient(databasePath);
   migrate(db);
   db.insert(apiKeys).values({
@@ -6006,7 +6244,7 @@ var SYSTEM_CLI_COMMANDS = [
 ];
 
 // src/cli-commands/wordpress.ts
-import fs6 from "fs";
+import fs7 from "fs";
 
 // src/commands/wordpress.ts
 function getClient17() {
@@ -6242,12 +6480,12 @@ async function wordpressSetMeta(project, body) {
   printPageDetail(result);
 }
 async function wordpressBulkSetMeta(project, opts) {
-  const fs7 = await import("fs/promises");
-  const path5 = await import("path");
-  const filePath = path5.resolve(opts.from);
+  const fs8 = await import("fs/promises");
+  const path6 = await import("path");
+  const filePath = path6.resolve(opts.from);
   let raw;
   try {
-    raw = await fs7.readFile(filePath, "utf8");
+    raw = await fs8.readFile(filePath, "utf8");
   } catch {
     throw new CliError({
       code: "FILE_READ_ERROR",
@@ -6344,13 +6582,13 @@ async function wordpressSetSchema(project, body) {
   printManualAssist(`Schema update for "${body.slug}"`, result);
 }
 async function wordpressSchemaDeploy(project, opts) {
-  const fs7 = await import("fs/promises");
-  const path5 = await import("path");
+  const fs8 = await import("fs/promises");
+  const path6 = await import("path");
   const yaml = await import("yaml").catch(() => null);
-  const filePath = path5.resolve(opts.profile);
+  const filePath = path6.resolve(opts.profile);
   let raw;
   try {
-    raw = await fs7.readFile(filePath, "utf8");
+    raw = await fs8.readFile(filePath, "utf8");
   } catch {
     throw new CliError({
       code: "FILE_READ_ERROR",
@@ -6455,13 +6693,13 @@ async function wordpressOnboard(project, opts) {
   }
   let profileData;
   if (opts.profile) {
-    const fs7 = await import("fs/promises");
-    const path5 = await import("path");
+    const fs8 = await import("fs/promises");
+    const path6 = await import("path");
     const yaml = await import("yaml").catch(() => null);
-    const filePath = path5.resolve(opts.profile);
+    const filePath = path6.resolve(opts.profile);
     let raw;
     try {
-      raw = await fs7.readFile(filePath, "utf8");
+      raw = await fs8.readFile(filePath, "utf8");
     } catch {
       throw new CliError({
         code: "FILE_READ_ERROR",
@@ -6610,7 +6848,7 @@ function resolveContent(input, command, usage, options) {
   }
   if (contentFile) {
     try {
-      return fs6.readFileSync(contentFile, "utf-8");
+      return fs7.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}`, {