@cloudcreate/adsense-check 1.0.0

package/README.md

@@ -0,0 +1,77 @@
+# adsense-check
+
+Check if a website meets Google AdSense review requirements.
+
+## Install
+
+```bash
+npm install -g adsense-check
+```
+
+## Usage
+
+```bash
+# Basic check
+adsense-check https://example.com
+
+# JSON output (for programmatic use)
+adsense-check https://example.com --json
+
+# Crawl more internal pages (default: 5)
+adsense-check https://example.com --depth 10
+
+# Skip AI content analysis
+adsense-check https://example.com --skip-ai
+
+# Custom timeout (ms)
+adsense-check https://example.com --timeout 60000
+```
+
+## What it checks
+
+| Category | Checks |
+|----------|--------|
+| **Content Quality** | Page word count, content duplication |
+| **Required Pages** | About, Privacy Policy, Contact, Terms of Service |
+| **Site Structure** | H1 tags, robots.txt, sitemap.xml, internal links, dead links |
+| **Performance** | Load time, mobile viewport, responsive layout, font size, popups |
+| **Policy Compliance** | Blacklisted keywords (porn, gambling, piracy, etc.) |
+| **AI Analysis** | Content originality, quality, compliance (requires `AI_API_KEY`) |
+
+## Options
+
+```
+-v, --version        Show version
+-j, --json           Output as JSON
+-d, --depth <n>      Number of internal pages to crawl (default: 5)
+-s, --skip-ai        Skip AI content analysis
+-t, --timeout <ms>   Page load timeout (default: 30000)
+--api-key <key>      Anthropic API key (or set ANTHROPIC_API_KEY env var)
+```
+
+## AI Analysis
+
+For deeper content quality assessment, configure AI API in `.env`:
+
+```bash
+cp .env.example .env
+# Edit .env and set AI_API_KEY, AI_API_BASE, AI_MODEL
+```
+
+Compatible with any OpenAI-format API: DeepSeek, OpenAI, Moonshot, local LLM, etc.
+
+Or pass the key directly:
+
+```bash
+adsense-check https://example.com --api-key sk-xxx...
+```
+
+## Exit codes
+
+- `0` — No failures (ready or mostly ready)
+- `1` — Has failures (not ready)
+- `2` — Error (invalid URL, network failure, etc.)
+
+## License
+
+MIT

package/dist/chunk-V2YZ36NU.js

