geo-ai-search-optimization 1.4.2 → 2.2.0

package/src/cli-site-ops-commands.js

@@ -1,3 +1,14 @@
+import { createAuditDiffFromFiles, renderAuditDiffMarkdown, writeAuditDiffOutput } from "./audit-diff.js";
+import { batchAuditPages, renderBatchPageAuditMarkdown, writeBatchPageAuditOutput } from "./batch-page-audit.js";
+import { saveSnapshot } from "./snapshot.js";
+import { runBenchmark, renderBenchmarkMarkdown, writeBenchmarkOutput } from "./benchmark.js";
+import { checkCitation, renderCitationCheckMarkdown, writeCitationCheckOutput } from "./citation-check.js";
+import { monitorCitations, renderCitationMonitorMarkdown, writeCitationMonitorOutput } from "./citation-monitor.js";
+import { runCiCheck, renderCiCheckMarkdown, writeCiCheckOutput } from "./ci.js";
+import { analyzeContentGap, renderContentGapMarkdown, writeContentGapOutput } from "./content-gap.js";
+import { initHook, renderInitHookMarkdown, writeInitHookOutput } from "./pre-commit.js";
+import { startWatch } from "./watch.js";
+import { buildTrend, renderTrendMarkdown, writeTrendOutput } from "./trend.js";
 import { auditProject, renderAuditMarkdown, writeAuditOutput } from "./audit.js";
 import {
   createActionCommandHandler,
@@ -20,6 +31,29 @@ import { createRewritePack, renderRewritePackMarkdown, writeRewritePackOutput }
 import { renderScanMarkdown, scanProject, writeScanOutput } from "./scan.js";
 import { createSchemaTemplate } from "./schema.js";
 import { analyzeWebsiteUrl, renderWebsiteOnboardingMarkdown, writeWebsiteOnboardingOutput } from "./url-onboarding.js";
+import { analyzeCrawlers, renderCrawlersMarkdown, writeCrawlersOutput } from "./crawlers.js";
+import { analyzeCitability, renderCitabilityMarkdown, writeCitabilityOutput } from "./citability.js";
+import { validateLlmsTxt, renderValidateLlmsMarkdown, writeValidateLlmsOutput } from "./validate-llms.js";
+import { validateSchema, renderValidateSchemaMarkdown, writeValidateSchemaOutput } from "./validate-schema.js";
+import { analyzeEeat, renderEeatMarkdown, writeEeatOutput } from "./eeat.js";
+import { analyzePlatformReadiness, renderPlatformReadyMarkdown, writePlatformReadyOutput } from "./platform-ready.js";
+import { analyzeReadability, renderReadabilityMarkdown, writeReadabilityOutput } from "./readability.js";
+import { analyzeHeadingStructure, renderHeadingStructureMarkdown, writeHeadingStructureOutput } from "./heading-structure.js";
+import { analyzeInternalLinks, renderInternalLinksMarkdown, writeInternalLinksOutput } from "./internal-links.js";
+import { analyzeSocialMeta, renderSocialMetaMarkdown, writeSocialMetaOutput } from "./social-meta.js";
+import { initConfig } from "./config.js";
+import { writePdfReport } from "./pdf-report.js";
+import { fullPageAudit, renderFullPageAuditMarkdown, writeFullPageAuditOutput } from "./full-page-audit.js";
+import { fullAudit, renderFullAuditMarkdown, writeFullAuditOutput } from "./full-audit.js";
+import { analyzeSitemap, renderSitemapMarkdown, writeSitemapOutput } from "./sitemap.js";
+import { analyzeSecurity, renderSecurityMarkdown, writeSecurityOutput } from "./security.js";
+import { analyzeFreshness, renderFreshnessMarkdown, writeFreshnessOutput } from "./freshness.js";
+import { analyzeTopics, renderTopicsMarkdown, writeTopicsOutput } from "./topics.js";
+import { batchFullPageAudit, renderBatchFullPageAuditMarkdown, writeBatchFullPageAuditOutput } from "./batch-full-page-audit.js";
+import { generateAutoFix, renderAutoFixMarkdown, writeAutoFixOutput } from "./auto-fix.js";
+import { savePageSnapshot, buildPageTrend, renderPageTrendMarkdown, writePageTrendOutput } from "./page-snapshot.js";
+import { diagnose, renderDiagnoseMarkdown, writeDiagnoseOutput } from "./diagnose.js";
+import { comparePages, renderCompareMarkdown, writeCompareOutput } from "./compare.js";
 
 export const SITE_OPS_HELP_LINES = [
   "  geo-ai-search-optimization doctor [--json]",
@@ -31,8 +65,41 @@ export const SITE_OPS_HELP_LINES = [
   "  geo-ai-search-optimization repo-patch-plan <project-path> [--json] [--out <file>]",
   "  geo-ai-search-optimization init-llms [target-dir] [--site-name <name>] [--site-url <url>] [--overwrite] [--json]",
   "  geo-ai-search-optimization init-schema <type> [target-dir] [--site-url <url>] [--overwrite] [--json]",
-  "  geo-ai-search-optimization audit <project-path> [--json] [--out <file>] [--max-file-size <bytes>] [--max-examples <count>]",
-  "  geo-ai-search-optimization scan <project-path> [--json] [--out <file>] [--max-file-size <bytes>] [--max-examples <count>]"
+  "  geo-ai-search-optimization audit <project-path> [--json] [--out <file>] [--save] [--data-dir <dir>] [--max-file-size <bytes>] [--max-examples <count>]",
+  "  geo-ai-search-optimization scan <project-path> [--json] [--out <file>] [--max-file-size <bytes>] [--max-examples <count>]",
+  "  geo-ai-search-optimization audit-diff <baseline.json> <current.json> [--json] [--out <file>]",
+  "  geo-ai-search-optimization batch-page-audit <url1> [url2...] [--urls-file <file>] [--concurrency <n>] [--json] [--out <file>]",
+  "  geo-ai-search-optimization trend [--data-dir <dir>] [--last <n>] [--json] [--out <file>]",
+  "  geo-ai-search-optimization benchmark <your-url> --competitors <url1,url2,...> [--json] [--out <file>]",
+  "  geo-ai-search-optimization content-gap <your-url> --competitors <url1,url2,...> [--json] [--out <file>]",
+  "  geo-ai-search-optimization ci <project-path> [--min-score <n>] [--baseline <file>] [--fail-on-regression] [--json]",
+  "  geo-ai-search-optimization watch <project-path> [--debounce <ms>]",
+  "  geo-ai-search-optimization init-hook [--min-score <n>] [target-dir]",
+  "  geo-ai-search-optimization citation-check <site-url> --queries <q1,q2,...> [--queries-file <file>] [--engine <perplexity|google|all>] [--json] [--out <file>]",
+  "  geo-ai-search-optimization citation-monitor <site-url> --queries-file <file> [--save] [--json] [--out <file>]",
+  "  geo-ai-search-optimization crawlers <url-or-file> [--strategy <open|selective|block-all>] [--json] [--out <file>]",
+  "  geo-ai-search-optimization citability <url-or-file> [--json] [--out <file>]",
+  "  geo-ai-search-optimization validate-llms <url-or-file> [--json] [--out <file>]",
+  "  geo-ai-search-optimization validate-schema <url-or-file> [--json] [--out <file>]",
+  "  geo-ai-search-optimization eeat <url-or-file> [--json] [--out <file>]",
+  "  geo-ai-search-optimization platform-ready <url-or-file> [--json] [--out <file>]",
+  "  geo-ai-search-optimization readability <url-or-file> [--json] [--out <file>]",
+  "  geo-ai-search-optimization heading-structure <url-or-file> [--json] [--out <file>]",
+  "  geo-ai-search-optimization internal-links <url-or-file> [--base-url <url>] [--json] [--out <file>]",
+  "  geo-ai-search-optimization social-meta <url-or-file> [--json] [--out <file>]",
+  "  geo-ai-search-optimization init-config [target-dir] [--site-name <name>] [--site-url <url>] [--overwrite] [--json]",
+  "  geo-ai-search-optimization pdf-report <audit.json> [--out <file>] [--title <title>]",
+  "  geo-ai-search-optimization full-page-audit <url-or-file> [--base-url <url>] [--save] [--data-dir <dir>] [--json] [--out <file>]",
+  "  geo-ai-search-optimization full-audit <project-path> [--sample-urls <url1,url2,...>] [--max-file-size <bytes>] [--save] [--data-dir <dir>] [--json] [--out <file>]",
+  "  geo-ai-search-optimization sitemap <url-or-file> [--json] [--out <file>]",
+  "  geo-ai-search-optimization security <url-or-file> [--json] [--out <file>]",
+  "  geo-ai-search-optimization freshness <url-or-file> [--json] [--out <file>]",
+  "  geo-ai-search-optimization topics <url-or-file> [--json] [--out <file>]",
+  "  geo-ai-search-optimization batch-full-page-audit <url1> [url2...] [--urls-file <file>] [--concurrency <n>] [--json] [--out <file>]",
+  "  geo-ai-search-optimization auto-fix <url-or-file> [--json] [--out <file>]",
+  "  geo-ai-search-optimization page-trend <url-or-file> [--data-dir <dir>] [--last <n>] [--json] [--out <file>]",
+  "  geo-ai-search-optimization diagnose <url-or-dir-or-file> [--json] [--out <file>]",
+  "  geo-ai-search-optimization compare <url-or-file-A> <url-or-file-B> [--json] [--out <file>]"
 ];
 
 const passthroughWriteOutput = async (outputPath) => outputPath;
@@ -171,7 +238,7 @@ const handleAudit = createStructuredOutputCommandHandler({
       throw new Error("audit requires a project path");
     }
 
-    return auditProject(projectPath, {
+    const result = await auditProject(projectPath, {
       maxFileSize: getFlagValue(args, "--max-file-size")
         ? parsePositiveInteger(getFlagValue(args, "--max-file-size"), "--max-file-size")
         : undefined,
@@ -179,6 +246,14 @@ const handleAudit = createStructuredOutputCommandHandler({
         ? parsePositiveInteger(getFlagValue(args, "--max-examples"), "--max-examples")
         : undefined
     });
+
+    if (hasFlag(args, "--save")) {
+      const dataDir = getFlagValue(args, "--data-dir") || undefined;
+      const saved = await saveSnapshot(result, { dataDir });
+      process.stderr.write(`快照已保存：${saved.path}\n`);
+    }
+
+    return result;
   },
   renderMarkdown: (report) => `${renderAuditMarkdown(report)}\n`,
   writeOutput: writeAuditOutput,
@@ -206,6 +281,532 @@ const handleScan = createStructuredOutputCommandHandler({
   getOutputJson: (args) => hasFlag(args, "--json")
 });
 
+const handleBatchPageAudit = createStructuredOutputCommandHandler({
+  commandLabel: "批量页面审计",
+  execute: async (args) => {
+    const nonFlags = args.filter((value) => !value.startsWith("-"));
+    const urlsFile = getFlagValue(args, "--urls-file");
+    let urls = [...nonFlags];
+
+    if (urlsFile) {
+      const { readFile } = await import("node:fs/promises");
+      const fileContent = await readFile(urlsFile, "utf8");
+      const fileUrls = fileContent.split("\n").map((line) => line.trim()).filter(Boolean);
+      urls = [...urls, ...fileUrls];
+    }
+
+    if (urls.length === 0) {
+      throw new Error("batch-page-audit requires at least one URL or file path");
+    }
+
+    const concurrencyValue = getFlagValue(args, "--concurrency");
+    return batchAuditPages(urls, {
+      concurrency: concurrencyValue ? parsePositiveInteger(concurrencyValue, "--concurrency") : 3
+    });
+  },
+  renderMarkdown: renderBatchPageAuditMarkdown,
+  writeOutput: writeBatchPageAuditOutput,
+  getOutputJson: (args) => hasFlag(args, "--json")
+});
+
+const handleAuditDiff = createStructuredOutputCommandHandler({
+  commandLabel: "审计对比",
+  execute: async (args) => {
+    const nonFlags = args.filter((value) => !value.startsWith("-"));
+    if (nonFlags.length < 2) {
+      throw new Error("audit-diff requires two audit JSON files: <baseline.json> <current.json>");
+    }
+    return createAuditDiffFromFiles(nonFlags[0], nonFlags[1]);
+  },
+  renderMarkdown: renderAuditDiffMarkdown,
+  writeOutput: writeAuditDiffOutput,
+  getOutputJson: (args) => hasFlag(args, "--json")
+});
+
+const handleCi = createStructuredOutputCommandHandler({
+  commandLabel: "CI 检查",
+  execute: async (args) => {
+    const projectPath = args.find((value) => !value.startsWith("-"));
+    if (!projectPath) {
+      throw new Error("ci requires a project path");
+    }
+    const minScoreValue = getFlagValue(args, "--min-score");
+    const result = await runCiCheck(projectPath, {
+      minScore: minScoreValue ? parsePositiveInteger(minScoreValue, "--min-score") : 40,
+      baseline: getFlagValue(args, "--baseline") || undefined,
+      failOnRegression: hasFlag(args, "--fail-on-regression")
+    });
+    if (result.exitCode !== 0) {
+      process.exitCode = result.exitCode;
+    }
+    return result;
+  },
+  renderMarkdown: renderCiCheckMarkdown,
+  writeOutput: writeCiCheckOutput,
+  getOutputJson: (args) => hasFlag(args, "--json")
+});
+
+const handleBenchmark = createStructuredOutputCommandHandler({
+  commandLabel: "竞品基准",
+  execute: async (args) => {
+    const ownUrl = args.find((value) => !value.startsWith("-"));
+    if (!ownUrl) {
+      throw new Error("benchmark requires your URL as the first argument");
+    }
+    const competitorsRaw = getFlagValue(args, "--competitors");
+    if (!competitorsRaw) {
+      throw new Error("benchmark requires --competitors <url1,url2,...>");
+    }
+    const competitorUrls = competitorsRaw.split(",").map((u) => u.trim()).filter(Boolean);
+    return runBenchmark(ownUrl, competitorUrls);
+  },
+  renderMarkdown: renderBenchmarkMarkdown,
+  writeOutput: writeBenchmarkOutput,
+  getOutputJson: (args) => hasFlag(args, "--json")
+});
+
+const handleContentGap = createStructuredOutputCommandHandler({
+  commandLabel: "内容缺口",
+  execute: async (args) => {
+    const firstArg = args.find((value) => !value.startsWith("-"));
+    if (!firstArg) {
+      throw new Error("content-gap requires a URL or benchmark JSON file");
+    }
+
+    // Check if it's a benchmark JSON file
+    if (firstArg.endsWith(".json")) {
+      return analyzeContentGap(null, [], { benchmarkJson: firstArg });
+    }
+
+    const competitorsRaw = getFlagValue(args, "--competitors");
+    if (!competitorsRaw) {
+      throw new Error("content-gap requires --competitors <url1,url2,...> or a benchmark JSON file");
+    }
+    const competitorUrls = competitorsRaw.split(",").map((u) => u.trim()).filter(Boolean);
+    return analyzeContentGap(firstArg, competitorUrls);
+  },
+  renderMarkdown: renderContentGapMarkdown,
+  writeOutput: writeContentGapOutput,
+  getOutputJson: (args) => hasFlag(args, "--json")
+});
+
+const handleTrend = createStructuredOutputCommandHandler({
+  commandLabel: "趋势",
+  execute: async (args) => {
+    const lastValue = getFlagValue(args, "--last");
+    return buildTrend({
+      dataDir: getFlagValue(args, "--data-dir") || undefined,
+      last: lastValue ? parsePositiveInteger(lastValue, "--last") : 0
+    });
+  },
+  renderMarkdown: renderTrendMarkdown,
+  writeOutput: writeTrendOutput,
+  getOutputJson: (args) => hasFlag(args, "--json")
+});
+
+async function parseQueries(args) {
+  const queriesRaw = getFlagValue(args, "--queries");
+  const queriesFile = getFlagValue(args, "--queries-file");
+  let queries = [];
+
+  if (queriesRaw) {
+    queries = queriesRaw.split(",").map((q) => q.trim()).filter(Boolean);
+  }
+
+  if (queriesFile) {
+    const { readFile } = await import("node:fs/promises");
+    const fileContent = await readFile(queriesFile, "utf8");
+    const fileQueries = fileContent.split("\n").map((line) => line.trim()).filter(Boolean);
+    queries = [...queries, ...fileQueries];
+  }
+
+  return queries;
+}
+
+function parseEngines(args) {
+  const engineRaw = getFlagValue(args, "--engine");
+  if (!engineRaw || engineRaw === "all") return ["perplexity", "google"];
+  return [engineRaw];
+}
+
+const handleCitationCheck = createStructuredOutputCommandHandler({
+  commandLabel: "引用检查",
+  execute: async (args) => {
+    const siteUrl = args.find((value) => !value.startsWith("-"));
+    if (!siteUrl) throw new Error("citation-check requires a site URL");
+    const queries = await parseQueries(args);
+    if (queries.length === 0) throw new Error("citation-check requires --queries or --queries-file");
+    return checkCitation(siteUrl, queries, { engines: parseEngines(args) });
+  },
+  renderMarkdown: renderCitationCheckMarkdown,
+  writeOutput: writeCitationCheckOutput,
+  getOutputJson: (args) => hasFlag(args, "--json")
+});
+
+const handleCitationMonitor = createStructuredOutputCommandHandler({
+  commandLabel: "引用监控",
+  execute: async (args) => {
+    const siteUrl = args.find((value) => !value.startsWith("-"));
+    if (!siteUrl) throw new Error("citation-monitor requires a site URL");
+    const queries = await parseQueries(args);
+    if (queries.length === 0) throw new Error("citation-monitor requires --queries-file");
+    return monitorCitations(siteUrl, queries, {
+      engines: parseEngines(args),
+      save: hasFlag(args, "--save"),
+      dataDir: getFlagValue(args, "--data-dir") || undefined
+    });
+  },
+  renderMarkdown: renderCitationMonitorMarkdown,
+  writeOutput: writeCitationMonitorOutput,
+  getOutputJson: (args) => hasFlag(args, "--json")
+});
+
+const handleWatch = async (args) => {
+  const projectPath = args.find((value) => !value.startsWith("-"));
+  if (!projectPath) {
+    throw new Error("watch requires a project path");
+  }
+  const debounceValue = getFlagValue(args, "--debounce");
+  await startWatch(projectPath, {
+    debounce: debounceValue ? parsePositiveInteger(debounceValue, "--debounce") : 500
+  });
+};
+
+const handleInitHook = createStructuredOutputCommandHandler({
+  commandLabel: "init-hook",
+  execute: async (args) => {
+    const minScoreValue = getFlagValue(args, "--min-score");
+    const targetDir = args.find((value) => !value.startsWith("-")) || ".";
+    return initHook({
+      minScore: minScoreValue ? parsePositiveInteger(minScoreValue, "--min-score") : 40,
+      targetDir
+    });
+  },
+  renderMarkdown: renderInitHookMarkdown,
+  writeOutput: writeInitHookOutput,
+  getOutputJson: (args) => hasFlag(args, "--json")
+});
+
+const handleCrawlers = createStructuredOutputCommandHandler({
+  commandLabel: "AI crawler analysis",
+  execute: async (args) => {
+    const input = args.find((value) => !value.startsWith("-"));
+    if (!input) throw new Error("crawlers requires a URL or robots.txt file path");
+    return analyzeCrawlers(input, { strategy: getFlagValue(args, "--strategy") || "open" });
+  },
+  renderMarkdown: renderCrawlersMarkdown,
+  writeOutput: writeCrawlersOutput,
+  getOutputJson: (args) => hasFlag(args, "--json")
+});
+
+const handleCitability = createStructuredOutputCommandHandler({
+  commandLabel: "citability analysis",
+  execute: async (args) => {
+    const input = args.find((value) => !value.startsWith("-"));
+    if (!input) throw new Error("citability requires a URL or file path");
+    return analyzeCitability(input);
+  },
+  renderMarkdown: renderCitabilityMarkdown,
+  writeOutput: writeCitabilityOutput,
+  getOutputJson: (args) => hasFlag(args, "--json")
+});
+
+const handleValidateLlms = createStructuredOutputCommandHandler({
+  commandLabel: "llms.txt validation",
+  execute: async (args) => {
+    const input = args.find((value) => !value.startsWith("-"));
+    if (!input) throw new Error("validate-llms requires a URL or llms.txt file path");
+    return validateLlmsTxt(input);
+  },
+  renderMarkdown: renderValidateLlmsMarkdown,
+  writeOutput: writeValidateLlmsOutput,
+  getOutputJson: (args) => hasFlag(args, "--json")
+});
+
+const handleValidateSchema = createStructuredOutputCommandHandler({
+  commandLabel: "schema validation",
+  execute: async (args) => {
+    const input = args.find((value) => !value.startsWith("-"));
+    if (!input) throw new Error("validate-schema requires a URL or file path");
+    return validateSchema(input);
+  },
+  renderMarkdown: renderValidateSchemaMarkdown,
+  writeOutput: writeValidateSchemaOutput,
+  getOutputJson: (args) => hasFlag(args, "--json")
+});
+
+const handleEeat = createStructuredOutputCommandHandler({
+  commandLabel: "E-E-A-T analysis",
+  execute: async (args) => {
+    const input = args.find((value) => !value.startsWith("-"));
+    if (!input) throw new Error("eeat requires a URL or file path");
+    return analyzeEeat(input);
+  },
+  renderMarkdown: renderEeatMarkdown,
+  writeOutput: writeEeatOutput,
+  getOutputJson: (args) => hasFlag(args, "--json")
+});
+
+const handlePlatformReady = createStructuredOutputCommandHandler({
+  commandLabel: "platform readiness",
+  execute: async (args) => {
+    const input = args.find((value) => !value.startsWith("-"));
+    if (!input) throw new Error("platform-ready requires a URL or file path");
+    return analyzePlatformReadiness(input);
+  },
+  renderMarkdown: renderPlatformReadyMarkdown,
+  writeOutput: writePlatformReadyOutput,
+  getOutputJson: (args) => hasFlag(args, "--json")
+});
+
+const handleReadability = createStructuredOutputCommandHandler({
+  commandLabel: "readability analysis",
+  execute: async (args) => {
+    const input = args.find((value) => !value.startsWith("-"));
+    if (!input) throw new Error("readability requires a URL or file path");
+    return analyzeReadability(input);
+  },
+  renderMarkdown: renderReadabilityMarkdown,
+  writeOutput: writeReadabilityOutput,
+  getOutputJson: (args) => hasFlag(args, "--json")
+});
+
+const handleHeadingStructure = createStructuredOutputCommandHandler({
+  commandLabel: "heading structure",
+  execute: async (args) => {
+    const input = args.find((value) => !value.startsWith("-"));
+    if (!input) throw new Error("heading-structure requires a URL or file path");
+    return analyzeHeadingStructure(input);
+  },
+  renderMarkdown: renderHeadingStructureMarkdown,
+  writeOutput: writeHeadingStructureOutput,
+  getOutputJson: (args) => hasFlag(args, "--json")
+});
+
+const handleInternalLinks = createStructuredOutputCommandHandler({
+  commandLabel: "internal links",
+  execute: async (args) => {
+    const input = args.find((value) => !value.startsWith("-"));
+    if (!input) throw new Error("internal-links requires a URL or file path");
+    return analyzeInternalLinks(input, { baseUrl: getFlagValue(args, "--base-url") });
+  },
+  renderMarkdown: renderInternalLinksMarkdown,
+  writeOutput: writeInternalLinksOutput,
+  getOutputJson: (args) => hasFlag(args, "--json")
+});
+
+const handleSocialMeta = createStructuredOutputCommandHandler({
+  commandLabel: "social meta",
+  execute: async (args) => {
+    const input = args.find((value) => !value.startsWith("-"));
+    if (!input) throw new Error("social-meta requires a URL or file path");
+    return analyzeSocialMeta(input);
+  },
+  renderMarkdown: renderSocialMetaMarkdown,
+  writeOutput: writeSocialMetaOutput,
+  getOutputJson: (args) => hasFlag(args, "--json")
+});
+
+const handleInitConfig = createActionCommandHandler({
+  execute: async (args) =>
+    initConfig({
+      targetDir: args.find((value) => !value.startsWith("-")) || ".",
+      siteName: getFlagValue(args, "--site-name"),
+      siteUrl: getFlagValue(args, "--site-url"),
+      overwrite: hasFlag(args, "--overwrite")
+    }),
+  getOutputJson: (args) => hasFlag(args, "--json"),
+  renderText: (result) => `Created config at ${result.outputPath}\n`
+});
+
+const handlePdfReport = createActionCommandHandler({
+  execute: async (args) => {
+    const input = args.find((value) => !value.startsWith("-"));
+    if (!input) throw new Error("pdf-report requires an audit JSON file path");
+    return writePdfReport(input, getFlagValue(args, "--out"), {
+      title: getFlagValue(args, "--title")
+    });
+  },
+  getOutputJson: (args) => hasFlag(args, "--json"),
+  renderText: (result) => `Generated PDF-ready HTML report at ${result.outputPath}\n`
+});
+
+const handleSitemap = createStructuredOutputCommandHandler({
+  commandLabel: "sitemap analysis",
+  execute: async (args) => {
+    const input = args.find((value) => !value.startsWith("-"));
+    if (!input) throw new Error("sitemap requires a URL or sitemap file path");
+    return analyzeSitemap(input);
+  },
+  renderMarkdown: renderSitemapMarkdown,
+  writeOutput: writeSitemapOutput,
+  getOutputJson: (args) => hasFlag(args, "--json")
+});
+
+const handleSecurity = createStructuredOutputCommandHandler({
+  commandLabel: "security analysis",
+  execute: async (args) => {
+    const input = args.find((value) => !value.startsWith("-"));
+    if (!input) throw new Error("security requires a URL or file path");
+    return analyzeSecurity(input);
+  },
+  renderMarkdown: renderSecurityMarkdown,
+  writeOutput: writeSecurityOutput,
+  getOutputJson: (args) => hasFlag(args, "--json")
+});
+
+const handleFreshness = createStructuredOutputCommandHandler({
+  commandLabel: "freshness analysis",
+  execute: async (args) => {
+    const input = args.find((value) => !value.startsWith("-"));
+    if (!input) throw new Error("freshness requires a URL or file path");
+    return analyzeFreshness(input);
+  },
+  renderMarkdown: renderFreshnessMarkdown,
+  writeOutput: writeFreshnessOutput,
+  getOutputJson: (args) => hasFlag(args, "--json")
+});
+
+const handleTopics = createStructuredOutputCommandHandler({
+  commandLabel: "topic analysis",
+  execute: async (args) => {
+    const input = args.find((value) => !value.startsWith("-"));
+    if (!input) throw new Error("topics requires a URL or file path");
+    return analyzeTopics(input);
+  },
+  renderMarkdown: renderTopicsMarkdown,
+  writeOutput: writeTopicsOutput,
+  getOutputJson: (args) => hasFlag(args, "--json")
+});
+
+const handleBatchFullPageAudit = createStructuredOutputCommandHandler({
+  commandLabel: "batch full page audit",
+  execute: async (args) => {
+    const nonFlags = args.filter((value) => !value.startsWith("-"));
+    const urlsFile = getFlagValue(args, "--urls-file");
+    let urls = [...nonFlags];
+
+    if (urlsFile) {
+      const { readFile } = await import("node:fs/promises");
+      const fileContent = await readFile(urlsFile, "utf8");
+      const fileUrls = fileContent.split("\n").map((line) => line.trim()).filter(Boolean);
+      urls = [...urls, ...fileUrls];
+    }
+
+    if (urls.length === 0) throw new Error("batch-full-page-audit requires at least one URL");
+
+    const concurrencyValue = getFlagValue(args, "--concurrency");
+    return batchFullPageAudit(urls, {
+      concurrency: concurrencyValue ? parsePositiveInteger(concurrencyValue, "--concurrency") : 2
+    });
+  },
+  renderMarkdown: renderBatchFullPageAuditMarkdown,
+  writeOutput: writeBatchFullPageAuditOutput,
+  getOutputJson: (args) => hasFlag(args, "--json")
+});
+
+const handleDiagnose = createStructuredOutputCommandHandler({
+  commandLabel: "diagnose",
+  execute: async (args) => {
+    const input = args.find((value) => !value.startsWith("-"));
+    if (!input) throw new Error("diagnose requires a URL, file path, or directory");
+    return diagnose(input);
+  },
+  renderMarkdown: renderDiagnoseMarkdown,
+  writeOutput: writeDiagnoseOutput,
+  getOutputJson: (args) => hasFlag(args, "--json")
+});
+
+const handleCompare = createStructuredOutputCommandHandler({
+  commandLabel: "compare",
+  execute: async (args) => {
+    const nonFlags = args.filter((value) => !value.startsWith("-"));
+    if (nonFlags.length < 2) throw new Error("compare requires two URLs or file paths: <A> <B>");
+    return comparePages(nonFlags[0], nonFlags[1]);
+  },
+  renderMarkdown: renderCompareMarkdown,
+  writeOutput: writeCompareOutput,
+  getOutputJson: (args) => hasFlag(args, "--json")
+});
+
+const handleAutoFix = createStructuredOutputCommandHandler({
+  commandLabel: "auto-fix",
+  execute: async (args) => {
+    const input = args.find((value) => !value.startsWith("-"));
+    if (!input) throw new Error("auto-fix requires a URL or file path");
+    return generateAutoFix(input);
+  },
+  renderMarkdown: renderAutoFixMarkdown,
+  writeOutput: writeAutoFixOutput,
+  getOutputJson: (args) => hasFlag(args, "--json")
+});
+
+const handlePageTrend = createStructuredOutputCommandHandler({
+  commandLabel: "page trend",
+  execute: async (args) => {
+    const input = args.find((value) => !value.startsWith("-"));
+    if (!input) throw new Error("page-trend requires a URL or file path (same input used for full-page-audit)");
+    const lastValue = getFlagValue(args, "--last");
+    return buildPageTrend(input, {
+      dataDir: getFlagValue(args, "--data-dir") || undefined,
+      last: lastValue ? parsePositiveInteger(lastValue, "--last") : 0
+    });
+  },
+  renderMarkdown: renderPageTrendMarkdown,
+  writeOutput: writePageTrendOutput,
+  getOutputJson: (args) => hasFlag(args, "--json")
+});
+
+const handleFullPageAudit = createStructuredOutputCommandHandler({
+  commandLabel: "full page audit",
+  execute: async (args) => {
+    const input = args.find((value) => !value.startsWith("-"));
+    if (!input) throw new Error("full-page-audit requires a URL or file path");
+    const result = await fullPageAudit(input, { baseUrl: getFlagValue(args, "--base-url") });
+
+    if (hasFlag(args, "--save")) {
+      const saved = await savePageSnapshot(result, {
+        dataDir: getFlagValue(args, "--data-dir") || undefined
+      });
+      process.stderr.write(`快照已保存：${saved.path}\n`);
+    }
+
+    return result;
+  },
+  renderMarkdown: renderFullPageAuditMarkdown,
+  writeOutput: writeFullPageAuditOutput,
+  getOutputJson: (args) => hasFlag(args, "--json")
+});
+
+const handleFullAudit = createStructuredOutputCommandHandler({
+  commandLabel: "full audit",
+  execute: async (args) => {
+    const projectPath = args.find((value) => !value.startsWith("-"));
+    if (!projectPath) throw new Error("full-audit requires a project path");
+
+    const sampleUrlsRaw = getFlagValue(args, "--sample-urls");
+    const sampleUrls = sampleUrlsRaw ? sampleUrlsRaw.split(",").map((u) => u.trim()).filter(Boolean) : [];
+
+    const result = await fullAudit(projectPath, {
+      sampleUrls,
+      maxFileSize: getFlagValue(args, "--max-file-size")
+        ? parsePositiveInteger(getFlagValue(args, "--max-file-size"), "--max-file-size")
+        : undefined
+    });
+
+    if (hasFlag(args, "--save")) {
+      const dataDir = getFlagValue(args, "--data-dir") || undefined;
+      const saved = await saveSnapshot(result, { dataDir });
+      process.stderr.write(`快照已保存：${saved.path}\n`);
+    }
+
+    return result;
+  },
+  renderMarkdown: renderFullAuditMarkdown,
+  writeOutput: writeFullAuditOutput,
+  getOutputJson: (args) => hasFlag(args, "--json")
+});
+
 export const SITE_OPS_COMMAND_HANDLERS = {
   doctor: handleDoctor,
   "quick-start": handleQuickStart,
@@ -217,5 +818,38 @@ export const SITE_OPS_COMMAND_HANDLERS = {
   "init-llms": handleInitLlms,
   "init-schema": handleInitSchema,
   audit: handleAudit,
-  scan: handleScan
+  scan: handleScan,
+  "audit-diff": handleAuditDiff,
+  "batch-page-audit": handleBatchPageAudit,
+  trend: handleTrend,
+  benchmark: handleBenchmark,
+  "content-gap": handleContentGap,
+  ci: handleCi,
+  watch: handleWatch,
+  "init-hook": handleInitHook,
+  "citation-check": handleCitationCheck,
+  "citation-monitor": handleCitationMonitor,
+  crawlers: handleCrawlers,
+  citability: handleCitability,
+  "validate-llms": handleValidateLlms,
+  "validate-schema": handleValidateSchema,
+  eeat: handleEeat,
+  "platform-ready": handlePlatformReady,
+  readability: handleReadability,
+  "heading-structure": handleHeadingStructure,
+  "internal-links": handleInternalLinks,
+  "social-meta": handleSocialMeta,
+  "init-config": handleInitConfig,
+  "pdf-report": handlePdfReport,
+  "full-page-audit": handleFullPageAudit,
+  "full-audit": handleFullAudit,
+  sitemap: handleSitemap,
+  security: handleSecurity,
+  freshness: handleFreshness,
+  topics: handleTopics,
+  "batch-full-page-audit": handleBatchFullPageAudit,
+  "auto-fix": handleAutoFix,
+  "page-trend": handlePageTrend,
+  diagnose: handleDiagnose,
+  compare: handleCompare
 };