@@ -0,0 +1,1015 @@
+// src/browser.ts
+import { chromium } from "playwright";
+var BrowserManager = class {
+  browser = null;
+  async launch() {
+    if (!this.browser) {
+      this.browser = await chromium.launch({ headless: true });
+    }
+    return this.browser;
+  }
+  async newPage() {
+    const browser = await this.launch();
+    const context = await browser.newContext({
+      userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36",
+      viewport: { width: 1280, height: 720 }
+    });
+    return context.newPage();
+  }
+  async newMobilePage() {
+    const browser = await this.launch();
+    const context = await browser.newContext({
+      userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Mobile/15E148 Safari/604.1",
+      viewport: { width: 390, height: 844 },
+      isMobile: true,
+      hasTouch: true
+    });
+    return context.newPage();
+  }
+  async close() {
+    if (this.browser) {
+      await this.browser.close();
+      this.browser = null;
+    }
+  }
+};
+async function fetchPage(page, url, timeout = 3e4) {
+  const response = await page.goto(url, { waitUntil: "domcontentloaded", timeout });
+  const status = response?.status() ?? 0;
+  const content = await page.content();
+  const text = await page.evaluate(() => document.body?.innerText ?? "");
+  const links = await page.evaluate(
+    () => Array.from(document.querySelectorAll("a[href]")).map((a) => a.href).filter((href) => href.startsWith("http"))
+  );
+  const linkDetails = await page.evaluate(
+    () => Array.from(document.querySelectorAll("a[href]")).filter((a) => a.href.startsWith("http")).map((a) => ({
+      href: a.href,
+      text: a.innerText.trim()
+    }))
+  );
+  const navText = await page.evaluate(() => {
+    const nav = document.querySelector("nav");
+    return nav?.innerText ?? "";
+  });
+  const footerText = await page.evaluate(() => {
+    const footer = document.querySelector("footer");
+    return footer?.innerText ?? "";
+  });
+  const title = await page.title();
+  return { status, content, text, links, linkDetails, navText, footerText, title, url };
+}
+async function checkRobotsTxt(origin) {
+  try {
+    const resp = await fetch(`${origin}/robots.txt`);
+    return resp.ok;
+  } catch {
+    return false;
+  }
+}
+async function checkSitemap(origin) {
+  try {
+    const resp = await fetch(`${origin}/sitemap.xml`);
+    return resp.ok;
+  } catch {
+    return false;
+  }
+}
+async function fetchSitemapUrls(origin) {
+  try {
+    const resp = await fetch(`${origin}/sitemap.xml`);
+    if (!resp.ok) return [];
+    const text = await resp.text();
+    const matches = text.match(/<loc>(.*?)<\/loc>/g);
+    if (!matches) return [];
+    return matches.map((m) => m.replace(/<\/?loc>/g, "")).filter((u) => u.startsWith("http"));
+  } catch {
+    return [];
+  }
+}
+
+// src/checks/content.ts
+function extractMainContent(text, allPageTexts) {
+  const paragraphs = text.split(/\n\s*\n/).map((p) => p.trim()).filter(Boolean);
+  if (allPageTexts.length <= 1) return paragraphs.join("\n\n");
+  const otherTexts = allPageTexts.filter((t) => t !== text);
+  const threshold = Math.ceil(otherTexts.length * 0.6);
+  const contentParagraphs = paragraphs.filter((para) => {
+    if (para.length < 20) return true;
+    const normalized = para.replace(/\s+/g, " ").slice(0, 100);
+    const appearanceCount = otherTexts.filter(
+      (other) => other.replace(/\s+/g, " ").includes(normalized)
+    ).length;
+    return appearanceCount < threshold;
+  });
+  return contentParagraphs.join("\n\n");
+}
+function contentRatio(pageText, mainContent) {
+  const total = pageText.replace(/\s+/g, "").length;
+  if (total === 0) return 0;
+  return mainContent.replace(/\s+/g, "").length / total;
+}
+function detectFillerPatterns(text) {
+  const fillers = [
+    /(?:总之|综上所述|总的来说|简单来说|众所周知|毫无疑问|显而易见|毋庸置疑)/g,
+    /(?:in conclusion|as we all know|it goes without saying|needless to say|obviously)/gi,
+    /(.{10,30})\1{3,}/g,
+    // repeated phrases (e.g. "this is great this is great this is great")
+    /(?:点击这里|了解更多|查看更多|click here|read more|learn more|check out){2,}/gi
+  ];
+  const examples = [];
+  let count = 0;
+  for (const pattern of fillers) {
+    const matches = text.match(pattern);
+    if (matches) {
+      count += matches.length;
+      examples.push(...matches.slice(0, 2));
+    }
+  }
+  return { count, examples: examples.slice(0, 5) };
+}
+function detectTemplatePages(pages) {
+  if (pages.length < 3) return { isTemplate: false, similarity: 0, details: "" };
+  const structures = pages.map((p) => {
+    return p.text.replace(/[a-zA-Z一-鿿]+/g, "W").replace(/\d+/g, "N").replace(/\s+/g, " ").slice(0, 1e3);
+  });
+  let totalSimilarity = 0;
+  let pairs = 0;
+  for (let i = 0; i < structures.length; i++) {
+    for (let j = i + 1; j < structures.length; j++) {
+      const a = structures[i];
+      const b = structures[j];
+      const longer = a.length > b.length ? a : b;
+      const shorter = a.length > b.length ? b : a;
+      let common = 0;
+      for (let k = 0; k < shorter.length; k++) {
+        if (shorter[k] === longer[k]) common++;
+      }
+      totalSimilarity += common / longer.length;
+      pairs++;
+    }
+  }
+  const avgSimilarity = pairs > 0 ? totalSimilarity / pairs : 0;
+  return {
+    isTemplate: avgSimilarity > 0.6,
+    similarity: Math.round(avgSimilarity * 100),
+    details: avgSimilarity > 0.6 ? `\u9875\u9762\u7ED3\u6784\u76F8\u4F3C\u5EA6 ${Math.round(avgSimilarity * 100)}%\uFF0C\u7591\u4F3C\u6A21\u677F\u6279\u91CF\u751F\u6210` : ""
+  };
+}
+function checkFreshness(pages) {
+  const datePatterns = [
+    /(\d{4})[年/\-.](\d{1,2})[月/\-.](\d{1,2})/g,
+    /(January|February|March|April|May|June|July|August|September|October|November|December)\s+(\d{1,2}),?\s+(\d{4})/gi,
+    /(\d{1,2})\s+(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\w*\s+(\d{4})/gi
+  ];
+  const now = /* @__PURE__ */ new Date();
+  const sixMonthsAgo = new Date(now.getTime() - 180 * 24 * 60 * 60 * 1e3);
+  let latestDate = "";
+  let latestDateObj = /* @__PURE__ */ new Date(0);
+  const stalePages = [];
+  let hasAnyDate = false;
+  for (const page of pages) {
+    let pageHasRecentDate = false;
+    for (const pattern of datePatterns) {
+      const matches = [...page.text.matchAll(pattern)];
+      for (const match of matches) {
+        hasAnyDate = true;
+        try {
+          let dateStr;
+          if (pattern.source.includes("January|February")) {
+            dateStr = `${match[1]} ${match[2]} ${match[3]}`;
+          } else if (pattern.source.includes("Jan|Feb")) {
+            dateStr = `${match[1]} ${match[2]} ${match[3]}`;
+          } else {
+            dateStr = `${match[1]}-${match[2].padStart(2, "0")}-${match[3].padStart(2, "0")}`;
+          }
+          const d = new Date(dateStr);
+          if (!isNaN(d.getTime()) && d > /* @__PURE__ */ new Date("2020-01-01") && d <= now) {
+            if (d > latestDateObj) {
+              latestDateObj = d;
+              latestDate = dateStr;
+            }
+            if (d >= sixMonthsAgo) pageHasRecentDate = true;
+          }
+        } catch {
+        }
+      }
+    }
+    if (!pageHasRecentDate && page.text.length > 200) {
+      stalePages.push(page.url);
+    }
+  }
+  return {
+    hasRecentContent: hasAnyDate && latestDateObj >= sixMonthsAgo,
+    latestDate: latestDate || "\u672A\u68C0\u6D4B\u5230\u65E5\u671F",
+    stalePages
+  };
+}
+function checkContentQuality(pages, sitePageCount) {
+  const items = [];
+  const allTexts = pages.map((p) => p.text);
+  const lowRatioPages = [];
+  for (const page of pages) {
+    const mainContent = extractMainContent(page.text, allTexts);
+    const ratio = contentRatio(page.text, mainContent);
+    const contentChars = mainContent.replace(/\s+/g, "").length;
+    if (ratio < 0.3 && page.text.replace(/\s+/g, "").length > 200) {
+      lowRatioPages.push({ url: page.url, ratio: Math.round(ratio * 100), contentChars });
+    }
+  }
+  if (lowRatioPages.length > 0) {
+    const details = lowRatioPages.map((p) => `${new URL(p.url).pathname}: \u6B63\u6587\u5360\u6BD4 ${p.ratio}% (${p.contentChars} \u5B57)`).join("; ");
+    items.push({
+      name: "\u6709\u6548\u5185\u5BB9\u6BD4\u7387",
+      status: "fail",
+      message: `${lowRatioPages.length} \u4E2A\u9875\u9762\u6B63\u6587\u5360\u6BD4\u8FC7\u4F4E\uFF08<30%\uFF09\uFF0C\u5927\u91CF\u5185\u5BB9\u4E3A\u5BFC\u822A/\u9875\u811A\u7B49\u6A21\u677F\u5143\u7D20`,
+      detail: details
+    });
+  } else {
+    items.push({
+      name: "\u6709\u6548\u5185\u5BB9\u6BD4\u7387",
+      status: "pass",
+      message: "\u5404\u9875\u9762\u6B63\u6587\u5360\u6BD4\u6B63\u5E38\uFF0C\u6A21\u677F\u5143\u7D20\u5360\u6BD4\u5408\u7406"
+    });
+  }
+  let thinPages = 0;
+  for (const page of pages) {
+    const mainContent = extractMainContent(page.text, allTexts);
+    const contentChars = mainContent.replace(/\s+/g, "").length;
+    if (pages.indexOf(page) === 0) {
+      if (contentChars >= 500) {
+        items.push({
+          name: "\u9996\u9875\u5B9E\u8D28\u5185\u5BB9",
+          status: "pass",
+          message: `\u9996\u9875\u6B63\u6587\u5185\u5BB9\u5145\u8DB3 (${contentChars.toLocaleString()} \u5B57)`
+        });
+      } else {
+        items.push({
+          name: "\u9996\u9875\u5B9E\u8D28\u5185\u5BB9",
+          status: "fail",
+          message: `\u9996\u9875\u6B63\u6587\u5185\u5BB9\u4E0D\u8DB3 (${contentChars} \u5B57\uFF0C\u5EFA\u8BAE 500+ \u5B57)`
+        });
+      }
+    } else {
+      if (contentChars < 300) thinPages++;
+    }
+  }
+  if (pages.length > 1) {
+    if (thinPages > 0) {
+      items.push({
+        name: "\u5185\u9875\u5185\u5BB9\u6DF1\u5EA6",
+        status: thinPages > pages.length * 0.5 ? "fail" : "warn",
+        message: `${thinPages}/${pages.length - 1} \u4E2A\u5185\u9875\u6B63\u6587\u5185\u5BB9\u4E0D\u8DB3 (<300 \u5B57)`
+      });
+    } else {
+      items.push({
+        name: "\u5185\u9875\u5185\u5BB9\u6DF1\u5EA6",
+        status: "pass",
+        message: "\u6240\u6709\u5185\u9875\u6B63\u6587\u5185\u5BB9\u5145\u8DB3"
+      });
+    }
+  }
+  const templateResult = detectTemplatePages(pages);
+  if (pages.length >= 3) {
+    items.push({
+      name: "\u6A21\u677F\u5316\u68C0\u6D4B",
+      status: templateResult.isTemplate ? "fail" : "pass",
+      message: templateResult.isTemplate ? templateResult.details : `\u9875\u9762\u7ED3\u6784\u591A\u6837\u6027\u6B63\u5E38 (\u76F8\u4F3C\u5EA6 ${templateResult.similarity}%)`
+    });
+  }
+  let totalFiller = 0;
+  const fillerExamples = [];
+  for (const page of pages) {
+    const filler = detectFillerPatterns(page.text);
+    totalFiller += filler.count;
+    fillerExamples.push(...filler.examples);
+  }
+  if (totalFiller > pages.length * 3) {
+    items.push({
+      name: "\u51D1\u5B57\u6570\u68C0\u6D4B",
+      status: "warn",
+      message: `\u68C0\u6D4B\u5230 ${totalFiller} \u5904\u7591\u4F3C\u51D1\u5B57\u6570\u7684\u586B\u5145\u5185\u5BB9`,
+      detail: fillerExamples.slice(0, 3).join("; ")
+    });
+  } else {
+    items.push({
+      name: "\u51D1\u5B57\u6570\u68C0\u6D4B",
+      status: "pass",
+      message: "\u672A\u68C0\u6D4B\u5230\u660E\u663E\u7684\u586B\u5145/\u51D1\u5B57\u6570\u5185\u5BB9"
+    });
+  }
+  if (pages.length > 1) {
+    const chunkSize = 200;
+    let duplicatedChunks = 0;
+    const allChunks = /* @__PURE__ */ new Set();
+    for (const page of pages) {
+      const text = page.text.replace(/\s+/g, " ");
+      for (let i = 0; i < text.length - chunkSize; i += chunkSize) {
+        const chunk = text.slice(i, i + chunkSize);
+        if (allChunks.has(chunk)) {
+          duplicatedChunks++;
+        } else {
+          allChunks.add(chunk);
+        }
+      }
+    }
+    const totalChunks = pages.reduce((sum, p) => sum + Math.max(1, Math.floor(p.text.replace(/\s+/g, " ").length / chunkSize)), 0);
+    const dupRatio = totalChunks > 0 ? duplicatedChunks / totalChunks : 0;
+    if (dupRatio > 0.3) {
+      items.push({
+        name: "\u8DE8\u9875\u5185\u5BB9\u91CD\u590D",
+        status: "warn",
+        message: `${Math.round(dupRatio * 100)}% \u7684\u5185\u5BB9\u7247\u6BB5\u5728\u591A\u4E2A\u9875\u9762\u91CD\u590D\u51FA\u73B0`
+      });
+    } else {
+      items.push({
+        name: "\u8DE8\u9875\u5185\u5BB9\u91CD\u590D",
+        status: "pass",
+        message: `\u5404\u9875\u9762\u5185\u5BB9\u72EC\u7ACB\u6027\u826F\u597D (\u91CD\u590D\u7387 ${Math.round(dupRatio * 100)}%)`
+      });
+    }
+  }
+  const freshness = checkFreshness(pages);
+  if (freshness.hasRecentContent) {
+    items.push({
+      name: "\u5185\u5BB9\u65B0\u9C9C\u5EA6",
+      status: "pass",
+      message: `\u6700\u8FD1\u6709\u66F4\u65B0\u5185\u5BB9 (\u6700\u65B0: ${freshness.latestDate})`
+    });
+  } else if (freshness.latestDate !== "\u672A\u68C0\u6D4B\u5230\u65E5\u671F") {
+    items.push({
+      name: "\u5185\u5BB9\u65B0\u9C9C\u5EA6",
+      status: "warn",
+      message: `\u6700\u8FD1\u66F4\u65B0: ${freshness.latestDate}\uFF0C\u8D85\u8FC7 6 \u4E2A\u6708\u672A\u66F4\u65B0`,
+      detail: freshness.stalePages.length > 0 ? `\u65E0\u8FD1\u671F\u65E5\u671F\u7684\u9875\u9762: ${freshness.stalePages.map((u) => new URL(u).pathname).join(", ")}` : ""
+    });
+  } else {
+    items.push({
+      name: "\u5185\u5BB9\u65B0\u9C9C\u5EA6",
+      status: "warn",
+      message: "\u9875\u9762\u4E2D\u672A\u68C0\u6D4B\u5230\u65E5\u671F\u4FE1\u606F\uFF0C\u65E0\u6CD5\u5224\u65AD\u5185\u5BB9\u65F6\u6548\u6027"
+    });
+  }
+  if (sitePageCount !== void 0) {
+    if (sitePageCount < 10) {
+      items.push({
+        name: "\u7AD9\u70B9\u89C4\u6A21",
+        status: "warn",
+        message: `\u7AD9\u70B9\u4EC5 ${sitePageCount} \u4E2A\u9875\u9762\uFF08\u5EFA\u8BAE\u81F3\u5C11 10+ \u4E2A\u6709\u4EF7\u503C\u7684\u5185\u5BB9\u9875\uFF09`
+      });
+    } else if (sitePageCount < 30) {
+      items.push({
+        name: "\u7AD9\u70B9\u89C4\u6A21",
+        status: "pass",
+        message: `\u7AD9\u70B9\u6709 ${sitePageCount} \u4E2A\u9875\u9762`
+      });
+    } else {
+      items.push({
+        name: "\u7AD9\u70B9\u89C4\u6A21",
+        status: "pass",
+        message: `\u7AD9\u70B9\u89C4\u6A21\u826F\u597D (${sitePageCount} \u4E2A\u9875\u9762)`
+      });
+    }
+  }
+  return { name: "Content Quality", items };
+}
+
+// src/checks/pages.ts
+var REQUIRED_PAGES = [
+  {
+    name: "About",
+    required: true,
+    urlPatterns: [/\/about/i, /about[- _]?(us)?/i, /关于我们/, /公司介绍/, /关于/],
+    textPatterns: [/about/i, /关于我们/, /公司介绍/, /关于/],
+    titlePatterns: [/about/i, /关于/],
+    contentPatterns: [/about/i, /关于我们/, /公司简介/, /团队/, /our (story|team|mission)/i]
+  },
+  {
+    name: "Privacy Policy",
+    required: true,
+    urlPatterns: [/\/privacy/i, /privacy[- _]?policy/i, /隐私政策/, /隐私声明/, /隐私条款/],
+    textPatterns: [/privacy/i, /隐私/, /cookie policy/i],
+    titlePatterns: [/privacy/i, /隐私/],
+    contentPatterns: [/privacy/i, /隐私/, /personal data/i, /个人信息/, /data (collection|use|protect)/i]
+  },
+  {
+    name: "Contact",
+    required: true,
+    urlPatterns: [/\/contact/i, /contact/i, /联系我们/, /联系方式/, /联系/],
+    textPatterns: [/contact/i, /联系我们/, /联系方式/, /联系/, /support/i, /help/i],
+    titlePatterns: [/contact/i, /联系/, /support/],
+    contentPatterns: [/contact/i, /联系/, /email/i, /邮箱/, /电话/, /address/i]
+  },
+  {
+    name: "Terms of Service",
+    required: false,
+    urlPatterns: [/\/terms/i, /terms[- _]?(of[- _]?)?service/i, /terms[- _]?and[- _]?conditions/i, /服务条款/, /使用条款/],
+    textPatterns: [/terms/i, /服务条款/, /使用条款/, /legal/i],
+    titlePatterns: [/terms/i, /条款/, /service agreement/i],
+    contentPatterns: [/terms/i, /条款/, /agreement/i, /条款/, /governing law/i, /适用法律/]
+  }
+];
+async function checkRequiredPages(input) {
+  const items = [];
+  const { allLinks, navText, footerText, sitemapUrls } = input;
+  const linkTexts = allLinks.map((l) => l.text).join("\n");
+  const linkHrefs = allLinks.map((l) => l.href).join("\n");
+  const allText = [linkTexts, linkHrefs, navText, footerText, sitemapUrls.join("\n")].join("\n");
+  for (const page of REQUIRED_PAGES) {
+    let found = false;
+    let foundUrl = "";
+    for (const pattern of page.urlPatterns) {
+      const linkMatch = allLinks.find((l) => pattern.test(l.href));
+      if (linkMatch) {
+        found = true;
+        foundUrl = linkMatch.href;
+        break;
+      }
+      const sitemapMatch = sitemapUrls.find((u) => pattern.test(u));
+      if (sitemapMatch) {
+        found = true;
+        foundUrl = sitemapMatch;
+        break;
+      }
+    }
+    if (!found) {
+      for (const pattern of page.textPatterns) {
+        const linkMatch = allLinks.find((l) => pattern.test(l.text));
+        if (linkMatch) {
+          found = true;
+          foundUrl = linkMatch.href;
+          break;
+        }
+      }
+    }
+    if (!found) {
+      for (const pattern of page.titlePatterns) {
+        const sitemapMatch = sitemapUrls.find((u) => {
+          const path = new URL(u).pathname;
+          return pattern.test(path);
+        });
+        if (sitemapMatch) {
+          found = true;
+          foundUrl = sitemapMatch;
+          break;
+        }
+      }
+    }
+    if (found) {
+      items.push({
+        name: `${page.name} \u9875\u9762`,
+        status: "pass",
+        message: `\u627E\u5230 ${page.name} \u9875\u9762${foundUrl ? ` (${new URL(foundUrl).pathname})` : ""}`
+      });
+    } else if (page.required) {
+      items.push({
+        name: `${page.name} \u9875\u9762`,
+        status: "fail",
+        message: `\u672A\u627E\u5230 ${page.name} \u9875\u9762\uFF08\u5FC5\u9700\uFF09`
+      });
+    } else {
+      items.push({
+        name: `${page.name} \u9875\u9762`,
+        status: "warn",
+        message: `\u672A\u627E\u5230 ${page.name} \u9875\u9762\uFF08\u5EFA\u8BAE\u6DFB\u52A0\uFF09`
+      });
+    }
+  }
+  return { name: "Required Pages", items };
+}
+
+// src/checks/structure.ts
+async function checkSiteStructure(origin, links, h1Count, deadLinks = []) {
+  const items = [];
+  if (h1Count === 1) {
+    items.push({
+      name: "H1 \u6807\u7B7E",
+      status: "pass",
+      message: "\u9875\u9762\u6709\u4E14\u4EC5\u6709\u4E00\u4E2A H1 \u6807\u7B7E"
+    });
+  } else if (h1Count === 0) {
+    items.push({
+      name: "H1 \u6807\u7B7E",
+      status: "warn",
+      message: "\u9875\u9762\u7F3A\u5C11 H1 \u6807\u7B7E"
+    });
+  } else {
+    items.push({
+      name: "H1 \u6807\u7B7E",
+      status: "warn",
+      message: `\u9875\u9762\u6709 ${h1Count} \u4E2A H1 \u6807\u7B7E\uFF08\u5EFA\u8BAE\u4FDD\u7559 1 \u4E2A\uFF09`
+    });
+  }
+  const hasRobots = await checkRobotsTxt(origin);
+  items.push({
+    name: "robots.txt",
+    status: hasRobots ? "pass" : "warn",
+    message: hasRobots ? "robots.txt \u5B58\u5728" : "\u672A\u627E\u5230 robots.txt\uFF08\u5EFA\u8BAE\u6DFB\u52A0\uFF09"
+  });
+  const hasSitemap = await checkSitemap(origin);
+  items.push({
+    name: "sitemap.xml",
+    status: hasSitemap ? "pass" : "warn",
+    message: hasSitemap ? "sitemap.xml \u5B58\u5728" : "\u672A\u627E\u5230 sitemap.xml\uFF08\u5EFA\u8BAE\u6DFB\u52A0\uFF09"
+  });
+  const internalLinks = links.filter((l) => {
+    try {
+      return new URL(l).origin === origin;
+    } catch {
+      return false;
+    }
+  });
+  if (internalLinks.length >= 5) {
+    items.push({
+      name: "\u5185\u90E8\u94FE\u63A5",
+      status: "pass",
+      message: `\u9996\u9875\u6709 ${internalLinks.length} \u4E2A\u5185\u90E8\u94FE\u63A5`
+    });
+  } else {
+    items.push({
+      name: "\u5185\u90E8\u94FE\u63A5",
+      status: "warn",
+      message: `\u9996\u9875\u4EC5 ${internalLinks.length} \u4E2A\u5185\u90E8\u94FE\u63A5\uFF08\u5EFA\u8BAE\u589E\u52A0\u5BFC\u822A\u94FE\u63A5\uFF09`
+    });
+  }
+  if (deadLinks.length > 0) {
+    items.push({
+      name: "\u6B7B\u94FE\u68C0\u6D4B",
+      status: "fail",
+      message: `\u68C0\u6D4B\u5230 ${deadLinks.length} \u4E2A\u6B7B\u94FE`,
+      detail: deadLinks.join(", ")
+    });
+  } else {
+    items.push({
+      name: "\u6B7B\u94FE\u68C0\u6D4B",
+      status: "pass",
+      message: "\u672A\u68C0\u6D4B\u5230\u6B7B\u94FE"
+    });
+  }
+  return { name: "Site Structure", items };
+}
+
+// src/checks/performance.ts
+async function checkPerformance(page, url, browser) {
+  const items = [];
+  const startTime = Date.now();
+  try {
+    await page.goto(url, { waitUntil: "domcontentloaded", timeout: 3e4 });
+    const loadTime = Date.now() - startTime;
+    if (loadTime < 3e3) {
+      items.push({
+        name: "\u9875\u9762\u52A0\u8F7D\u901F\u5EA6",
+        status: "pass",
+        message: `\u52A0\u8F7D\u65F6\u95F4 ${(loadTime / 1e3).toFixed(1)}s`
+      });
+    } else if (loadTime < 6e3) {
+      items.push({
+        name: "\u9875\u9762\u52A0\u8F7D\u901F\u5EA6",
+        status: "warn",
+        message: `\u52A0\u8F7D\u65F6\u95F4 ${(loadTime / 1e3).toFixed(1)}s\uFF08\u5EFA\u8BAE\u4F18\u5316\u5230 3s \u4EE5\u5185\uFF09`
+      });
+    } else {
+      items.push({
+        name: "\u9875\u9762\u52A0\u8F7D\u901F\u5EA6",
+        status: "fail",
+        message: `\u52A0\u8F7D\u65F6\u95F4 ${(loadTime / 1e3).toFixed(1)}s\uFF08\u8FC7\u6162\uFF0C\u4E25\u91CD\u5F71\u54CD\u7528\u6237\u4F53\u9A8C\uFF09`
+      });
+    }
+  } catch {
+    items.push({
+      name: "\u9875\u9762\u52A0\u8F7D\u901F\u5EA6",
+      status: "fail",
+      message: "\u9875\u9762\u52A0\u8F7D\u8D85\u65F6\uFF0830s\uFF09"
+    });
+  }
+  const hasViewport = await page.evaluate(() => {
+    const meta = document.querySelector('meta[name="viewport"]');
+    return !!meta;
+  });
+  items.push({
+    name: "viewport \u6807\u7B7E",
+    status: hasViewport ? "pass" : "warn",
+    message: hasViewport ? "\u5B58\u5728 viewport meta \u6807\u7B7E" : "\u7F3A\u5C11 viewport meta \u6807\u7B7E"
+  });
+  try {
+    const mobileContext = await browser.newContext({
+      userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Mobile/15E148 Safari/604.1",
+      viewport: { width: 390, height: 844 },
+      isMobile: true,
+      hasTouch: true
+    });
+    const mobilePage = await mobileContext.newPage();
+    await mobilePage.goto(url, { waitUntil: "domcontentloaded", timeout: 3e4 });
+    const mobileCheck = await mobilePage.evaluate(() => {
+      const body = document.body;
+      const hasHorizontalScroll = body.scrollWidth > window.innerWidth;
+      const textTooSmall = Array.from(document.querySelectorAll("p, span, a, li")).some((el) => {
+        const fontSize = parseFloat(window.getComputedStyle(el).fontSize);
+        return fontSize > 0 && fontSize < 12;
+      });
+      return { hasHorizontalScroll, textTooSmall };
+    });
+    if (mobileCheck.hasHorizontalScroll) {
+      items.push({
+        name: "\u79FB\u52A8\u7AEF\u6A2A\u5411\u6EA2\u51FA",
+        status: "warn",
+        message: "\u79FB\u52A8\u7AEF\u9875\u9762\u5B58\u5728\u6A2A\u5411\u6EDA\u52A8\uFF08body \u5BBD\u5EA6\u8D85\u51FA\u89C6\u53E3\uFF09"
+      });
+    } else {
+      items.push({
+        name: "\u79FB\u52A8\u7AEF\u6A2A\u5411\u6EA2\u51FA",
+        status: "pass",
+        message: "\u79FB\u52A8\u7AEF\u9875\u9762\u65E0\u6A2A\u5411\u6EA2\u51FA"
+      });
+    }
+    if (mobileCheck.textTooSmall) {
+      items.push({
+        name: "\u79FB\u52A8\u7AEF\u5B57\u4F53\u5927\u5C0F",
+        status: "warn",
+        message: "\u90E8\u5206\u6587\u5B57\u5B57\u53F7\u5C0F\u4E8E 12px\uFF0C\u79FB\u52A8\u7AEF\u9605\u8BFB\u56F0\u96BE"
+      });
+    } else {
+      items.push({
+        name: "\u79FB\u52A8\u7AEF\u5B57\u4F53\u5927\u5C0F",
+        status: "pass",
+        message: "\u79FB\u52A8\u7AEF\u5B57\u53F7\u9002\u4E2D"
+      });
+    }
+    await mobileContext.close();
+  } catch {
+    items.push({
+      name: "\u79FB\u52A8\u7AEF\u6D4B\u8BD5",
+      status: "skip",
+      message: "\u79FB\u52A8\u7AEF\u6D4B\u8BD5\u5931\u8D25\uFF08\u9875\u9762\u52A0\u8F7D\u5F02\u5E38\uFF09"
+    });
+  }
+  const hasOverlay = await page.evaluate(() => {
+    const overlays = document.querySelectorAll(
+      '[class*="modal"], [class*="popup"], [class*="overlay"], [id*="modal"], [id*="popup"]'
+    );
+    const visible = Array.from(overlays).filter((el) => {
+      const style = window.getComputedStyle(el);
+      return style.display !== "none" && style.visibility !== "hidden" && style.opacity !== "0";
+    });
+    return visible.length;
+  });
+  if (hasOverlay > 0) {
+    items.push({
+      name: "\u5F39\u7A97\u68C0\u6D4B",
+      status: "warn",
+      message: `\u68C0\u6D4B\u5230 ${hasOverlay} \u4E2A\u53EF\u80FD\u7684\u5F39\u7A97/\u906E\u7F69\u5C42\uFF08\u8FC7\u591A\u5F39\u7A97\u4F1A\u5F71\u54CD\u5BA1\u6838\uFF09`
+    });
+  } else {
+    items.push({
+      name: "\u5F39\u7A97\u68C0\u6D4B",
+      status: "pass",
+      message: "\u672A\u68C0\u6D4B\u5230\u660E\u663E\u7684\u5F39\u7A97/\u906E\u7F69\u5C42"
+    });
+  }
+  return { name: "Performance", items };
+}
+
+// src/checks/policy.ts
+var BLACKLIST_PATTERNS = [
+  /\b(porn|xxx|nude|naked|sex\s*tube)\b/i,
+  /\b(gamble|casino|betting|lottery)\b/i,
+  /\b(hack|crack|pirate|torrent|warez)\b/i,
+  /\b(drug|marijuana|cocaine|heroin)\b/i,
+  /色情|赌博|毒品|暴力|盗版/
+];
+function checkPolicyCompliance(pages) {
+  const items = [];
+  const violations = [];
+  for (const page of pages) {
+    for (const pattern of BLACKLIST_PATTERNS) {
+      const match = page.text.match(pattern);
+      if (match) {
+        violations.push({ url: page.url, match: match[0] });
+      }
+    }
+  }
+  if (violations.length > 0) {
+    const details = violations.map((v) => `${v.url}: "${v.match}"`).join("; ");
+    items.push({
+      name: "\u8FDD\u89C4\u5173\u952E\u8BCD",
+      status: "fail",
+      message: `\u68C0\u6D4B\u5230 ${violations.length} \u4E2A\u53EF\u7591\u5173\u952E\u8BCD`,
+      detail: details
+    });
+  } else {
+    items.push({
+      name: "\u8FDD\u89C4\u5173\u952E\u8BCD",
+      status: "pass",
+      message: "\u672A\u68C0\u6D4B\u5230\u660E\u663E\u7684\u8FDD\u89C4\u5173\u952E\u8BCD"
+    });
+  }
+  const hasAdKeywords = pages.some(
+    (p) => /ad[-_]?slot|google[-_]?ad|adsbygoogle|广告位/i.test(p.text)
+  );
+  if (hasAdKeywords) {
+    items.push({
+      name: "\u5E7F\u544A\u4EE3\u7801",
+      status: "warn",
+      message: "\u9875\u9762\u5DF2\u5B58\u5728\u5E7F\u544A\u4EE3\u7801\u5360\u4F4D\uFF0C\u786E\u8BA4\u4E0D\u5F71\u54CD\u5BA1\u6838"
+    });
+  }
+  return { name: "Policy Compliance", items };
+}
+
+// src/ai/analyzer.ts
+function getApiEndpoint() {
+  const base = process.env.AI_API_BASE || "https://api.deepseek.com";
+  return `${base.replace(/\/$/, "")}/chat/completions`;
+}
+function getApiKey() {
+  return process.env.AI_API_KEY;
+}
+function getModel() {
+  return process.env.AI_MODEL || "deepseek-chat";
+}
+async function callAI(prompt, maxTokens = 4096) {
+  const response = await fetch(getApiEndpoint(), {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${getApiKey()}`
+    },
+    body: JSON.stringify({
+      model: getModel(),
+      max_tokens: maxTokens,
+      messages: [{ role: "user", content: prompt }]
+    })
+  });
+  if (!response.ok) {
+    throw new Error(`AI API error: ${response.status} ${response.statusText}`);
+  }
+  const data = await response.json();
+  return data.choices?.[0]?.message?.content ?? "";
+}
+function extractJson(text) {
+  const jsonMatch = text.match(/\{[\s\S]*\}/);
+  if (jsonMatch) {
+    return JSON.parse(jsonMatch[0]);
+  }
+  throw new Error("No JSON found in response");
+}
+async function analyzeWithAI(pages, apiKey) {
+  const key = apiKey || getApiKey();
+  const empty = {
+    contentQuality: { status: "skip", detail: "\u672A\u914D\u7F6E AI_API_KEY\uFF0C\u8DF3\u8FC7 AI \u5206\u6790" },
+    originality: { status: "skip", detail: "N/A" },
+    compliance: { status: "skip", detail: "N/A" },
+    suggestions: [],
+    pageAnalyses: []
+  };
+  if (!key) return empty;
+  const sampled = pages.slice(0, 8);
+  const pageContents = sampled.map((p, i) => `=== \u9875\u9762 ${i + 1}: ${p.url} ===
+${p.text.slice(0, 1500)}`).join("\n\n");
+  const prompt = `\u4F60\u662F\u4E00\u4E2A Google AdSense \u5BA1\u6838\u4E13\u5BB6\uFF0C\u4E13\u95E8\u5224\u65AD\u7F51\u7AD9\u662F\u5426\u5B58\u5728 "low value content" \u95EE\u9898\u3002
+\u5F53\u524D\u65E5\u671F\uFF1A${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}
+
+AdSense \u6700\u5E38\u89C1\u7684\u62D2\u7EDD\u7406\u7531\u662F "low value content"\uFF08\u4F4E\u4EF7\u503C\u5185\u5BB9\uFF09\uFF0C\u8868\u73B0\u5305\u62EC\uFF1A
+- \u9875\u9762\u5185\u5BB9\u592A\u8584\uFF0C\u7F3A\u4E4F\u5B9E\u8D28\u6027\u4FE1\u606F
+- \u5185\u5BB9\u50CF\u662F\u673A\u5668\u6279\u91CF\u751F\u6210\u6216\u4ECE\u5176\u4ED6\u7F51\u7AD9\u91C7\u96C6\u7684
+- \u7F51\u7AD9\u6CA1\u6709\u4E3A\u7528\u6237\u63D0\u4F9B\u72EC\u7279\u7684\u4EF7\u503C
+- \u5185\u5BB9\u7A7A\u6D1E\uFF0C\u5927\u91CF\u51D1\u5B57\u6570\u3001\u91CD\u590D\u8868\u8FF0
+- \u591A\u4E2A\u9875\u9762\u5185\u5BB9\u9AD8\u5EA6\u96F7\u540C\uFF0C\u53EA\u662F\u6362\u4E86\u5173\u952E\u8BCD
+
+\u8BF7\u5206\u6790\u4EE5\u4E0B ${sampled.length} \u4E2A\u9875\u9762\uFF0C\u8FD4\u56DE JSON\uFF1A
+
+{
+  "overall": {
+    "contentQuality": { "status": "pass|warn|fail", "detail": "\u6574\u4F53\u5185\u5BB9\u4EF7\u503C\u8BC4\u4F30..." },
+    "originality": { "status": "pass|warn|fail", "detail": "\u6574\u4F53\u539F\u521B\u6027\u8BC4\u4F30..." },
+    "compliance": { "status": "pass|warn|fail", "detail": "\u6574\u4F53\u5408\u89C4\u6027\u8BC4\u4F30..." },
+    "suggestions": ["\u6539\u8FDB\u5EFA\u8BAE1", "\u6539\u8FDB\u5EFA\u8BAE2"]
+  },
+  "pages": [
+    {
+      "url": "\u9875\u9762URL",
+      "status": "pass|warn|fail",
+      "assessment": "\u8BE5\u9875\u9762\u7684\u5177\u4F53\u8BC4\u4F30\uFF0C\u8BF4\u660E\u5185\u5BB9\u4EF7\u503C\u3001\u95EE\u9898\u6240\u5728",
+      "suggestions": ["\u9488\u5BF9\u8BE5\u9875\u9762\u7684\u5177\u4F53\u6539\u8FDB\u5EFA\u8BAE"]
+    }
+  ]
+}
+
+\u9875\u9762\u5185\u5BB9\uFF1A
+
+${pageContents}`;
+  try {
+    const text = await callAI(prompt, 4096);
+    const result = extractJson(text);
+    return {
+      contentQuality: result.overall?.contentQuality ?? { status: "warn", detail: "\u89E3\u6790\u5F02\u5E38" },
+      originality: result.overall?.originality ?? { status: "warn", detail: "\u89E3\u6790\u5F02\u5E38" },
+      compliance: result.overall?.compliance ?? { status: "warn", detail: "\u89E3\u6790\u5F02\u5E38" },
+      suggestions: result.overall?.suggestions ?? [],
+      pageAnalyses: (result.pages ?? []).map((p) => ({
+        url: p.url,
+        status: p.status ?? "warn",
+        assessment: p.assessment ?? "",
+        suggestions: p.suggestions ?? []
+      }))
+    };
+  } catch (err) {
+    return {
+      ...empty,
+      contentQuality: { status: "warn", detail: `AI \u5206\u6790\u5931\u8D25: ${err instanceof Error ? err.message : String(err)}` }
+    };
+  }
+}
+
+// src/checker.ts
+function extractMainContent2(text, allPageTexts) {
+  const paragraphs = text.split(/\n\s*\n/).map((p) => p.trim()).filter(Boolean);
+  if (allPageTexts.length <= 1) return paragraphs.join("\n\n");
+  const otherTexts = allPageTexts.filter((t) => t !== text);
+  const threshold = Math.ceil(otherTexts.length * 0.6);
+  return paragraphs.filter((para) => {
+    if (para.length < 20) return true;
+    const normalized = para.replace(/\s+/g, " ").slice(0, 100);
+    const count = otherTexts.filter((o) => o.replace(/\s+/g, " ").includes(normalized)).length;
+    return count < threshold;
+  }).join("\n\n");
+}
+function buildPageDetails(pages, aiAnalyses) {
+  const allTexts = pages.map((p) => p.text);
+  const aiMap = new Map(aiAnalyses.map((a) => [a.url, a]));
+  return pages.map((page) => {
+    const totalChars = page.text.replace(/\s+/g, "").length;
+    const mainContent = extractMainContent2(page.text, allTexts);
+    const contentChars = mainContent.replace(/\s+/g, "").length;
+    const contentRatio2 = totalChars > 0 ? Math.round(contentChars / totalChars * 100) : 0;
+    const issues = [];
+    let contentStatus = "pass";
+    if (contentRatio2 < 30 && totalChars > 200) {
+      issues.push(`\u6B63\u6587\u5360\u6BD4\u4EC5 ${contentRatio2}%\uFF0C\u5927\u91CF\u6A21\u677F\u5143\u7D20`);
+      contentStatus = "fail";
+    }
+    if (contentChars < 300) {
+      issues.push(`\u6B63\u6587\u5185\u5BB9\u4E0D\u8DB3 (${contentChars} \u5B57)`);
+      contentStatus = contentStatus === "fail" ? "fail" : "warn";
+    }
+    const ai = aiMap.get(page.url);
+    const detail = {
+      url: page.url,
+      title: page.title,
+      totalChars,
+      contentChars,
+      contentRatio: contentRatio2,
+      contentStatus,
+      issues
+    };
+    if (ai) {
+      detail.ai = {
+        status: ai.status,
+        assessment: ai.assessment,
+        suggestions: ai.suggestions
+      };
+    }
+    return detail;
+  });
+}
+async function check(options) {
+  const { url, depth = 10, skipAi = false, timeout = 3e4, apiKey } = options;
+  const origin = new URL(url).origin;
+  const browser = new BrowserManager();
+  try {
+    const homepage = await browser.newPage();
+    const homeData = await fetchPage(homepage, url, timeout);
+    const h1Count = await homepage.evaluate(
+      () => document.querySelectorAll("h1").length
+    );
+    const sitemapUrls = await fetchSitemapUrls(origin);
+    const pages = [
+      { url: homeData.url, text: homeData.text, title: homeData.title }
+    ];
+    const internalLinks = homeData.links.filter((l) => {
+      try {
+        return new URL(l).origin === origin;
+      } catch {
+        return false;
+      }
+    });
+    const sitemapInternal = sitemapUrls.filter((u) => {
+      try {
+        return new URL(u).origin === origin;
+      } catch {
+        return false;
+      }
+    });
+    const allInternal = [.../* @__PURE__ */ new Set([...internalLinks, ...sitemapInternal])];
+    const uniqueLinks = allInternal.slice(0, depth);
+    const deadLinks = [];
+    for (const link of uniqueLinks) {
+      if (link === url) continue;
+      try {
+        const page = await browser.newPage();
+        const resp = await page.goto(link, { waitUntil: "domcontentloaded", timeout });
+        const status = resp?.status() ?? 0;
+        if (status >= 400) {
+          deadLinks.push(`${link} (${status})`);
+        } else {
+          const data = await fetchPage(page, link, timeout);
+          pages.push({ url: link, text: data.text, title: data.title });
+        }
+        await page.close();
+      } catch {
+        deadLinks.push(`${link} (timeout/error)`);
+      }
+    }
+    const seen = /* @__PURE__ */ new Set();
+    const uniquePages = pages.filter((p) => {
+      const normalized = p.url.replace(/\/+$/, "").split("#")[0];
+      if (seen.has(normalized)) return false;
+      seen.add(normalized);
+      return true;
+    });
+    const categories = [];
+    categories.push(checkContentQuality(uniquePages, allInternal.length));
+    categories.push(await checkRequiredPages({
+      allLinks: homeData.linkDetails,
+      navText: homeData.navText,
+      footerText: homeData.footerText,
+      sitemapUrls
+    }));
+    categories.push(await checkSiteStructure(origin, homeData.links, h1Count, deadLinks));
+    const playBrowser = await browser.launch();
+    const perfPage = await browser.newPage();
+    categories.push(await checkPerformance(perfPage, url, playBrowser));
+    await perfPage.close();
+    categories.push(checkPolicyCompliance(uniquePages));
+    let pageAnalyses = [];
+    if (!skipAi) {
+      try {
+        const aiResult = await analyzeWithAI(uniquePages, apiKey);
+        pageAnalyses = aiResult.pageAnalyses;
+        const aiCategory = {
+          name: "AI Content Analysis",
+          items: [
+            {
+              name: "\u5185\u5BB9\u8D28\u91CF\u8BC4\u4F30",
+              status: aiResult.contentQuality.status,
+              message: aiResult.contentQuality.detail.slice(0, 200)
+            },
+            {
+              name: "\u539F\u521B\u6027\u8BC4\u4F30",
+              status: aiResult.originality.status,
+              message: aiResult.originality.detail.slice(0, 200)
+            },
+            {
+              name: "\u5408\u89C4\u6027\u8BC4\u4F30",
+              status: aiResult.compliance.status,
+              message: aiResult.compliance.detail.slice(0, 200)
+            }
+          ]
+        };
+        if (aiResult.suggestions.length > 0) {
+          aiCategory.items.push({
+            name: "AI \u5EFA\u8BAE",
+            status: "warn",
+            message: `${aiResult.suggestions.length} \u6761\u6539\u8FDB\u5EFA\u8BAE`,
+            detail: aiResult.suggestions.join("; ")
+          });
+        }
+        categories.push(aiCategory);
+      } catch (err) {
+        categories.push({
+          name: "AI Content Analysis",
+          items: [
+            {
+              name: "AI \u5206\u6790",
+              status: "skip",
+              message: `AI \u5206\u6790\u5931\u8D25: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ]
+        });
+      }
+    }
+    const pageDetails = buildPageDetails(uniquePages, pageAnalyses);
+    const allItems = categories.flatMap((c) => c.items);
+    const passed = allItems.filter((i) => i.status === "pass").length;
+    const warned = allItems.filter((i) => i.status === "warn").length;
+    const failed = allItems.filter((i) => i.status === "fail").length;
+    const skipped = allItems.filter((i) => i.status === "skip").length;
+    return {
+      url,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      categories,
+      score: passed,
+      totalChecks: allItems.length,
+      passed,
+      warned,
+      failed,
+      skipped,
+      pages: pageDetails
+    };
+  } finally {
+    await browser.close();
+  }
+}
+
+export {
+  check
+};

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,179 @@
+#!/usr/bin/env node
+import {
+  check
+} from "./chunk-V2YZ36NU.js";
+
+// src/cli.ts
+import "dotenv/config";
+import { Command } from "commander";
+import chalk2 from "chalk";
+import { mkdirSync, writeFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+
+// src/reporter.ts
+import chalk from "chalk";
+import figures from "figures";
+var STATUS_ICONS = {
+  pass: chalk.green(figures.tick),
+  warn: chalk.yellow(figures.warning),
+  fail: chalk.red(figures.cross),
+  skip: chalk.gray("-")
+};
+var STATUS_LABELS = {
+  pass: chalk.green("PASS"),
+  warn: chalk.yellow("WARN"),
+  fail: chalk.red("FAIL"),
+  skip: chalk.gray("SKIP")
+};
+function getStatusSummary(report) {
+  if (report.failed > 0) {
+    return chalk.red.bold(`NOT READY \u2014 ${report.failed} \u9879\u5931\u8D25\u9700\u8981\u4FEE\u590D`);
+  }
+  if (report.warned > 0) {
+    return chalk.yellow.bold(`MOSTLY READY \u2014 \u4FEE\u590D ${report.warned} \u9879\u8B66\u544A\u540E\u53EF\u63D0\u4EA4\u5BA1\u6838`);
+  }
+  return chalk.green.bold("READY \u2014 \u53EF\u4EE5\u63D0\u4EA4 AdSense \u5BA1\u6838");
+}
+function renderTerminalReport(report) {
+  const lines = [];
+  lines.push("");
+  lines.push(chalk.bold.cyan("  AdSense Checklist Report"));
+  lines.push(chalk.gray(`  Website: ${report.url}`));
+  lines.push(chalk.gray(`  Checked: ${report.timestamp}`));
+  lines.push("");
+  for (const category of report.categories) {
+    lines.push(chalk.bold(`  ${category.name}`));
+    for (const item of category.items) {
+      const icon = STATUS_ICONS[item.status];
+      const label = STATUS_LABELS[item.status];
+      lines.push(`    ${icon} [${label}] ${item.message}`);
+      if (item.detail) {
+        lines.push(chalk.gray(`         ${item.detail}`));
+      }
+    }
+    lines.push("");
+  }
+  if (report.pages.length > 0) {
+    lines.push(chalk.bold("  Page Details"));
+    lines.push(chalk.gray(`  (${report.pages.length} pages analyzed)`));
+    lines.push("");
+    const problemPages = report.pages.filter(
+      (p) => p.contentStatus !== "pass" || p.issues.length > 0 || p.ai && p.ai.status !== "pass"
+    );
+    const okPages = report.pages.filter(
+      (p) => p.contentStatus === "pass" && p.issues.length === 0 && (!p.ai || p.ai.status === "pass")
+    );
+    for (const page of problemPages) {
+      renderPageDetail(lines, page, true);
+    }
+    if (okPages.length > 0) {
+      lines.push(chalk.gray(`    + ${okPages.length} \u4E2A\u9875\u9762\u65E0\u95EE\u9898`));
+      lines.push("");
+    }
+  }
+  lines.push(chalk.bold("  Score: ") + `${report.score}/${report.totalChecks}`);
+  lines.push(`  Status: ${getStatusSummary(report)}`);
+  lines.push("");
+  return lines.join("\n");
+}
+function renderPageDetail(lines, page, verbose) {
+  const path = safePath(page.url);
+  const statusIcon = STATUS_ICONS[page.contentStatus];
+  const ratioColor = page.contentRatio >= 50 ? chalk.green : page.contentRatio >= 30 ? chalk.yellow : chalk.red;
+  lines.push(`    ${statusIcon} ${chalk.bold(path)}`);
+  lines.push(chalk.gray(`       ${page.title}`));
+  lines.push(`       \u6B63\u6587 ${ratioColor(page.contentRatio + "%")} (${page.contentChars}/${page.totalChars} \u5B57)`);
+  for (const issue of page.issues) {
+    lines.push(chalk.yellow(`       ! ${issue}`));
+  }
+  if (page.ai) {
+    const aiIcon = STATUS_ICONS[page.ai.status];
+    lines.push(`       ${aiIcon} AI: ${truncate(page.ai.assessment, 80)}`);
+    for (const s of page.ai.suggestions.slice(0, 2)) {
+      lines.push(chalk.gray(`         \u2192 ${truncate(s, 70)}`));
+    }
+  }
+  lines.push("");
+}
+function safePath(url) {
+  try {
+    return new URL(url).pathname;
+  } catch {
+    return url;
+  }
+}
+function truncate(s, max) {
+  return s.length > max ? s.slice(0, max - 1) + "..." : s;
+}
+function renderJsonReport(report) {
+  return JSON.stringify(report, null, 2);
+}
+
+// src/cli.ts
+var __dirname = dirname(fileURLToPath(import.meta.url));
+function formatTimestamp() {
+  const d = /* @__PURE__ */ new Date();
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}-${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`;
+}
+function getDomain(url) {
+  try {
+    return new URL(url).hostname;
+  } catch {
+    return "unknown";
+  }
+}
+var program = new Command();
+program.name("adsense-check").description("Check if a website meets Google AdSense review requirements").version("1.0.0").argument("<url>", "Website URL to check").option("-j, --json", "Output as JSON to stdout").option("-d, --depth <number>", "Number of internal pages to crawl", "10").option("-s, --skip-ai", "Skip AI content analysis", false).option("-t, --timeout <ms>", "Page load timeout in milliseconds", "30000").option("--api-key <key>", "AI API key (or set AI_API_KEY in .env)").option("-o, --output <dir>", "Report output directory", "tmp").option("--no-save", "Skip auto-saving report files").action(async (url, opts) => {
+  try {
+    new URL(url);
+  } catch {
+    console.error(chalk2.red(`Error: Invalid URL "${url}"`));
+    process.exit(1);
+  }
+  if (!url.startsWith("http")) {
+    url = "https://" + url;
+  }
+  const spinner = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+  let frame = 0;
+  const interval = setInterval(() => {
+    process.stderr.write(`\r${chalk2.cyan(spinner[frame++ % spinner.length])} Checking ${url}...`);
+  }, 80);
+  try {
+    const report = await check({
+      url,
+      depth: parseInt(opts.depth, 10),
+      skipAi: opts.skipAi,
+      timeout: parseInt(opts.timeout, 10),
+      apiKey: opts.apiKey
+    });
+    clearInterval(interval);
+    process.stderr.write("\r" + " ".repeat(60) + "\r");
+    if (opts.json) {
+      console.log(renderJsonReport(report));
+    } else {
+      console.log(renderTerminalReport(report));
+    }
+    if (opts.save !== false) {
+      const ts = formatTimestamp();
+      const domain = getDomain(url);
+      const outDir = join(process.cwd(), opts.output);
+      try {
+        mkdirSync(outDir, { recursive: true });
+        const jsonPath = join(outDir, `${domain}-${ts}.json`);
+        writeFileSync(jsonPath, renderJsonReport(report), "utf-8");
+        console.log(chalk2.gray(`  Report saved: ${jsonPath}`));
+      } catch (saveErr) {
+        console.error(chalk2.yellow(`  Warning: Failed to save report: ${saveErr instanceof Error ? saveErr.message : String(saveErr)}`));
+      }
+    }
+    process.exit(report.failed > 0 ? 1 : 0);
+  } catch (err) {
+    clearInterval(interval);
+    process.stderr.write("\r" + " ".repeat(60) + "\r");
+    console.error(chalk2.red(`Error: ${err instanceof Error ? err.message : String(err)}`));
+    process.exit(2);
+  }
+});
+program.parse();

package/dist/index.d.ts

@@ -0,0 +1,48 @@
+type CheckStatus = 'pass' | 'warn' | 'fail' | 'skip';
+interface CheckItem {
+    name: string;
+    status: CheckStatus;
+    message: string;
+    detail?: string;
+}
+interface CheckCategory {
+    name: string;
+    items: CheckItem[];
+}
+interface PageDetail {
+    url: string;
+    title: string;
+    totalChars: number;
+    contentChars: number;
+    contentRatio: number;
+    contentStatus: CheckStatus;
+    issues: string[];
+    ai?: {
+        status: CheckStatus;
+        assessment: string;
+        suggestions: string[];
+    };
+}
+interface CheckReport {
+    url: string;
+    timestamp: string;
+    categories: CheckCategory[];
+    score: number;
+    totalChecks: number;
+    passed: number;
+    warned: number;
+    failed: number;
+    skipped: number;
+    pages: PageDetail[];
+}
+interface CheckOptions {
+    url: string;
+    depth?: number;
+    skipAi?: boolean;
+    timeout?: number;
+    apiKey?: string;
+}
+
+declare function check(options: CheckOptions): Promise<CheckReport>;
+
+export { type CheckCategory, type CheckItem, type CheckOptions, type CheckReport, check };

package/dist/index.js

@@ -0,0 +1,6 @@
+import {
+  check
+} from "./chunk-V2YZ36NU.js";
+export {
+  check
+};

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@cloudcreate/adsense-check",
+  "version": "1.0.0",
+  "description": "Check if a website meets Google AdSense review requirements",
+  "homepage": "https://cloudcreate.ai",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cloudcreate-ai/adsense-checklist.git"
+  },
+  "bugs": {
+    "url": "https://github.com/cloudcreate-ai/adsense-checklist/issues"
+  },
+  "type": "module",
+  "bin": {
+    "adsense-check": "./dist/cli.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsx src/cli.ts",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "adsense",
+    "google",
+    "website",
+    "checker",
+    "seo",
+    "audit"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^5.4.1",
+    "commander": "^13.1.0",
+    "dotenv": "^16.5.0",
+    "figures": "^6.1.0",
+    "playwright": "^1.52.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.0",
+    "tsup": "^8.4.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.8.0"
+  }
+}