@djangocfg/seo 2.1.50

package/dist/index.mjs

@@ -0,0 +1,3236 @@
+import consola2 from 'consola';
+import { searchconsole } from '@googleapis/searchconsole';
+import pLimit from 'p-limit';
+import pRetry from 'p-retry';
+import { JWT } from 'google-auth-library';
+import fs, { existsSync, readdirSync, rmSync, mkdirSync, writeFileSync, readFileSync, statSync } from 'fs';
+import { load } from 'cheerio';
+import robotsParser from 'robots-parser';
+import path, { join, dirname } from 'path';
+import { mkdir, writeFile } from 'fs/promises';
+import * as linkinator from 'linkinator';
+import chalk from 'chalk';
+
+// src/analyzer.ts
+var SCOPES = [
+  "https://www.googleapis.com/auth/webmasters.readonly",
+  "https://www.googleapis.com/auth/webmasters"
+];
+function loadCredentials(config) {
+  if (config.serviceAccountJson) {
+    return config.serviceAccountJson;
+  }
+  if (config.serviceAccountPath) {
+    if (!existsSync(config.serviceAccountPath)) {
+      throw new Error(`Service account file not found: ${config.serviceAccountPath}`);
+    }
+    const content = readFileSync(config.serviceAccountPath, "utf-8");
+    return JSON.parse(content);
+  }
+  const envJson = process.env.GOOGLE_SERVICE_ACCOUNT_JSON;
+  if (envJson) {
+    return JSON.parse(envJson);
+  }
+  const defaultPath = "./service_account.json";
+  if (existsSync(defaultPath)) {
+    const content = readFileSync(defaultPath, "utf-8");
+    return JSON.parse(content);
+  }
+  throw new Error(
+    "No service account credentials found. Provide serviceAccountPath, serviceAccountJson, or set GOOGLE_SERVICE_ACCOUNT_JSON env variable."
+  );
+}
+function createAuthClient(config) {
+  const credentials = loadCredentials(config);
+  const auth = new JWT({
+    email: credentials.client_email,
+    key: credentials.private_key,
+    scopes: SCOPES
+  });
+  auth._serviceAccountEmail = credentials.client_email;
+  return auth;
+}
+async function verifyAuth(auth, siteUrl) {
+  const email = auth._serviceAccountEmail || auth.email;
+  try {
+    await auth.authorize();
+    consola2.success("Google Search Console authentication verified");
+    consola2.info(`Service account: ${email}`);
+    if (siteUrl) {
+      const domain = new URL(siteUrl).hostname;
+      const gscUrl = `https://search.google.com/search-console/users?resource_id=sc-domain%3A${domain}`;
+      consola2.info(`Ensure this email has Full access in GSC: ${gscUrl}`);
+    }
+    return true;
+  } catch (error) {
+    consola2.error("Authentication failed");
+    consola2.info(`Service account email: ${email}`);
+    consola2.info("Make sure this email is added to GSC with Full access");
+    return false;
+  }
+}
+
+// src/google-console/client.ts
+var GoogleConsoleClient = class {
+  auth;
+  searchconsole;
+  siteUrl;
+  gscSiteUrl;
+  // Format for GSC API (may be sc-domain:xxx)
+  limit = pLimit(2);
+  // Max 2 concurrent requests (Cloudflare-friendly)
+  requestDelay = 500;
+  // Delay between requests in ms
+  constructor(config) {
+    this.auth = createAuthClient(config);
+    this.searchconsole = searchconsole({ version: "v1", auth: this.auth });
+    this.siteUrl = config.siteUrl;
+    if (config.gscSiteUrl) {
+      this.gscSiteUrl = config.gscSiteUrl;
+    } else {
+      const domain = new URL(config.siteUrl).hostname;
+      this.gscSiteUrl = `sc-domain:${domain}`;
+    }
+    consola2.debug(`GSC site URL: ${this.gscSiteUrl}`);
+  }
+  /**
+   * Delay helper for rate limiting
+   */
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * Verify the client is authenticated
+   */
+  async verify() {
+    return verifyAuth(this.auth, this.siteUrl);
+  }
+  /**
+   * List all sites in Search Console
+   */
+  async listSites() {
+    try {
+      const response = await this.searchconsole.sites.list();
+      return response.data.siteEntry?.map((site) => site.siteUrl || "") || [];
+    } catch (error) {
+      consola2.error("Failed to list sites:", error);
+      throw error;
+    }
+  }
+  /**
+   * Inspect a single URL
+   */
+  async inspectUrl(url) {
+    return this.limit(async () => {
+      return pRetry(
+        async () => {
+          const response = await this.searchconsole.urlInspection.index.inspect({
+            requestBody: {
+              inspectionUrl: url,
+              siteUrl: this.gscSiteUrl,
+              languageCode: "en-US"
+            }
+          });
+          const result = response.data.inspectionResult;
+          if (!result?.indexStatusResult) {
+            throw new Error(`No inspection result for URL: ${url}`);
+          }
+          return this.mapInspectionResult(url, result);
+        },
+        {
+          retries: 2,
+          minTimeout: 2e3,
+          maxTimeout: 1e4,
+          factor: 2,
+          // Exponential backoff
+          onFailedAttempt: (ctx) => {
+            if (ctx.retriesLeft === 0) {
+              consola2.warn(`Failed: ${url}`);
+            }
+          }
+        }
+      );
+    });
+  }
+  /**
+   * Inspect multiple URLs in batch
+   * Stops early if too many consecutive errors (likely rate limiting)
+   */
+  async inspectUrls(urls) {
+    consola2.info(`Inspecting ${urls.length} URLs...`);
+    const results = [];
+    const errors = [];
+    let consecutiveErrors = 0;
+    const maxConsecutiveErrors = 3;
+    for (const url of urls) {
+      try {
+        const result = await this.inspectUrl(url);
+        results.push(result);
+        consecutiveErrors = 0;
+        await this.delay(this.requestDelay);
+      } catch (error) {
+        const err = error;
+        errors.push({ url, error: err });
+        consecutiveErrors++;
+        if (consecutiveErrors >= maxConsecutiveErrors) {
+          console.log("");
+          consola2.error(`Stopping after ${maxConsecutiveErrors} consecutive failures`);
+          this.showRateLimitHelp();
+          break;
+        }
+      }
+    }
+    if (errors.length > 0 && consecutiveErrors < maxConsecutiveErrors) {
+      consola2.warn(`Failed to inspect ${errors.length} URLs`);
+    }
+    if (results.length > 0) {
+      consola2.success(`Successfully inspected ${results.length}/${urls.length} URLs`);
+    } else if (errors.length > 0) {
+      consola2.warn("No URLs were successfully inspected");
+    }
+    return results;
+  }
+  /**
+   * Show help message for rate limiting issues
+   */
+  showRateLimitHelp() {
+    consola2.info("Possible causes:");
+    consola2.info("  1. Google API quota exceeded (2000 requests/day)");
+    consola2.info("  2. Cloudflare blocking Google's crawler");
+    consola2.info("  3. Service account not added to GSC");
+    console.log("");
+    consola2.info("Solutions:");
+    consola2.info("  \u2022 Check GSC access: https://search.google.com/search-console/users");
+    console.log("");
+    consola2.info("  \u2022 Cloudflare WAF rule to allow Googlebot:");
+    consola2.info("    1. Dashboard \u2192 Security \u2192 WAF \u2192 Custom rules \u2192 Create rule");
+    consola2.info('    2. Name: "Allow Googlebot"');
+    consola2.info('    3. Field: "Known Bots" | Operator: "equals" | Value: "true"');
+    consola2.info('    4. Or click "Edit expression" and paste: (cf.client.bot)');
+    consola2.info("    5. Action: Skip \u2192 check all rules");
+    consola2.info("    6. Deploy");
+    consola2.info("    Docs: https://developers.cloudflare.com/waf/custom-rules/use-cases/allow-traffic-from-verified-bots/");
+    console.log("");
+  }
+  /**
+   * Get search analytics data
+   */
+  async getSearchAnalytics(options) {
+    try {
+      const response = await this.searchconsole.searchanalytics.query({
+        siteUrl: this.gscSiteUrl,
+        requestBody: {
+          startDate: options.startDate,
+          endDate: options.endDate,
+          dimensions: options.dimensions || ["page"],
+          rowLimit: options.rowLimit || 1e3
+        }
+      });
+      return response.data.rows || [];
+    } catch (error) {
+      consola2.error("Failed to get search analytics:", error);
+      throw error;
+    }
+  }
+  /**
+   * Get list of sitemaps
+   */
+  async getSitemaps() {
+    try {
+      const response = await this.searchconsole.sitemaps.list({
+        siteUrl: this.gscSiteUrl
+      });
+      return response.data.sitemap || [];
+    } catch (error) {
+      consola2.error("Failed to get sitemaps:", error);
+      throw error;
+    }
+  }
+  /**
+   * Map API response to our types
+   */
+  mapInspectionResult(url, result) {
+    const indexStatus = result.indexStatusResult;
+    return {
+      url,
+      inspectionResultLink: result.inspectionResultLink || void 0,
+      indexStatusResult: {
+        verdict: indexStatus.verdict || "VERDICT_UNSPECIFIED",
+        coverageState: indexStatus.coverageState || "COVERAGE_STATE_UNSPECIFIED",
+        indexingState: indexStatus.indexingState || "INDEXING_STATE_UNSPECIFIED",
+        robotsTxtState: indexStatus.robotsTxtState || "ROBOTS_TXT_STATE_UNSPECIFIED",
+        pageFetchState: indexStatus.pageFetchState || "PAGE_FETCH_STATE_UNSPECIFIED",
+        lastCrawlTime: indexStatus.lastCrawlTime || void 0,
+        crawledAs: indexStatus.crawledAs,
+        googleCanonical: indexStatus.googleCanonical || void 0,
+        userCanonical: indexStatus.userCanonical || void 0,
+        sitemap: indexStatus.sitemap || void 0,
+        referringUrls: indexStatus.referringUrls || void 0
+      },
+      mobileUsabilityResult: result.mobileUsabilityResult ? {
+        verdict: result.mobileUsabilityResult.verdict || "VERDICT_UNSPECIFIED",
+        issues: result.mobileUsabilityResult.issues?.map((issue) => ({
+          issueType: issue.issueType || "UNKNOWN",
+          message: issue.message || ""
+        }))
+      } : void 0,
+      richResultsResult: result.richResultsResult ? {
+        verdict: result.richResultsResult.verdict || "VERDICT_UNSPECIFIED",
+        detectedItems: result.richResultsResult.detectedItems?.map((item) => ({
+          richResultType: item.richResultType || "UNKNOWN",
+          items: item.items?.map((i) => ({
+            name: i.name || "",
+            issues: i.issues?.map((issue) => ({
+              issueMessage: issue.issueMessage || "",
+              severity: issue.severity || "WARNING"
+            }))
+          }))
+        }))
+      } : void 0
+    };
+  }
+};
+
+// src/google-console/analyzer.ts
+function analyzeInspectionResults(results) {
+  const issues = [];
+  for (const result of results) {
+    issues.push(...analyzeUrlInspection(result));
+  }
+  return issues.sort((a, b) => severityOrder(a.severity) - severityOrder(b.severity));
+}
+function analyzeUrlInspection(result) {
+  const issues = [];
+  const { indexStatusResult, mobileUsabilityResult, richResultsResult } = result;
+  switch (indexStatusResult.coverageState) {
+    case "CRAWLED_CURRENTLY_NOT_INDEXED":
+      issues.push({
+        id: `crawled-not-indexed-${hash(result.url)}`,
+        url: result.url,
+        category: "indexing",
+        severity: "error",
+        title: "Page crawled but not indexed",
+        description: "Google crawled this page but decided not to index it. This often indicates low content quality or duplicate content.",
+        recommendation: "Improve content quality, ensure uniqueness, add more valuable information, and check for duplicate content issues.",
+        detectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        metadata: { coverageState: indexStatusResult.coverageState }
+      });
+      break;
+    case "DISCOVERED_CURRENTLY_NOT_INDEXED":
+      issues.push({
+        id: `discovered-not-indexed-${hash(result.url)}`,
+        url: result.url,
+        category: "indexing",
+        severity: "warning",
+        title: "Page discovered but not crawled",
+        description: "Google discovered this URL but has not crawled it yet. This may indicate crawl budget issues or low priority.",
+        recommendation: "Improve internal linking to this page, submit URL through Google Search Console, or add to sitemap.",
+        detectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        metadata: { coverageState: indexStatusResult.coverageState }
+      });
+      break;
+    case "DUPLICATE_WITHOUT_USER_SELECTED_CANONICAL":
+      issues.push({
+        id: `duplicate-no-canonical-${hash(result.url)}`,
+        url: result.url,
+        category: "indexing",
+        severity: "warning",
+        title: "Duplicate page without canonical",
+        description: "This page is considered a duplicate but no canonical URL has been specified. Google chose a canonical for you.",
+        recommendation: "Add a canonical tag pointing to the preferred version of this page.",
+        detectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        metadata: {
+          coverageState: indexStatusResult.coverageState,
+          googleCanonical: indexStatusResult.googleCanonical
+        }
+      });
+      break;
+    case "DUPLICATE_GOOGLE_CHOSE_DIFFERENT_CANONICAL":
+      issues.push({
+        id: `canonical-mismatch-${hash(result.url)}`,
+        url: result.url,
+        category: "indexing",
+        severity: "warning",
+        title: "Google chose different canonical",
+        description: "You specified a canonical URL, but Google chose a different one. This may cause indexing issues.",
+        recommendation: "Review canonical tags and ensure they point to the correct URL. Check for duplicate content.",
+        detectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        metadata: {
+          coverageState: indexStatusResult.coverageState,
+          userCanonical: indexStatusResult.userCanonical,
+          googleCanonical: indexStatusResult.googleCanonical
+        }
+      });
+      break;
+  }
+  switch (indexStatusResult.indexingState) {
+    case "BLOCKED_BY_META_TAG":
+      issues.push({
+        id: `blocked-meta-noindex-${hash(result.url)}`,
+        url: result.url,
+        category: "indexing",
+        severity: "error",
+        title: "Blocked by noindex meta tag",
+        description: "This page has a noindex meta tag preventing it from being indexed.",
+        recommendation: "Remove the noindex meta tag if you want this page to be indexed. If intentional, no action needed.",
+        detectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        metadata: { indexingState: indexStatusResult.indexingState }
+      });
+      break;
+    case "BLOCKED_BY_HTTP_HEADER":
+      issues.push({
+        id: `blocked-http-header-${hash(result.url)}`,
+        url: result.url,
+        category: "indexing",
+        severity: "error",
+        title: "Blocked by X-Robots-Tag header",
+        description: "This page has a noindex directive in the X-Robots-Tag HTTP header.",
+        recommendation: "Remove the X-Robots-Tag: noindex header if you want this page to be indexed.",
+        detectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        metadata: { indexingState: indexStatusResult.indexingState }
+      });
+      break;
+    case "BLOCKED_BY_ROBOTS_TXT":
+      issues.push({
+        id: `blocked-robots-txt-${hash(result.url)}`,
+        url: result.url,
+        category: "crawling",
+        severity: "error",
+        title: "Blocked by robots.txt",
+        description: "This page is blocked from crawling by robots.txt rules.",
+        recommendation: "Update robots.txt to allow crawling if you want this page to be indexed.",
+        detectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        metadata: { indexingState: indexStatusResult.indexingState }
+      });
+      break;
+  }
+  switch (indexStatusResult.pageFetchState) {
+    case "SOFT_404":
+      issues.push({
+        id: `soft-404-${hash(result.url)}`,
+        url: result.url,
+        category: "technical",
+        severity: "error",
+        title: "Soft 404 error",
+        description: "This page returns a 200 status but Google detected it as a 404 page (empty or low-value content).",
+        recommendation: "Either return a proper 404 status code or add meaningful content to this page.",
+        detectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        metadata: { pageFetchState: indexStatusResult.pageFetchState }
+      });
+      break;
+    case "NOT_FOUND":
+      issues.push({
+        id: `404-error-${hash(result.url)}`,
+        url: result.url,
+        category: "technical",
+        severity: "error",
+        title: "404 Not Found",
+        description: "This page returns a 404 error.",
+        recommendation: "Either restore the page content or set up a redirect to a relevant page.",
+        detectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        metadata: { pageFetchState: indexStatusResult.pageFetchState }
+      });
+      break;
+    case "SERVER_ERROR":
+      issues.push({
+        id: `server-error-${hash(result.url)}`,
+        url: result.url,
+        category: "technical",
+        severity: "critical",
+        title: "Server error (5xx)",
+        description: "This page returns a server error when Google tries to crawl it.",
+        recommendation: "Fix the server-side error. Check server logs for details.",
+        detectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        metadata: { pageFetchState: indexStatusResult.pageFetchState }
+      });
+      break;
+    case "REDIRECT_ERROR":
+      issues.push({
+        id: `redirect-error-${hash(result.url)}`,
+        url: result.url,
+        category: "technical",
+        severity: "error",
+        title: "Redirect error",
+        description: "There is a redirect issue with this page (redirect loop, too many redirects, or invalid redirect).",
+        recommendation: "Fix the redirect chain. Ensure redirects point to valid, accessible pages.",
+        detectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        metadata: { pageFetchState: indexStatusResult.pageFetchState }
+      });
+      break;
+    case "ACCESS_DENIED":
+    case "ACCESS_FORBIDDEN":
+      issues.push({
+        id: `access-denied-${hash(result.url)}`,
+        url: result.url,
+        category: "technical",
+        severity: "error",
+        title: "Access denied (401/403)",
+        description: "Google cannot access this page due to authentication requirements.",
+        recommendation: "Ensure the page is publicly accessible without authentication for Googlebot.",
+        detectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        metadata: { pageFetchState: indexStatusResult.pageFetchState }
+      });
+      break;
+  }
+  if (mobileUsabilityResult?.verdict === "FAIL" && mobileUsabilityResult.issues) {
+    for (const issue of mobileUsabilityResult.issues) {
+      issues.push({
+        id: `mobile-${issue.issueType}-${hash(result.url)}`,
+        url: result.url,
+        category: "mobile",
+        severity: "warning",
+        title: `Mobile usability: ${formatIssueType(issue.issueType)}`,
+        description: issue.message || "Mobile usability issue detected.",
+        recommendation: getMobileRecommendation(issue.issueType),
+        detectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        metadata: { issueType: issue.issueType }
+      });
+    }
+  }
+  if (richResultsResult?.verdict === "FAIL" && richResultsResult.detectedItems) {
+    for (const item of richResultsResult.detectedItems) {
+      for (const i of item.items || []) {
+        for (const issueDetail of i.issues || []) {
+          issues.push({
+            id: `rich-result-${item.richResultType}-${hash(result.url)}`,
+            url: result.url,
+            category: "structured-data",
+            severity: issueDetail.severity === "ERROR" ? "error" : "warning",
+            title: `${item.richResultType}: ${i.name}`,
+            description: issueDetail.issueMessage,
+            recommendation: "Fix the structured data markup according to Google guidelines.",
+            detectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            metadata: { richResultType: item.richResultType }
+          });
+        }
+      }
+    }
+  }
+  return issues;
+}
+function severityOrder(severity) {
+  const order = {
+    critical: 0,
+    error: 1,
+    warning: 2,
+    info: 3
+  };
+  return order[severity];
+}
+function hash(str) {
+  let hash5 = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash5 = (hash5 << 5) - hash5 + char;
+    hash5 = hash5 & hash5;
+  }
+  return Math.abs(hash5).toString(36);
+}
+function formatIssueType(type) {
+  return type.replace(/_/g, " ").toLowerCase().replace(/\b\w/g, (c) => c.toUpperCase());
+}
+function getMobileRecommendation(issueType) {
+  const recommendations = {
+    MOBILE_FRIENDLY_RULE_USES_INCOMPATIBLE_PLUGINS: "Remove Flash or other incompatible plugins. Use HTML5 alternatives.",
+    MOBILE_FRIENDLY_RULE_CONFIGURE_VIEWPORT: 'Add a viewport meta tag: <meta name="viewport" content="width=device-width, initial-scale=1">',
+    MOBILE_FRIENDLY_RULE_CONTENT_NOT_SIZED_TO_VIEWPORT: "Ensure content width fits the viewport. Use responsive CSS.",
+    MOBILE_FRIENDLY_RULE_TAP_TARGETS_TOO_SMALL: "Increase the size of touch targets (buttons, links) to at least 48x48 pixels.",
+    MOBILE_FRIENDLY_RULE_TEXT_TOO_SMALL: "Use at least 16px font size for body text."
+  };
+  return recommendations[issueType] || "Fix the mobile usability issue according to Google guidelines.";
+}
+var DEFAULT_CONFIG = {
+  maxPages: 100,
+  maxDepth: 3,
+  concurrency: 5,
+  timeout: 3e4,
+  userAgent: "DjangoCFG-SEO-Crawler/1.0 (+https://djangocfg.com/bot)",
+  respectRobotsTxt: true,
+  includePatterns: [],
+  excludePatterns: [
+    "/api/",
+    "/admin/",
+    "/_next/",
+    "/static/",
+    ".pdf",
+    ".jpg",
+    ".png",
+    ".gif",
+    ".svg",
+    ".css",
+    ".js"
+  ]
+};
+var SiteCrawler = class {
+  config;
+  baseUrl;
+  visited = /* @__PURE__ */ new Set();
+  queue = [];
+  results = [];
+  limit;
+  constructor(siteUrl, config) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.baseUrl = new URL(siteUrl);
+    this.limit = pLimit(this.config.concurrency);
+  }
+  /**
+   * Start crawling the site
+   */
+  async crawl() {
+    consola2.info(`Starting crawl of ${this.baseUrl.origin}`);
+    consola2.info(`Config: maxPages=${this.config.maxPages}, maxDepth=${this.config.maxDepth}`);
+    this.queue.push({ url: this.baseUrl.href, depth: 0 });
+    while (this.queue.length > 0 && this.results.length < this.config.maxPages) {
+      const batch = this.queue.splice(0, this.config.concurrency);
+      const promises = batch.map(
+        ({ url, depth }) => this.limit(() => this.crawlPage(url, depth))
+      );
+      await Promise.all(promises);
+    }
+    consola2.success(`Crawl complete. Crawled ${this.results.length} pages.`);
+    return this.results;
+  }
+  /**
+   * Crawl a single page
+   */
+  async crawlPage(url, depth) {
+    const normalizedUrl = this.normalizeUrl(url);
+    if (this.visited.has(normalizedUrl)) return;
+    if (this.shouldExclude(normalizedUrl)) return;
+    this.visited.add(normalizedUrl);
+    const startTime = Date.now();
+    const result = {
+      url: normalizedUrl,
+      statusCode: 0,
+      links: { internal: [], external: [] },
+      images: [],
+      loadTime: 0,
+      errors: [],
+      warnings: [],
+      crawledAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+      const response = await fetch(normalizedUrl, {
+        headers: {
+          "User-Agent": this.config.userAgent,
+          Accept: "text/html,application/xhtml+xml"
+        },
+        signal: controller.signal,
+        redirect: "follow"
+      });
+      result.ttfb = Date.now() - startTime;
+      clearTimeout(timeoutId);
+      result.statusCode = response.status;
+      result.contentType = response.headers.get("content-type") || void 0;
+      result.contentLength = Number(response.headers.get("content-length")) || void 0;
+      if (response.ok && result.contentType?.includes("text/html")) {
+        const html = await response.text();
+        this.parseHtml(html, result, normalizedUrl, depth);
+      } else if (!response.ok) {
+        result.errors.push(`HTTP ${response.status}: ${response.statusText}`);
+      }
+    } catch (error) {
+      if (error instanceof Error) {
+        if (error.name === "AbortError") {
+          result.errors.push("Request timeout");
+        } else {
+          result.errors.push(error.message);
+        }
+      }
+    }
+    result.loadTime = Date.now() - startTime;
+    this.results.push(result);
+    consola2.debug(`Crawled: ${normalizedUrl} (${result.statusCode}) - ${result.loadTime}ms`);
+  }
+  /**
+   * Parse HTML and extract SEO-relevant data
+   */
+  parseHtml(html, result, pageUrl, depth) {
+    const $ = load(html);
+    result.title = $("title").first().text().trim() || void 0;
+    if (!result.title) {
+      result.warnings.push("Missing title tag");
+    } else if (result.title.length > 60) {
+      result.warnings.push(`Title too long (${result.title.length} chars, recommended: <60)`);
+    }
+    result.metaDescription = $('meta[name="description"]').attr("content")?.trim() || void 0;
+    if (!result.metaDescription) {
+      result.warnings.push("Missing meta description");
+    } else if (result.metaDescription.length > 160) {
+      result.warnings.push(
+        `Meta description too long (${result.metaDescription.length} chars, recommended: <160)`
+      );
+    }
+    result.metaRobots = $('meta[name="robots"]').attr("content")?.trim() || void 0;
+    const xRobots = $('meta[http-equiv="X-Robots-Tag"]').attr("content")?.trim();
+    if (xRobots) {
+      result.metaRobots = result.metaRobots ? `${result.metaRobots}, ${xRobots}` : xRobots;
+    }
+    result.canonicalUrl = $('link[rel="canonical"]').attr("href")?.trim() || void 0;
+    if (!result.canonicalUrl) {
+      result.warnings.push("Missing canonical tag");
+    }
+    result.h1 = $("h1").map((_, el) => $(el).text().trim()).get();
+    result.h2 = $("h2").map((_, el) => $(el).text().trim()).get();
+    if (result.h1.length === 0) {
+      result.warnings.push("Missing H1 tag");
+    } else if (result.h1.length > 1) {
+      result.warnings.push(`Multiple H1 tags (${result.h1.length})`);
+    }
+    $("a[href]").each((_, el) => {
+      const href = $(el).attr("href");
+      if (!href) return;
+      try {
+        const linkUrl = new URL(href, pageUrl);
+        if (linkUrl.hostname === this.baseUrl.hostname) {
+          const internalUrl = this.normalizeUrl(linkUrl.href);
+          result.links.internal.push(internalUrl);
+          if (depth < this.config.maxDepth && !this.visited.has(internalUrl)) {
+            this.queue.push({ url: internalUrl, depth: depth + 1 });
+          }
+        } else {
+          result.links.external.push(linkUrl.href);
+        }
+      } catch {
+      }
+    });
+    $("img").each((_, el) => {
+      const src = $(el).attr("src");
+      const alt = $(el).attr("alt");
+      if (src) {
+        result.images.push({
+          src,
+          alt,
+          hasAlt: alt !== void 0 && alt.trim().length > 0
+        });
+      }
+    });
+    const imagesWithoutAlt = result.images.filter((img) => !img.hasAlt);
+    if (imagesWithoutAlt.length > 0) {
+      result.warnings.push(`${imagesWithoutAlt.length} images without alt text`);
+    }
+  }
+  /**
+   * Normalize URL for deduplication
+   */
+  normalizeUrl(url) {
+    try {
+      const parsed = new URL(url, this.baseUrl.href);
+      parsed.hash = "";
+      let pathname = parsed.pathname;
+      if (pathname.endsWith("/") && pathname !== "/") {
+        pathname = pathname.slice(0, -1);
+      }
+      parsed.pathname = pathname;
+      return parsed.href;
+    } catch {
+      return url;
+    }
+  }
+  /**
+   * Check if URL should be excluded
+   */
+  shouldExclude(url) {
+    if (this.config.includePatterns.length > 0) {
+      const included = this.config.includePatterns.some(
+        (pattern) => url.includes(pattern)
+      );
+      if (!included) return true;
+    }
+    return this.config.excludePatterns.some((pattern) => url.includes(pattern));
+  }
+};
+function analyzeCrawlResults(results) {
+  const issues = [];
+  for (const result of results) {
+    if (result.statusCode >= 400) {
+      issues.push({
+        id: `http-error-${hash2(result.url)}`,
+        url: result.url,
+        category: "technical",
+        severity: result.statusCode >= 500 ? "critical" : "error",
+        title: `HTTP ${result.statusCode} error`,
+        description: `Page returns ${result.statusCode} status code.`,
+        recommendation: result.statusCode === 404 ? "Either restore the content or set up a redirect." : "Fix the server error and ensure the page is accessible.",
+        detectedAt: result.crawledAt,
+        metadata: { statusCode: result.statusCode }
+      });
+    }
+    if (!result.title && result.statusCode === 200) {
+      issues.push({
+        id: `missing-title-${hash2(result.url)}`,
+        url: result.url,
+        category: "content",
+        severity: "error",
+        title: "Missing title tag",
+        description: "This page does not have a title tag.",
+        recommendation: "Add a unique, descriptive title tag (50-60 characters).",
+        detectedAt: result.crawledAt
+      });
+    }
+    if (!result.metaDescription && result.statusCode === 200) {
+      issues.push({
+        id: `missing-meta-desc-${hash2(result.url)}`,
+        url: result.url,
+        category: "content",
+        severity: "warning",
+        title: "Missing meta description",
+        description: "This page does not have a meta description.",
+        recommendation: "Add a unique meta description (120-160 characters).",
+        detectedAt: result.crawledAt
+      });
+    }
+    if (result.h1 && result.h1.length === 0 && result.statusCode === 200) {
+      issues.push({
+        id: `missing-h1-${hash2(result.url)}`,
+        url: result.url,
+        category: "content",
+        severity: "warning",
+        title: "Missing H1 heading",
+        description: "This page does not have an H1 heading.",
+        recommendation: "Add a single H1 heading that describes the page content.",
+        detectedAt: result.crawledAt
+      });
+    }
+    if (result.h1 && result.h1.length > 1) {
+      issues.push({
+        id: `multiple-h1-${hash2(result.url)}`,
+        url: result.url,
+        category: "content",
+        severity: "warning",
+        title: "Multiple H1 headings",
+        description: `This page has ${result.h1.length} H1 headings.`,
+        recommendation: "Use only one H1 heading per page.",
+        detectedAt: result.crawledAt,
+        metadata: { h1Count: result.h1.length }
+      });
+    }
+    const imagesWithoutAlt = result.images.filter((img) => !img.hasAlt);
+    if (imagesWithoutAlt.length > 0) {
+      issues.push({
+        id: `images-no-alt-${hash2(result.url)}`,
+        url: result.url,
+        category: "content",
+        severity: "info",
+        title: "Images without alt text",
+        description: `${imagesWithoutAlt.length} images are missing alt text.`,
+        recommendation: "Add descriptive alt text to all images for accessibility and SEO.",
+        detectedAt: result.crawledAt,
+        metadata: { count: imagesWithoutAlt.length }
+      });
+    }
+    if (result.loadTime > 3e3) {
+      issues.push({
+        id: `slow-page-${hash2(result.url)}`,
+        url: result.url,
+        category: "performance",
+        severity: result.loadTime > 5e3 ? "error" : "warning",
+        title: "Slow page load time",
+        description: `Page took ${result.loadTime}ms to load.`,
+        recommendation: "Optimize page load time. Target under 3 seconds.",
+        detectedAt: result.crawledAt,
+        metadata: { loadTime: result.loadTime }
+      });
+    }
+    if (result.ttfb && result.ttfb > 800) {
+      issues.push({
+        id: `slow-ttfb-${hash2(result.url)}`,
+        url: result.url,
+        category: "performance",
+        severity: result.ttfb > 1500 ? "error" : "warning",
+        title: "Slow Time to First Byte",
+        description: `TTFB is ${result.ttfb}ms. Server responded slowly.`,
+        recommendation: "Optimize server response. Target TTFB under 800ms. Consider CDN, caching, or server upgrades.",
+        detectedAt: result.crawledAt,
+        metadata: { ttfb: result.ttfb }
+      });
+    }
+    if (result.metaRobots?.includes("noindex")) {
+      issues.push({
+        id: `noindex-${hash2(result.url)}`,
+        url: result.url,
+        category: "indexing",
+        severity: "info",
+        title: "Page marked as noindex",
+        description: "This page has a noindex directive.",
+        recommendation: "Verify this is intentional. Remove noindex if the page should be indexed.",
+        detectedAt: result.crawledAt,
+        metadata: { metaRobots: result.metaRobots }
+      });
+    }
+  }
+  return issues;
+}
+function hash2(str) {
+  let hash5 = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash5 = (hash5 << 5) - hash5 + char;
+    hash5 = hash5 & hash5;
+  }
+  return Math.abs(hash5).toString(36);
+}
+async function analyzeRobotsTxt(siteUrl) {
+  const robotsUrl = new URL("/robots.txt", siteUrl).href;
+  const analysis = {
+    exists: false,
+    sitemaps: [],
+    allowedPaths: [],
+    disallowedPaths: [],
+    issues: []
+  };
+  try {
+    const response = await fetch(robotsUrl);
+    if (!response.ok) {
+      analysis.issues.push({
+        id: "missing-robots-txt",
+        url: robotsUrl,
+        category: "technical",
+        severity: "warning",
+        title: "Missing robots.txt",
+        description: `No robots.txt file found (HTTP ${response.status}).`,
+        recommendation: "Create a robots.txt file to control crawler access.",
+        detectedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      return analysis;
+    }
+    analysis.exists = true;
+    analysis.content = await response.text();
+    const robots = robotsParser(robotsUrl, analysis.content);
+    analysis.sitemaps = robots.getSitemaps();
+    if (analysis.sitemaps.length === 0) {
+      analysis.issues.push({
+        id: "no-sitemap-in-robots",
+        url: robotsUrl,
+        category: "technical",
+        severity: "info",
+        title: "No sitemap in robots.txt",
+        description: "No sitemap URL is declared in robots.txt.",
+        recommendation: "Add a Sitemap directive pointing to your XML sitemap.",
+        detectedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+    const lines = analysis.content.split("\n");
+    let currentUserAgent = "*";
+    for (const line of lines) {
+      const trimmed = line.trim().toLowerCase();
+      if (trimmed.startsWith("user-agent:")) {
+        currentUserAgent = trimmed.replace("user-agent:", "").trim();
+      } else if (trimmed.startsWith("disallow:")) {
+        const path5 = line.trim().replace(/disallow:/i, "").trim();
+        if (path5) {
+          analysis.disallowedPaths.push(path5);
+        }
+      } else if (trimmed.startsWith("allow:")) {
+        const path5 = line.trim().replace(/allow:/i, "").trim();
+        if (path5) {
+          analysis.allowedPaths.push(path5);
+        }
+      } else if (trimmed.startsWith("crawl-delay:")) {
+        const delay = parseInt(trimmed.replace("crawl-delay:", "").trim(), 10);
+        if (!isNaN(delay)) {
+          analysis.crawlDelay = delay;
+        }
+      }
+    }
+    const importantPaths = ["/", "/sitemap.xml"];
+    for (const path5 of importantPaths) {
+      if (!robots.isAllowed(new URL(path5, siteUrl).href, "Googlebot")) {
+        analysis.issues.push({
+          id: `blocked-important-path-${path5.replace(/\//g, "-")}`,
+          url: siteUrl,
+          category: "crawling",
+          severity: "error",
+          title: `Important path blocked: ${path5}`,
+          description: `The path ${path5} is blocked in robots.txt.`,
+          recommendation: `Ensure ${path5} is accessible to search engines.`,
+          detectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          metadata: { path: path5 }
+        });
+      }
+    }
+    if (analysis.disallowedPaths.includes("/")) {
+      analysis.issues.push({
+        id: "all-blocked",
+        url: robotsUrl,
+        category: "crawling",
+        severity: "critical",
+        title: "Entire site blocked",
+        description: "robots.txt blocks access to the entire site (Disallow: /).",
+        recommendation: "Remove or modify this rule if you want your site to be indexed.",
+        detectedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+    consola2.debug(`Analyzed robots.txt: ${analysis.disallowedPaths.length} disallow rules`);
+  } catch (error) {
+    consola2.error("Failed to fetch robots.txt:", error);
+    analysis.issues.push({
+      id: "robots-txt-error",
+      url: robotsUrl,
+      category: "technical",
+      severity: "warning",
+      title: "Failed to fetch robots.txt",
+      description: `Error fetching robots.txt: ${error instanceof Error ? error.message : "Unknown error"}`,
+      recommendation: "Ensure robots.txt is accessible.",
+      detectedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  return analysis;
+}
+async function isUrlAllowed(siteUrl, url, userAgent = "Googlebot") {
+  const robotsUrl = new URL("/robots.txt", siteUrl).href;
+  try {
+    const response = await fetch(robotsUrl);
+    if (!response.ok) return true;
+    const content = await response.text();
+    const robots = robotsParser(robotsUrl, content);
+    return robots.isAllowed(url, userAgent) ?? true;
+  } catch {
+    return true;
+  }
+}
+async function analyzeSitemap(sitemapUrl) {
+  const analysis = {
+    url: sitemapUrl,
+    exists: false,
+    type: "unknown",
+    urls: [],
+    childSitemaps: [],
+    issues: []
+  };
+  try {
+    const response = await fetch(sitemapUrl, {
+      headers: {
+        Accept: "application/xml, text/xml, */*"
+      }
+    });
+    if (!response.ok) {
+      analysis.issues.push({
+        id: `sitemap-not-found-${hash3(sitemapUrl)}`,
+        url: sitemapUrl,
+        category: "technical",
+        severity: "error",
+        title: "Sitemap not accessible",
+        description: `Sitemap returned HTTP ${response.status}.`,
+        recommendation: "Ensure the sitemap URL is correct and accessible.",
+        detectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        metadata: { statusCode: response.status }
+      });
+      return analysis;
+    }
+    analysis.exists = true;
+    const content = await response.text();
+    const contentType = response.headers.get("content-type") || "";
+    if (!contentType.includes("xml") && !content.trim().startsWith("<?xml")) {
+      analysis.issues.push({
+        id: `sitemap-not-xml-${hash3(sitemapUrl)}`,
+        url: sitemapUrl,
+        category: "technical",
+        severity: "warning",
+        title: "Sitemap is not XML",
+        description: "The sitemap does not have an XML content type.",
+        recommendation: "Ensure sitemap is served with Content-Type: application/xml.",
+        detectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        metadata: { contentType }
+      });
+    }
+    const $ = load(content, { xmlMode: true });
+    const sitemapIndex = $("sitemapindex");
+    if (sitemapIndex.length > 0) {
+      analysis.type = "sitemap-index";
+      $("sitemap").each((_, el) => {
+        const loc = $("loc", el).text().trim();
+        if (loc) {
+          analysis.childSitemaps.push(loc);
+        }
+      });
+      consola2.debug(`Sitemap index contains ${analysis.childSitemaps.length} sitemaps`);
+    } else {
+      analysis.type = "sitemap";
+      $("url").each((_, el) => {
+        const loc = $("loc", el).text().trim();
+        if (loc) {
+          analysis.urls.push(loc);
+        }
+      });
+      const lastmod = $("url lastmod").first().text().trim();
+      if (lastmod) {
+        analysis.lastmod = lastmod;
+      }
+      consola2.debug(`Sitemap contains ${analysis.urls.length} URLs`);
+    }
+    if (analysis.type === "sitemap" && analysis.urls.length === 0) {
+      analysis.issues.push({
+        id: `sitemap-empty-${hash3(sitemapUrl)}`,
+        url: sitemapUrl,
+        category: "technical",
+        severity: "warning",
+        title: "Sitemap is empty",
+        description: "The sitemap contains no URLs.",
+        recommendation: "Add URLs to your sitemap or remove it if not needed.",
+        detectedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+    if (analysis.urls.length > 5e4) {
+      analysis.issues.push({
+        id: `sitemap-too-large-${hash3(sitemapUrl)}`,
+        url: sitemapUrl,
+        category: "technical",
+        severity: "error",
+        title: "Sitemap exceeds URL limit",
+        description: `Sitemap contains ${analysis.urls.length} URLs. Maximum is 50,000.`,
+        recommendation: "Split the sitemap into multiple files using a sitemap index.",
+        detectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        metadata: { urlCount: analysis.urls.length }
+      });
+    }
+    const sizeInMB = new Blob([content]).size / (1024 * 1024);
+    if (sizeInMB > 50) {
+      analysis.issues.push({
+        id: `sitemap-too-large-size-${hash3(sitemapUrl)}`,
+        url: sitemapUrl,
+        category: "technical",
+        severity: "error",
+        title: "Sitemap exceeds size limit",
+        description: `Sitemap is ${sizeInMB.toFixed(2)}MB. Maximum is 50MB.`,
+        recommendation: "Split the sitemap or compress it.",
+        detectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        metadata: { sizeMB: sizeInMB }
+      });
+    }
+  } catch (error) {
+    consola2.error("Failed to analyze sitemap:", error);
+    analysis.issues.push({
+      id: `sitemap-error-${hash3(sitemapUrl)}`,
+      url: sitemapUrl,
+      category: "technical",
+      severity: "error",
+      title: "Failed to parse sitemap",
+      description: `Error: ${error instanceof Error ? error.message : "Unknown error"}`,
+      recommendation: "Check sitemap validity using Google Search Console.",
+      detectedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  return analysis;
+}
+async function analyzeAllSitemaps(sitemapUrl, maxDepth = 3) {
+  const results = [];
+  const visited = /* @__PURE__ */ new Set();
+  async function analyze(url, depth) {
+    if (depth > maxDepth || visited.has(url)) return;
+    visited.add(url);
+    const analysis = await analyzeSitemap(url);
+    results.push(analysis);
+    for (const childUrl of analysis.childSitemaps) {
+      await analyze(childUrl, depth + 1);
+    }
+  }
+  await analyze(sitemapUrl, 0);
+  return results;
+}
+function hash3(str) {
+  let hash5 = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash5 = (hash5 << 5) - hash5 + char;
+    hash5 = hash5 & hash5;
+  }
+  return Math.abs(hash5).toString(36);
+}
+
+// src/reports/json-report.ts
+function generateJsonReport(siteUrl, data, options = {}) {
+  const { issues, urlInspections = [], crawlResults = [] } = data;
+  const maxUrlsPerIssue = options.maxUrlsPerIssue ?? 10;
+  const limitedIssues = limitIssuesByTitle(issues, maxUrlsPerIssue);
+  const report = {
+    id: generateReportId(),
+    siteUrl,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    summary: generateSummary(issues, urlInspections, crawlResults),
+    // Use original for accurate counts
+    issues: sortIssues(limitedIssues),
+    urlInspections: options.includeRawData ? urlInspections.slice(0, 100) : [],
+    crawlResults: options.includeRawData ? crawlResults.slice(0, 100) : [],
+    recommendations: generateRecommendations(issues, maxUrlsPerIssue)
+  };
+  return report;
+}
+function limitIssuesByTitle(issues, maxUrls) {
+  const byTitle = /* @__PURE__ */ new Map();
+  for (const issue of issues) {
+    const existing = byTitle.get(issue.title) || [];
+    existing.push(issue);
+    byTitle.set(issue.title, existing);
+  }
+  const limited = [];
+  for (const [, group] of byTitle) {
+    const sorted = group.sort((a, b) => {
+      const severityOrder2 = { critical: 0, error: 1, warning: 2, info: 3 };
+      return severityOrder2[a.severity] - severityOrder2[b.severity];
+    });
+    limited.push(...sorted.slice(0, maxUrls));
+  }
+  return limited;
+}
+function generateSummary(issues, urlInspections, crawlResults) {
+  const totalUrls = Math.max(
+    urlInspections.length,
+    crawlResults.length,
+    new Set(issues.map((i) => i.url)).size
+  );
+  const indexedUrls = urlInspections.filter(
+    (r) => r.indexStatusResult.coverageState === "SUBMITTED_AND_INDEXED"
+  ).length;
+  const notIndexedUrls = urlInspections.filter(
+    (r) => r.indexStatusResult.coverageState === "NOT_INDEXED" || r.indexStatusResult.coverageState === "CRAWLED_CURRENTLY_NOT_INDEXED" || r.indexStatusResult.coverageState === "DISCOVERED_CURRENTLY_NOT_INDEXED"
+  ).length;
+  const issuesByCategory = issues.reduce(
+    (acc, issue) => {
+      acc[issue.category] = (acc[issue.category] || 0) + 1;
+      return acc;
+    },
+    {}
+  );
+  const issuesBySeverity = issues.reduce(
+    (acc, issue) => {
+      acc[issue.severity] = (acc[issue.severity] || 0) + 1;
+      return acc;
+    },
+    {}
+  );
+  const healthScore = calculateHealthScore(issues, totalUrls);
+  return {
+    totalUrls,
+    indexedUrls,
+    notIndexedUrls,
+    issuesByCategory,
+    issuesBySeverity,
+    healthScore
+  };
+}
+function calculateHealthScore(issues, totalUrls) {
+  if (totalUrls === 0) return 100;
+  const severityWeights = {
+    critical: 10,
+    error: 5,
+    warning: 2,
+    info: 0.5
+  };
+  const totalPenalty = issues.reduce(
+    (sum, issue) => sum + severityWeights[issue.severity],
+    0
+  );
+  const maxPenalty = totalUrls * 20;
+  const penaltyRatio = Math.min(totalPenalty / maxPenalty, 1);
+  return Math.round((1 - penaltyRatio) * 100);
+}
+function generateRecommendations(issues, maxUrls = 10) {
+  const recommendations = [];
+  const issueGroups = /* @__PURE__ */ new Map();
+  for (const issue of issues) {
+    const key = `${issue.category}:${issue.title}`;
+    if (!issueGroups.has(key)) {
+      issueGroups.set(key, []);
+    }
+    issueGroups.get(key).push(issue);
+  }
+  for (const [, groupedIssues] of issueGroups) {
+    const firstIssue = groupedIssues[0];
+    if (!firstIssue) continue;
+    const severity = firstIssue.severity;
+    const priority = severity === "critical" ? 1 : severity === "error" ? 2 : severity === "warning" ? 3 : 4;
+    const impact = priority <= 2 ? "high" : priority === 3 ? "medium" : "low";
+    const allUrls = groupedIssues.map((i) => i.url);
+    const totalCount = allUrls.length;
+    const limitedUrls = allUrls.slice(0, maxUrls);
+    recommendations.push({
+      priority,
+      category: firstIssue.category,
+      title: firstIssue.title,
+      description: totalCount > maxUrls ? `${firstIssue.description} (showing ${maxUrls} of ${totalCount} URLs)` : firstIssue.description,
+      affectedUrls: limitedUrls,
+      estimatedImpact: impact,
+      actionItems: [firstIssue.recommendation]
+    });
+  }
+  return recommendations.sort((a, b) => a.priority - b.priority);
+}
+function sortIssues(issues) {
+  const severityOrder2 = {
+    critical: 0,
+    error: 1,
+    warning: 2,
+    info: 3
+  };
+  return [...issues].sort((a, b) => {
+    const severityDiff = severityOrder2[a.severity] - severityOrder2[b.severity];
+    if (severityDiff !== 0) return severityDiff;
+    return a.category.localeCompare(b.category);
+  });
+}
+function generateReportId() {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 8);
+  return `seo-report-${timestamp}-${random}`;
+}
+function exportJsonReport(report, pretty = true) {
+  return JSON.stringify(report, null, pretty ? 2 : 0);
+}
+var AI_REPORT_SCHEMA = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  title: "SEO Report",
+  description: "AI-friendly SEO analysis report with issues and recommendations",
+  type: "object",
+  properties: {
+    id: { type: "string", description: "Unique report identifier" },
+    siteUrl: { type: "string", description: "Analyzed site URL" },
+    generatedAt: { type: "string", format: "date-time" },
+    summary: {
+      type: "object",
+      description: "Quick overview of SEO health",
+      properties: {
+        totalUrls: { type: "number" },
+        indexedUrls: { type: "number" },
+        notIndexedUrls: { type: "number" },
+        healthScore: {
+          type: "number",
+          minimum: 0,
+          maximum: 100,
+          description: "0-100 score, higher is better"
+        }
+      }
+    },
+    issues: {
+      type: "array",
+      description: "List of detected SEO issues sorted by severity",
+      items: {
+        type: "object",
+        properties: {
+          severity: {
+            type: "string",
+            enum: ["critical", "error", "warning", "info"]
+          },
+          category: {
+            type: "string",
+            enum: [
+              "indexing",
+              "crawling",
+              "content",
+              "technical",
+              "mobile",
+              "performance",
+              "structured-data",
+              "security"
+            ]
+          },
+          title: { type: "string" },
+          description: { type: "string" },
+          recommendation: { type: "string" },
+          url: { type: "string" }
+        }
+      }
+    },
+    recommendations: {
+      type: "array",
+      description: "Prioritized action items",
+      items: {
+        type: "object",
+        properties: {
+          priority: { type: "number", minimum: 1, maximum: 5 },
+          title: { type: "string" },
+          affectedUrls: { type: "array", items: { type: "string" } },
+          actionItems: { type: "array", items: { type: "string" } }
+        }
+      }
+    }
+  }
+};
+
+// src/reports/markdown-report.ts
+function generateMarkdownReport(report, options = {}) {
+  const { includeRawIssues = true, includeUrls = true, maxUrlsPerIssue = 10 } = options;
+  const lines = [];
+  lines.push(`# SEO Analysis Report`);
+  lines.push("");
+  lines.push(`**Site:** ${report.siteUrl}`);
+  lines.push(`**Generated:** ${new Date(report.generatedAt).toLocaleString()}`);
+  lines.push(`**Report ID:** ${report.id}`);
+  lines.push("");
+  lines.push("## Summary");
+  lines.push("");
+  lines.push(`| Metric | Value |`);
+  lines.push(`|--------|-------|`);
+  lines.push(`| Health Score | ${getHealthScoreEmoji(report.summary.healthScore)} **${report.summary.healthScore}/100** |`);
+  lines.push(`| Total URLs | ${report.summary.totalUrls} |`);
+  lines.push(`| Indexed URLs | ${report.summary.indexedUrls} |`);
+  lines.push(`| Not Indexed | ${report.summary.notIndexedUrls} |`);
+  lines.push("");
+  lines.push("### Issues by Severity");
+  lines.push("");
+  const severities = ["critical", "error", "warning", "info"];
+  for (const severity of severities) {
+    const count = report.summary.issuesBySeverity[severity] || 0;
+    lines.push(`- ${getSeverityEmoji(severity)} **${capitalize(severity)}:** ${count}`);
+  }
+  lines.push("");
+  lines.push("### Issues by Category");
+  lines.push("");
+  const categories = Object.entries(report.summary.issuesByCategory).sort(
+    ([, a], [, b]) => b - a
+  );
+  for (const [category, count] of categories) {
+    lines.push(`- ${getCategoryEmoji(category)} **${formatCategory(category)}:** ${count}`);
+  }
+  lines.push("");
+  lines.push("## Prioritized Recommendations");
+  lines.push("");
+  for (const rec of report.recommendations) {
+    lines.push(`### ${getPriorityEmoji(rec.priority)} Priority ${rec.priority}: ${rec.title}`);
+    lines.push("");
+    lines.push(`**Category:** ${formatCategory(rec.category)}`);
+    lines.push(`**Impact:** ${capitalize(rec.estimatedImpact)}`);
+    lines.push(`**Affected URLs:** ${rec.affectedUrls.length}`);
+    lines.push("");
+    lines.push(`${rec.description}`);
+    lines.push("");
+    lines.push("**Action Items:**");
+    for (const action of rec.actionItems) {
+      lines.push(`- ${action}`);
+    }
+    lines.push("");
+    if (includeUrls && rec.affectedUrls.length > 0) {
+      const urlsToShow = rec.affectedUrls.slice(0, maxUrlsPerIssue);
+      lines.push("<details>");
+      lines.push(`<summary>Affected URLs (${rec.affectedUrls.length})</summary>`);
+      lines.push("");
+      for (const url of urlsToShow) {
+        lines.push(`- ${url}`);
+      }
+      if (rec.affectedUrls.length > maxUrlsPerIssue) {
+        lines.push(`- ... and ${rec.affectedUrls.length - maxUrlsPerIssue} more`);
+      }
+      lines.push("</details>");
+      lines.push("");
+    }
+    lines.push("---");
+    lines.push("");
+  }
+  if (includeRawIssues) {
+    lines.push("## All Issues");
+    lines.push("");
+    const issuesByCategory = groupBy(report.issues, "category");
+    for (const [category, issues] of Object.entries(issuesByCategory)) {
+      lines.push(`### ${getCategoryEmoji(category)} ${formatCategory(category)}`);
+      lines.push("");
+      for (const issue of issues) {
+        lines.push(
+          `#### ${getSeverityEmoji(issue.severity)} ${issue.title}`
+        );
+        lines.push("");
+        lines.push(`**URL:** \`${issue.url}\``);
+        lines.push(`**Severity:** ${capitalize(issue.severity)}`);
+        lines.push("");
+        lines.push(issue.description);
+        lines.push("");
+        lines.push(`**Recommendation:** ${issue.recommendation}`);
+        lines.push("");
+      }
+    }
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push("*Report generated by [@djangocfg/seo](https://djangocfg.com)*");
+  lines.push("");
+  lines.push("> This report is designed to be processed by AI assistants for automated SEO improvements.");
+  return lines.join("\n");
+}
+function generateAiSummary(report) {
+  const lines = [];
+  lines.push("# SEO Report Summary for AI Processing");
+  lines.push("");
+  lines.push("## Context");
+  lines.push(`Site: ${report.siteUrl}`);
+  lines.push(`Health Score: ${report.summary.healthScore}/100`);
+  lines.push(`Critical Issues: ${report.summary.issuesBySeverity.critical || 0}`);
+  lines.push(`Errors: ${report.summary.issuesBySeverity.error || 0}`);
+  lines.push(`Warnings: ${report.summary.issuesBySeverity.warning || 0}`);
+  lines.push("");
+  lines.push("## Top Priority Actions");
+  lines.push("");
+  const topRecommendations = report.recommendations.slice(0, 5);
+  for (let i = 0; i < topRecommendations.length; i++) {
+    const rec = topRecommendations[i];
+    if (!rec) continue;
+    lines.push(`${i + 1}. **${rec.title}** (${rec.affectedUrls.length} URLs)`);
+    lines.push(`   - ${rec.actionItems[0]}`);
+  }
+  lines.push("");
+  lines.push("## Issue Categories");
+  lines.push("");
+  const sortedCategories = Object.entries(report.summary.issuesByCategory).sort(([, a], [, b]) => b - a);
+  for (const [category, count] of sortedCategories) {
+    lines.push(`- ${formatCategory(category)}: ${count} issues`);
+  }
+  return lines.join("\n");
+}
+function getSeverityEmoji(severity) {
+  const emojis = {
+    critical: "\u{1F534}",
+    error: "\u{1F7E0}",
+    warning: "\u{1F7E1}",
+    info: "\u{1F535}"
+  };
+  return emojis[severity];
+}
+function getCategoryEmoji(category) {
+  const emojis = {
+    indexing: "\u{1F4D1}",
+    crawling: "\u{1F577}\uFE0F",
+    content: "\u{1F4DD}",
+    technical: "\u2699\uFE0F",
+    mobile: "\u{1F4F1}",
+    performance: "\u26A1",
+    "structured-data": "\u{1F3F7}\uFE0F",
+    security: "\u{1F512}"
+  };
+  return emojis[category] || "\u{1F4CB}";
+}
+function getPriorityEmoji(priority) {
+  const emojis = {
+    1: "\u{1F6A8}",
+    2: "\u26A0\uFE0F",
+    3: "\u{1F4CC}",
+    4: "\u{1F4A1}",
+    5: "\u2139\uFE0F"
+  };
+  return emojis[priority] || "\u{1F4CB}";
+}
+function getHealthScoreEmoji(score) {
+  if (score >= 90) return "\u{1F7E2}";
+  if (score >= 70) return "\u{1F7E1}";
+  if (score >= 50) return "\u{1F7E0}";
+  return "\u{1F534}";
+}
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function formatCategory(category) {
+  return category.split("-").map(capitalize).join(" ");
+}
+function groupBy(array, key) {
+  return array.reduce(
+    (acc, item) => {
+      const groupKey = String(item[key]);
+      if (!acc[groupKey]) {
+        acc[groupKey] = [];
+      }
+      acc[groupKey].push(item);
+      return acc;
+    },
+    {}
+  );
+}
+var MAX_LINES = 1e3;
+function generateSplitReports(report, options) {
+  const { outputDir, clearOutputDir = true } = options;
+  if (clearOutputDir && existsSync(outputDir)) {
+    const files = readdirSync(outputDir);
+    for (const file of files) {
+      if (file.startsWith("seo-") && file.endsWith(".md")) {
+        rmSync(join(outputDir, file), { force: true });
+      }
+    }
+  }
+  if (!existsSync(outputDir)) {
+    mkdirSync(outputDir, { recursive: true });
+  }
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+  const siteName = new URL(report.siteUrl).hostname.replace(/\./g, "-");
+  const prefix = `seo-${siteName}-${timestamp}`;
+  const categoryFiles = [];
+  const issuesByCategory = groupIssuesByCategory(report.issues);
+  const categories = Object.keys(issuesByCategory);
+  for (const category of categories) {
+    const issues = issuesByCategory[category] || [];
+    if (issues.length === 0) continue;
+    const chunks = splitIntoChunks(issues);
+    for (let i = 0; i < chunks.length; i++) {
+      const suffix = chunks.length > 1 ? `-${i + 1}` : "";
+      const filename = `${prefix}-${category}${suffix}.md`;
+      const filepath = join(outputDir, filename);
+      const chunk2 = chunks[i];
+      if (!chunk2) continue;
+      const content = generateCategoryFile(report.siteUrl, category, chunk2, {
+        part: chunks.length > 1 ? i + 1 : void 0,
+        totalParts: chunks.length > 1 ? chunks.length : void 0
+      });
+      writeFileSync(filepath, content, "utf-8");
+      categoryFiles.push(filename);
+    }
+  }
+  const indexFilename = `${prefix}-index.md`;
+  const indexFilepath = join(outputDir, indexFilename);
+  const indexContent = generateIndexFile(report, categoryFiles);
+  writeFileSync(indexFilepath, indexContent, "utf-8");
+  return {
+    indexFile: indexFilename,
+    categoryFiles,
+    totalFiles: categoryFiles.length + 1
+  };
+}
+function generateIndexFile(report, categoryFiles) {
+  const lines = [];
+  lines.push("# SEO Report Index");
+  lines.push("");
+  lines.push(`Site: ${report.siteUrl}`);
+  lines.push(`Score: ${report.summary.healthScore}/100`);
+  lines.push(`Date: ${report.generatedAt.slice(0, 10)}`);
+  lines.push("");
+  lines.push("## Issues");
+  lines.push("");
+  lines.push("| Severity | Count |");
+  lines.push("|----------|-------|");
+  const severities = ["critical", "error", "warning", "info"];
+  for (const sev of severities) {
+    const count = report.summary.issuesBySeverity[sev] || 0;
+    if (count > 0) {
+      lines.push(`| ${sev} | ${count} |`);
+    }
+  }
+  lines.push("");
+  lines.push("## Actions");
+  lines.push("");
+  const topRecs = report.recommendations.slice(0, 10);
+  for (let i = 0; i < topRecs.length; i++) {
+    const rec = topRecs[i];
+    if (!rec) continue;
+    lines.push(`${i + 1}. **${rec.title}** (${rec.affectedUrls.length})`);
+    lines.push(`   ${rec.actionItems[0]}`);
+  }
+  lines.push("");
+  lines.push("## Files");
+  lines.push("");
+  for (const file of categoryFiles) {
+    lines.push(`- [${file}](./${file})`);
+  }
+  return lines.join("\n");
+}
+function generateCategoryFile(siteUrl, category, issues, opts) {
+  const lines = [];
+  const partStr = opts.part ? ` (Part ${opts.part}/${opts.totalParts})` : "";
+  lines.push(`# ${formatCategory2(category)}${partStr}`);
+  lines.push("");
+  lines.push(`Site: ${siteUrl}`);
+  lines.push(`Issues: ${issues.length}`);
+  lines.push("");
+  const byTitle = /* @__PURE__ */ new Map();
+  for (const issue of issues) {
+    const group = byTitle.get(issue.title) || [];
+    group.push(issue);
+    byTitle.set(issue.title, group);
+  }
+  for (const [title, groupIssues] of byTitle) {
+    const first = groupIssues[0];
+    if (!first) continue;
+    lines.push(`## ${title}`);
+    lines.push("");
+    lines.push(`Severity: ${first.severity}`);
+    lines.push(`Count: ${groupIssues.length}`);
+    lines.push("");
+    lines.push(`> ${first.recommendation}`);
+    lines.push("");
+    lines.push("URLs:");
+    for (const issue of groupIssues.slice(0, 20)) {
+      lines.push(`- ${issue.url}`);
+    }
+    if (groupIssues.length > 20) {
+      lines.push(`- ... +${groupIssues.length - 20} more`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function splitIntoChunks(issues, category) {
+  const byTitle = /* @__PURE__ */ new Map();
+  for (const issue of issues) {
+    const group = byTitle.get(issue.title) || [];
+    group.push(issue);
+    byTitle.set(issue.title, group);
+  }
+  const chunks = [];
+  let currentChunk = [];
+  let currentLines = 10;
+  for (const [, groupIssues] of byTitle) {
+    const urlCount = Math.min(20, groupIssues.length);
+    const groupLines = 8 + urlCount;
+    if (currentLines + groupLines > MAX_LINES && currentChunk.length > 0) {
+      chunks.push(currentChunk);
+      currentChunk = [];
+      currentLines = 10;
+    }
+    currentChunk.push(...groupIssues);
+    currentLines += groupLines;
+  }
+  if (currentChunk.length > 0) {
+    chunks.push(currentChunk);
+  }
+  return chunks.length > 0 ? chunks : [[]];
+}
+function groupIssuesByCategory(issues) {
+  const result = {};
+  for (const issue of issues) {
+    if (!result[issue.category]) {
+      result[issue.category] = [];
+    }
+    result[issue.category].push(issue);
+  }
+  return result;
+}
+function formatCategory2(category) {
+  return category.split("-").map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join(" ");
+}
+
+// src/reports/claude-context.ts
+function generateClaudeContext(report) {
+  const lines = [];
+  lines.push("# @djangocfg/seo");
+  lines.push("");
+  lines.push("SEO audit toolkit. Generates AI-optimized split reports (max 1000 lines each).");
+  lines.push("");
+  lines.push("## Commands");
+  lines.push("");
+  lines.push("```bash");
+  lines.push("# Audit (HTTP-based, crawls live site)");
+  lines.push("pnpm seo:audit                    # Full audit (split reports)");
+  lines.push("pnpm seo:audit --env dev          # Audit local dev");
+  lines.push("pnpm seo:audit --format all       # All formats");
+  lines.push("");
+  lines.push("# Content (file-based, scans MDX/content/)");
+  lines.push("pnpm exec djangocfg-seo content check    # Check MDX links");
+  lines.push("pnpm exec djangocfg-seo content fix      # Show fixable links");
+  lines.push("pnpm exec djangocfg-seo content fix --fix # Apply fixes");
+  lines.push("pnpm exec djangocfg-seo content sitemap  # Generate sitemap.ts");
+  lines.push("```");
+  lines.push("");
+  lines.push("## Options");
+  lines.push("");
+  lines.push("- `--env, -e` - prod (default) or dev");
+  lines.push("- `--site, -s` - Site URL (overrides env)");
+  lines.push("- `--output, -o` - Output directory");
+  lines.push("- `--format, -f` - split (default), json, markdown, ai-summary, all");
+  lines.push("- `--max-pages` - Max pages (default: 100)");
+  lines.push("- `--service-account` - Google service account JSON path");
+  lines.push("- `--content-dir` - Content directory (default: content/)");
+  lines.push("- `--base-path` - Base URL path for docs (default: /docs)");
+  lines.push("");
+  lines.push("## Reports");
+  lines.push("");
+  lines.push("- `seo-*-index.md` - Summary + links to categories");
+  lines.push("- `seo-*-technical.md` - Broken links, sitemap issues");
+  lines.push("- `seo-*-content.md` - H1, meta, title issues");
+  lines.push("- `seo-*-performance.md` - Load time, TTFB issues");
+  lines.push("- `seo-ai-summary-*.md` - Quick overview");
+  lines.push("");
+  lines.push("## Issue Severity");
+  lines.push("");
+  lines.push("- **critical** - Blocks indexing (fix immediately)");
+  lines.push("- **error** - SEO problems (high priority)");
+  lines.push("- **warning** - Recommendations (medium priority)");
+  lines.push("- **info** - Best practices (low priority)");
+  lines.push("");
+  lines.push("## Issue Categories");
+  lines.push("");
+  lines.push("- **technical** - Broken links, sitemap, robots.txt");
+  lines.push("- **content** - Missing H1, meta description, title");
+  lines.push("- **indexing** - Not indexed, crawl errors from GSC");
+  lines.push("- **performance** - Slow load time (>3s), high TTFB (>800ms)");
+  lines.push("");
+  lines.push("## Routes Scanner");
+  lines.push("");
+  lines.push("Scans Next.js App Router `app/` directory. Handles:");
+  lines.push("- Route groups `(group)` - ignored in URL");
+  lines.push("- Dynamic `[slug]` - shown as `:slug`");
+  lines.push("- Catch-all `[...slug]` - shown as `:...slug`");
+  lines.push("- Parallel `@folder` - skipped");
+  lines.push("- Private `_folder` - skipped");
+  lines.push("");
+  lines.push("## Link Guidelines");
+  lines.push("");
+  lines.push("### Nextra/MDX Projects (content/)");
+  lines.push("");
+  lines.push("For non-index files (e.g., `overview.mdx`):");
+  lines.push("- **Sibling file**: `../sibling` (one level up)");
+  lines.push("- **Other section**: `/docs/full/path` (absolute)");
+  lines.push("- **AVOID**: `./sibling` (browser adds filename to path!)");
+  lines.push("- **AVOID**: `../../deep/path` (hard to maintain)");
+  lines.push("");
+  lines.push("For index files (e.g., `index.mdx`):");
+  lines.push("- **Child file**: `./child` works correctly");
+  lines.push("- **Sibling folder**: `../sibling/` or absolute");
+  lines.push("");
+  lines.push("### Next.js App Router Projects");
+  lines.push("");
+  lines.push("Use declarative routes from `_routes/`:");
+  lines.push("```typescript");
+  lines.push('import { routes } from "@/app/_routes";');
+  lines.push("<Link href={routes.dashboard.machines}>Machines</Link>");
+  lines.push("```");
+  lines.push("");
+  lines.push("Benefits: type-safe, refactor-friendly, centralized.");
+  lines.push("");
+  lines.push("---");
+  lines.push("");
+  lines.push("## Current Audit");
+  lines.push("");
+  lines.push(`Site: ${report.siteUrl}`);
+  lines.push(`Score: ${report.summary.healthScore}/100`);
+  lines.push(`Date: ${report.generatedAt.slice(0, 10)}`);
+  lines.push("");
+  lines.push("### Issues");
+  lines.push("");
+  const { critical = 0, error = 0, warning = 0, info = 0 } = report.summary.issuesBySeverity;
+  if (critical > 0) lines.push(`- Critical: ${critical}`);
+  if (error > 0) lines.push(`- Error: ${error}`);
+  if (warning > 0) lines.push(`- Warning: ${warning}`);
+  if (info > 0) lines.push(`- Info: ${info}`);
+  lines.push("");
+  lines.push("### Top Actions");
+  lines.push("");
+  const topRecs = report.recommendations.slice(0, 5);
+  for (let i = 0; i < topRecs.length; i++) {
+    const rec = topRecs[i];
+    if (!rec) continue;
+    lines.push(`${i + 1}. **${rec.title}** (${rec.affectedUrls.length} URLs)`);
+  }
+  lines.push("");
+  lines.push("### Report Files");
+  lines.push("");
+  lines.push("See split reports in this directory:");
+  lines.push("- `seo-*-index.md` - Start here");
+  lines.push("- `seo-*-technical.md` - Technical issues");
+  lines.push("- `seo-*-content.md` - Content issues");
+  lines.push("- `seo-*-performance.md` - Performance issues");
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/reports/generator.ts
+async function generateAndSaveReports(siteUrl, data, options) {
+  const {
+    outputDir,
+    formats,
+    includeRawData = false,
+    timestamp = true,
+    clearOutputDir = true,
+    maxUrlsPerIssue = 10
+  } = options;
+  if (clearOutputDir && existsSync(outputDir)) {
+    try {
+      const files = readdirSync(outputDir);
+      for (const file of files) {
+        if (file.startsWith("seo-")) {
+          rmSync(join(outputDir, file), { force: true });
+        }
+      }
+    } catch {
+    }
+  }
+  if (!existsSync(outputDir)) {
+    mkdirSync(outputDir, { recursive: true });
+  }
+  const report = generateJsonReport(siteUrl, data, { includeRawData, maxUrlsPerIssue });
+  const result = {
+    report,
+    files: {}
+  };
+  const ts = timestamp ? `-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19)}` : "";
+  const siteName = new URL(siteUrl).hostname.replace(/\./g, "-");
+  if (formats.includes("json")) {
+    const filename = `seo-report-${siteName}${ts}.json`;
+    const filepath = join(outputDir, filename);
+    const content = exportJsonReport(report, true);
+    writeFileSync(filepath, content, "utf-8");
+    result.files.json = filepath;
+    consola2.success(`JSON report saved: ${filepath}`);
+  }
+  if (formats.includes("markdown")) {
+    const filename = `seo-report-${siteName}${ts}.md`;
+    const filepath = join(outputDir, filename);
+    const content = generateMarkdownReport(report, {
+      includeRawIssues: true,
+      includeUrls: true
+    });
+    writeFileSync(filepath, content, "utf-8");
+    result.files.markdown = filepath;
+    consola2.success(`Markdown report saved: ${filepath}`);
+  }
+  if (formats.includes("ai-summary")) {
+    const filename = `seo-ai-summary-${siteName}${ts}.md`;
+    const filepath = join(outputDir, filename);
+    const content = generateAiSummary(report);
+    writeFileSync(filepath, content, "utf-8");
+    result.files.aiSummary = filepath;
+    consola2.success(`AI summary saved: ${filepath}`);
+  }
+  if (formats.includes("split")) {
+    const splitResult = generateSplitReports(report, {
+      outputDir,
+      clearOutputDir: false
+      // Already cleared above
+    });
+    result.files.split = {
+      index: join(outputDir, splitResult.indexFile),
+      categories: splitResult.categoryFiles.map((f) => join(outputDir, f))
+    };
+    consola2.success(`Split reports saved: ${splitResult.totalFiles} files (index + ${splitResult.categoryFiles.length} categories)`);
+  }
+  const claudeContent = generateClaudeContext(report);
+  const claudeFilepath = join(outputDir, "CLAUDE.md");
+  writeFileSync(claudeFilepath, claudeContent, "utf-8");
+  consola2.success(`AI context saved: ${claudeFilepath}`);
+  return result;
+}
+function printReportSummary(report) {
+  consola2.box(
+    `SEO Report: ${report.siteUrl}
+Health Score: ${report.summary.healthScore}/100
+Total URLs: ${report.summary.totalUrls}
+Indexed: ${report.summary.indexedUrls} | Not Indexed: ${report.summary.notIndexedUrls}
+Issues: ${report.issues.length}`
+  );
+  if (report.summary.issuesBySeverity.critical) {
+    consola2.error(`Critical issues: ${report.summary.issuesBySeverity.critical}`);
+  }
+  if (report.summary.issuesBySeverity.error) {
+    consola2.warn(`Errors: ${report.summary.issuesBySeverity.error}`);
+  }
+  if (report.summary.issuesBySeverity.warning) {
+    consola2.info(`Warnings: ${report.summary.issuesBySeverity.warning}`);
+  }
+  consola2.log("");
+  consola2.info("Top recommendations:");
+  for (const rec of report.recommendations.slice(0, 3)) {
+    consola2.log(`  ${rec.priority}. ${rec.title} (${rec.affectedUrls.length} URLs)`);
+  }
+}
+function mergeReports(reports) {
+  if (reports.length === 0) {
+    throw new Error("Cannot merge empty reports array");
+  }
+  const merged = {
+    id: `merged-${Date.now().toString(36)}`,
+    siteUrl: reports.map((r) => r.siteUrl).join(", "),
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    summary: {
+      totalUrls: reports.reduce((sum, r) => sum + r.summary.totalUrls, 0),
+      indexedUrls: reports.reduce((sum, r) => sum + r.summary.indexedUrls, 0),
+      notIndexedUrls: reports.reduce((sum, r) => sum + r.summary.notIndexedUrls, 0),
+      issuesByCategory: {},
+      issuesBySeverity: {},
+      healthScore: Math.round(
+        reports.reduce((sum, r) => sum + r.summary.healthScore, 0) / reports.length
+      )
+    },
+    issues: reports.flatMap((r) => r.issues),
+    urlInspections: reports.flatMap((r) => r.urlInspections),
+    crawlResults: reports.flatMap((r) => r.crawlResults),
+    recommendations: []
+  };
+  for (const report of reports) {
+    for (const [category, count] of Object.entries(report.summary.issuesByCategory)) {
+      const cat = category;
+      merged.summary.issuesByCategory[cat] = (merged.summary.issuesByCategory[cat] || 0) + count;
+    }
+    for (const [severity, count] of Object.entries(report.summary.issuesBySeverity)) {
+      const sev = severity;
+      merged.summary.issuesBySeverity[sev] = (merged.summary.issuesBySeverity[sev] || 0) + count;
+    }
+  }
+  const recMap = /* @__PURE__ */ new Map();
+  for (const report of reports) {
+    for (const rec of report.recommendations) {
+      const key = `${rec.category}:${rec.title}`;
+      if (recMap.has(key)) {
+        const existing = recMap.get(key);
+        existing.affectedUrls.push(...rec.affectedUrls);
+      } else {
+        recMap.set(key, { ...rec, affectedUrls: [...rec.affectedUrls] });
+      }
+    }
+  }
+  merged.recommendations = Array.from(recMap.values()).sort(
+    (a, b) => a.priority - b.priority
+  );
+  return merged;
+}
+
+// src/analyzer.ts
+var SeoAnalyzer = class {
+  config;
+  siteUrl;
+  gscClient;
+  constructor(config) {
+    this.config = config;
+    this.siteUrl = config.siteUrl || config.googleConsole?.siteUrl || "";
+    if (!this.siteUrl) {
+      throw new Error("siteUrl is required");
+    }
+    if (config.googleConsole) {
+      this.gscClient = new GoogleConsoleClient({
+        ...config.googleConsole,
+        siteUrl: this.siteUrl
+      });
+    }
+  }
+  /**
+   * Run full SEO analysis
+   */
+  async analyze(options = {}) {
+    const {
+      includeGoogleConsole = true,
+      includeCrawler = true,
+      includeRobotsTxt = true,
+      includeSitemap = true,
+      crawlerMaxPages = this.config.crawler?.maxPages || 100,
+      crawlerMaxDepth = this.config.crawler?.maxDepth || 3,
+      urlsToInspect
+    } = options;
+    consola2.start(`Starting SEO analysis for ${this.siteUrl}`);
+    const allIssues = [];
+    const allInspections = [];
+    const allCrawlResults = [];
+    if (includeRobotsTxt) {
+      consola2.info("Analyzing robots.txt...");
+      try {
+        const robotsAnalysis = await analyzeRobotsTxt(this.siteUrl);
+        allIssues.push(...robotsAnalysis.issues);
+        consola2.success(`robots.txt: ${robotsAnalysis.exists ? "found" : "not found"}`);
+      } catch (error) {
+        consola2.warn("Failed to analyze robots.txt:", error);
+      }
+    }
+    if (includeSitemap) {
+      consola2.info("Analyzing sitemaps...");
+      try {
+        const sitemapUrl = new URL("/sitemap.xml", this.siteUrl).href;
+        const sitemapAnalyses = await analyzeAllSitemaps(sitemapUrl);
+        let totalUrls = 0;
+        for (const analysis of sitemapAnalyses) {
+          allIssues.push(...analysis.issues);
+          totalUrls += analysis.urls.length;
+        }
+        consola2.success(`Sitemaps: ${sitemapAnalyses.length} found, ${totalUrls} URLs`);
+      } catch (error) {
+        consola2.warn("Failed to analyze sitemaps:", error);
+      }
+    }
+    if (includeCrawler) {
+      consola2.info("Crawling site...");
+      try {
+        const crawler = new SiteCrawler(this.siteUrl, {
+          maxPages: crawlerMaxPages,
+          maxDepth: crawlerMaxDepth,
+          ...this.config.crawler
+        });
+        const crawlResults = await crawler.crawl();
+        const crawlIssues = analyzeCrawlResults(crawlResults);
+        allCrawlResults.push(...crawlResults);
+        allIssues.push(...crawlIssues);
+        consola2.success(`Crawled ${crawlResults.length} pages, found ${crawlIssues.length} issues`);
+      } catch (error) {
+        consola2.error("Failed to crawl site:", error);
+      }
+    }
+    if (includeGoogleConsole && this.gscClient) {
+      consola2.info("Inspecting URLs via Google Search Console...");
+      try {
+        const isAuth = await this.gscClient.verify();
+        if (isAuth) {
+          const urls = urlsToInspect || allCrawlResults.filter((r) => r.statusCode === 200).slice(0, 50).map((r) => r.url);
+          if (urls.length > 0) {
+            const inspections = await this.gscClient.inspectUrls(urls);
+            const gscIssues = analyzeInspectionResults(inspections);
+            allInspections.push(...inspections);
+            allIssues.push(...gscIssues);
+            consola2.success(`Inspected ${inspections.length} URLs, found ${gscIssues.length} issues`);
+          }
+        }
+      } catch (error) {
+        consola2.warn("Google Search Console inspection failed:", error);
+      }
+    }
+    const report = generateJsonReport(
+      this.siteUrl,
+      {
+        issues: allIssues,
+        urlInspections: allInspections,
+        crawlResults: allCrawlResults
+      },
+      { includeRawData: true }
+    );
+    consola2.success(`Analysis complete. Health score: ${report.summary.healthScore}/100`);
+    return {
+      report,
+      issues: allIssues,
+      urlInspections: allInspections,
+      crawlResults: allCrawlResults
+    };
+  }
+  /**
+   * Save report to files
+   */
+  async saveReport(outputDir) {
+    const result = await this.analyze();
+    await generateAndSaveReports(
+      this.siteUrl,
+      {
+        issues: result.issues,
+        urlInspections: result.urlInspections,
+        crawlResults: result.crawlResults
+      },
+      {
+        outputDir: outputDir || this.config.reports?.outputDir || "./seo-reports",
+        formats: this.config.reports?.formats || ["json", "markdown"],
+        includeRawData: true
+      }
+    );
+    printReportSummary(result.report);
+  }
+  /**
+   * Quick health check
+   */
+  async healthCheck() {
+    const result = await this.analyze({
+      includeGoogleConsole: false,
+      crawlerMaxPages: 20,
+      crawlerMaxDepth: 2
+    });
+    return {
+      healthScore: result.report.summary.healthScore,
+      criticalIssues: result.report.summary.issuesBySeverity.critical || 0,
+      errors: result.report.summary.issuesBySeverity.error || 0,
+      warnings: result.report.summary.issuesBySeverity.warning || 0
+    };
+  }
+  /**
+   * Inspect specific URLs
+   */
+  async inspectUrls(urls) {
+    if (!this.gscClient) {
+      throw new Error("Google Console is not configured");
+    }
+    return this.gscClient.inspectUrls(urls);
+  }
+  /**
+   * Get Google Console client
+   */
+  getGoogleConsoleClient() {
+    return this.gscClient;
+  }
+};
+var DEFAULT_SKIP_PATTERN = [
+  "github.com",
+  "twitter.com",
+  "linkedin.com",
+  "x.com",
+  "127.0.0.1",
+  "localhost:[0-9]+",
+  "api\\.localhost",
+  "demo\\.localhost",
+  "cdn-cgi",
+  // Cloudflare email protection
+  "mailto:",
+  // Email links
+  "tel:",
+  // Phone links
+  "javascript:"
+  // JavaScript links
+].join("|");
+function getSiteUrl(options) {
+  if (options.url) {
+    return options.url;
+  }
+  const envUrl = process.env.NEXT_PUBLIC_SITE_URL || process.env.SITE_URL || process.env.BASE_URL;
+  if (envUrl) {
+    return envUrl;
+  }
+  throw new Error(
+    "URL is required. Provide it via options.url or set NEXT_PUBLIC_SITE_URL environment variable."
+  );
+}
+function isExternalUrl(linkUrl, baseUrl) {
+  try {
+    const link = new URL(linkUrl);
+    const base = new URL(baseUrl);
+    return link.hostname !== base.hostname;
+  } catch {
+    return true;
+  }
+}
+async function checkLinks(options) {
+  const url = getSiteUrl(options);
+  const {
+    timeout = 6e4,
+    skipPattern = DEFAULT_SKIP_PATTERN,
+    showOnlyBroken = true,
+    concurrency = 50,
+    outputFile,
+    reportFormat = "text",
+    verbose = true
+  } = options;
+  const startTime = Date.now();
+  if (verbose) {
+    console.log(chalk.cyan(`
+\u{1F50D} Starting link check for: ${chalk.bold(url)}`));
+    console.log(chalk.dim(`   Timeout: ${timeout}ms | Concurrency: ${concurrency}`));
+    console.log("");
+  }
+  const skipRegex = new RegExp(skipPattern);
+  const checkOptions = {
+    path: url,
+    recurse: true,
+    timeout,
+    concurrency,
+    linksToSkip: (link) => {
+      return Promise.resolve(skipRegex.test(link));
+    }
+  };
+  const broken = [];
+  const internalErrors = [];
+  const externalErrors = [];
+  let total = 0;
+  try {
+    const results = await linkinator.check(checkOptions);
+    for (const result2 of results.links) {
+      total++;
+      const status = result2.status || 0;
+      const isExternal = isExternalUrl(result2.url, url);
+      if (status < 200 || status >= 400 || result2.state === "BROKEN") {
+        const statusValue = status || "TIMEOUT";
+        if (statusValue === "TIMEOUT" && isExternal) {
+          continue;
+        }
+        const brokenLink = {
+          url: result2.url,
+          status: statusValue,
+          reason: result2.state === "BROKEN" ? "BROKEN" : void 0,
+          isExternal,
+          sourceUrl: result2.parent
+        };
+        broken.push(brokenLink);
+        if (isExternal) {
+          externalErrors.push(brokenLink);
+        } else {
+          internalErrors.push(brokenLink);
+        }
+      }
+    }
+    const success = internalErrors.length === 0;
+    if (!showOnlyBroken || broken.length > 0) {
+      if (success && externalErrors.length === 0) {
+        console.log(`\u2705 All links are valid!`);
+        console.log(`   Checked ${total} links.`);
+      } else {
+        if (internalErrors.length > 0) {
+          console.log(chalk.red(`\u274C Found ${internalErrors.length} broken internal links:`));
+          for (const { url: linkUrl, status, reason } of internalErrors.slice(0, 20)) {
+            console.log(`   [${status}] ${linkUrl}${reason ? ` (${reason})` : ""}`);
+          }
+          if (internalErrors.length > 20) {
+            console.log(chalk.dim(`   ... and ${internalErrors.length - 20} more`));
+          }
+        }
+        if (externalErrors.length > 0) {
+          console.log("");
+          console.log(chalk.yellow(`\u26A0\uFE0F  Found ${externalErrors.length} broken external links:`));
+          for (const { url: linkUrl, status } of externalErrors.slice(0, 10)) {
+            console.log(`   [${status}] ${linkUrl}`);
+          }
+          if (externalErrors.length > 10) {
+            console.log(chalk.dim(`   ... and ${externalErrors.length - 10} more`));
+          }
+        }
+      }
+    }
+    const duration = Date.now() - startTime;
+    const result = {
+      success,
+      broken: broken.length,
+      total,
+      errors: broken,
+      internalErrors,
+      externalErrors,
+      url,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      duration
+    };
+    if (outputFile) {
+      await saveReport(result, outputFile, reportFormat);
+      console.log(chalk.green(`
+\u{1F4C4} Report saved to: ${chalk.cyan(outputFile)}`));
+    }
+    return result;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    const errorName = error instanceof Error ? error.name : "UnknownError";
+    if (errorMessage.includes("timeout") || errorMessage.includes("TimeoutError") || errorName === "TimeoutError" || errorMessage.includes("aborted")) {
+      console.warn(chalk.yellow(`\u26A0\uFE0F  Some links timed out after ${timeout}ms`));
+      console.warn(chalk.dim(`   This is normal for slow or protected URLs.`));
+      if (total > 0) {
+        console.warn(chalk.dim(`   Checked ${total} links before timeout.`));
+      }
+      if (broken.length > 0) {
+        console.log(chalk.red(`
+\u274C Found ${broken.length} broken links:`));
+        for (const { url: url2, status, reason } of broken) {
+          const statusColor = typeof status === "number" && status >= 500 ? chalk.red : chalk.yellow;
+          console.log(
+            `   ${statusColor(`[${status}]`)} ${chalk.cyan(url2)}${reason ? chalk.dim(` (${reason})`) : ""}`
+          );
+        }
+      }
+    } else {
+      console.error(chalk.red(`\u274C Error checking links: ${errorMessage}`));
+    }
+    const duration = Date.now() - startTime;
+    const result = {
+      success: internalErrors.length === 0 && total > 0,
+      broken: broken.length,
+      total,
+      errors: broken,
+      internalErrors,
+      externalErrors,
+      url,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      duration
+    };
+    if (outputFile) {
+      try {
+        await saveReport(result, outputFile, reportFormat);
+        console.log(chalk.green(`
+\u{1F4C4} Report saved to: ${chalk.cyan(outputFile)}`));
+      } catch (saveError) {
+        console.warn(
+          chalk.yellow(
+            `
+\u26A0\uFE0F  Failed to save report: ${saveError instanceof Error ? saveError.message : String(saveError)}`
+          )
+        );
+      }
+    }
+    return result;
+  }
+}
+function linkResultsToSeoIssues(result) {
+  const issues = [];
+  for (const error of result.internalErrors) {
+    issues.push({
+      id: `broken-internal-link-${hash4(error.url)}`,
+      url: error.url,
+      category: "technical",
+      severity: typeof error.status === "number" && error.status >= 500 ? "critical" : "error",
+      title: `Broken internal link: ${error.status}`,
+      description: `Internal link returned ${error.status} status${error.reason ? ` (${error.reason})` : ""}.`,
+      recommendation: "Fix the internal link. This affects user experience and SEO.",
+      detectedAt: result.timestamp,
+      metadata: {
+        status: error.status,
+        reason: error.reason,
+        sourceUrl: error.sourceUrl || result.url,
+        isExternal: false
+      }
+    });
+  }
+  for (const error of result.externalErrors) {
+    issues.push({
+      id: `broken-external-link-${hash4(error.url)}`,
+      url: error.url,
+      category: "technical",
+      severity: "warning",
+      title: `Broken external link: ${error.status}`,
+      description: `External link returned ${error.status} status.`,
+      recommendation: "Consider removing or updating the external link.",
+      detectedAt: result.timestamp,
+      metadata: {
+        status: error.status,
+        reason: error.reason,
+        sourceUrl: error.sourceUrl || result.url,
+        isExternal: true
+      }
+    });
+  }
+  return issues;
+}
+async function saveReport(result, filePath, format) {
+  const dir = dirname(filePath);
+  if (dir !== ".") {
+    await mkdir(dir, { recursive: true });
+  }
+  let content;
+  switch (format) {
+    case "json":
+      content = JSON.stringify(result, null, 2);
+      break;
+    case "markdown":
+      content = generateMarkdownReport2(result);
+      break;
+    case "text":
+    default:
+      content = generateTextReport(result);
+      break;
+  }
+  await writeFile(filePath, content, "utf-8");
+}
+function generateMarkdownReport2(result) {
+  const lines = [];
+  lines.push("# Link Check Report");
+  lines.push("");
+  lines.push(`**URL:** ${result.url}`);
+  lines.push(`**Timestamp:** ${result.timestamp}`);
+  if (result.duration) {
+    lines.push(`**Duration:** ${(result.duration / 1e3).toFixed(2)}s`);
+  }
+  lines.push("");
+  lines.push(
+    `**Status:** ${result.success ? "\u2705 All links valid" : "\u274C Broken links found"}`
+  );
+  lines.push(`**Total links:** ${result.total}`);
+  lines.push(`**Broken links:** ${result.broken}`);
+  lines.push("");
+  if (result.errors.length > 0) {
+    lines.push("## Broken Links");
+    lines.push("");
+    lines.push("| Status | URL | Reason |");
+    lines.push("|--------|-----|--------|");
+    for (const { url, status, reason } of result.errors) {
+      lines.push(`| ${status} | ${url} | ${reason || "-"} |`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function generateTextReport(result) {
+  const lines = [];
+  lines.push("Link Check Report");
+  lines.push("=".repeat(50));
+  lines.push(`URL: ${result.url}`);
+  lines.push(`Timestamp: ${result.timestamp}`);
+  if (result.duration) {
+    lines.push(`Duration: ${(result.duration / 1e3).toFixed(2)}s`);
+  }
+  lines.push("");
+  lines.push(
+    `Status: ${result.success ? "\u2705 All links valid" : "\u274C Broken links found"}`
+  );
+  lines.push(`Total links: ${result.total}`);
+  lines.push(`Broken links: ${result.broken}`);
+  lines.push("");
+  if (result.errors.length > 0) {
+    lines.push("Broken Links:");
+    lines.push("-".repeat(50));
+    for (const { url, status, reason } of result.errors) {
+      lines.push(`[${status}] ${url}${reason ? ` (${reason})` : ""}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function hash4(str) {
+  let h = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    h = (h << 5) - h + char;
+    h = h & h;
+  }
+  return Math.abs(h).toString(36);
+}
+function loadUrlsFromFile(filePath) {
+  if (!existsSync(filePath)) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+  const content = readFileSync(filePath, "utf-8");
+  return content.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
+}
+function normalizeUrl(url, baseUrl) {
+  try {
+    const parsed = new URL(url, baseUrl);
+    parsed.hash = "";
+    if (parsed.pathname.endsWith("/") && parsed.pathname !== "/") {
+      parsed.pathname = parsed.pathname.slice(0, -1);
+    }
+    return parsed.href;
+  } catch {
+    return url;
+  }
+}
+function isSameDomain(url, baseUrl) {
+  try {
+    const urlHost = new URL(url).hostname;
+    const baseHost = new URL(baseUrl).hostname;
+    return urlHost === baseHost;
+  } catch {
+    return false;
+  }
+}
+function formatBytes(bytes) {
+  if (bytes === 0) return "0 B";
+  const units = ["B", "KB", "MB", "GB"];
+  const k = 1024;
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${units[i]}`;
+}
+function formatDuration(ms) {
+  if (ms < 1e3) return `${ms}ms`;
+  if (ms < 6e4) return `${(ms / 1e3).toFixed(1)}s`;
+  return `${Math.floor(ms / 6e4)}m ${Math.round(ms % 6e4 / 1e3)}s`;
+}
+function chunk(array, size) {
+  const chunks = [];
+  for (let i = 0; i < array.length; i += size) {
+    chunks.push(array.slice(i, i + size));
+  }
+  return chunks;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function retry(fn, options = {}) {
+  const { retries = 3, minTimeout = 1e3, maxTimeout = 3e4, factor = 2 } = options;
+  let lastError;
+  let timeout = minTimeout;
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt < retries) {
+        await sleep(timeout);
+        timeout = Math.min(timeout * factor, maxTimeout);
+      }
+    }
+  }
+  throw lastError;
+}
+function detectProjectType(cwd) {
+  const contentDir = path.join(cwd, "content");
+  const appDir = path.join(cwd, "app");
+  if (fs.existsSync(contentDir)) {
+    if (hasMetaFiles(contentDir)) {
+      return "nextra";
+    }
+  }
+  if (fs.existsSync(appDir)) {
+    return "nextjs";
+  }
+  return "unknown";
+}
+function hasMetaFiles(dir) {
+  if (!fs.existsSync(dir)) return false;
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name === "_meta.ts" || entry.name === "_meta.tsx") {
+      return true;
+    }
+    if (entry.isDirectory() && !entry.name.startsWith(".")) {
+      const subDir = path.join(dir, entry.name);
+      if (hasMetaFiles(subDir)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function scanProject(cwd, config) {
+  const contentDir = path.join(cwd, config?.contentDir || "content");
+  const appDir = path.join(cwd, config?.appDir || "app");
+  const extensions = config?.extensions || [".mdx", ".md"];
+  const hasContent = fs.existsSync(contentDir);
+  const hasApp = fs.existsSync(appDir);
+  const projectType = detectProjectType(cwd);
+  const mdxFiles = hasContent ? getAllFiles(contentDir, extensions) : [];
+  const pageFiles = hasApp ? getPageFiles(appDir) : [];
+  return {
+    projectType,
+    hasContent,
+    hasApp,
+    mdxFiles,
+    pageFiles
+  };
+}
+function getAllFiles(dir, extensions, files = []) {
+  if (!fs.existsSync(dir)) return files;
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (!entry.name.startsWith(".") && entry.name !== "node_modules") {
+        getAllFiles(fullPath, extensions, files);
+      }
+    } else {
+      const ext = path.extname(entry.name).toLowerCase();
+      if (extensions.includes(ext)) {
+        files.push(fullPath);
+      }
+    }
+  }
+  return files;
+}
+function getAllMdxFiles(contentDir) {
+  return getAllFiles(contentDir, [".mdx", ".md"]);
+}
+function getPageFiles(appDir) {
+  const pages = [];
+  function scan(dir) {
+    if (!fs.existsSync(dir)) return;
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name.startsWith("_") || entry.name.startsWith(".")) continue;
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        scan(fullPath);
+      } else if (entry.name === "page.tsx" || entry.name === "page.ts") {
+        pages.push(fullPath);
+      }
+    }
+  }
+  scan(appDir);
+  return pages;
+}
+function getFileInfo(filePath, contentDir) {
+  const relativePath = path.relative(contentDir, filePath);
+  const parsed = path.parse(relativePath);
+  const isIndex = parsed.name === "index";
+  const folder = parsed.dir || "";
+  return {
+    fullPath: filePath,
+    relativePath,
+    isIndex,
+    folder,
+    name: parsed.name
+  };
+}
+function pathExists(docsPath, contentDir) {
+  const cleanPath = docsPath.replace(/\/$/, "").replace(/^\//, "");
+  const candidates = [
+    path.join(contentDir, cleanPath + ".mdx"),
+    path.join(contentDir, cleanPath + ".md"),
+    path.join(contentDir, cleanPath, "index.mdx"),
+    path.join(contentDir, cleanPath, "index.md")
+  ];
+  return candidates.some((p) => fs.existsSync(p));
+}
+var LINK_PATTERNS = [
+  // Absolute links: [text](/docs/path)
+  { regex: /\]\(\/docs\/([^)#\s"]+)/g, type: "absolute" },
+  { regex: /href="\/docs\/([^"#]+)"/g, type: "absolute" },
+  { regex: /to="\/docs\/([^"#]+)"/g, type: "absolute" },
+  // Dot-slash relative: [text](./path)
+  { regex: /\]\(\.\/([^)#\s"]+)(?:#[^)]*)?\)/g, type: "dotslash" },
+  { regex: /href="\.\/([^"#]+)"/g, type: "dotslash" },
+  // Parent relative: [text](../path)
+  { regex: /\]\(\.\.\/([^)#\s"]+)(?:#[^)]*)?\)/g, type: "parent" },
+  { regex: /href="\.\.\/([^"#]+)"/g, type: "parent" },
+  // Simple relative (no prefix): [text](path)
+  { regex: /\]\((?!\/|http|#|\.|\[)([a-zA-Z][^)#\s"]*)(?:#[^)]*)?\)/g, type: "simple" },
+  { regex: /href="(?!\/|http|#|\.)([a-zA-Z][^"#]*)"/g, type: "simple" }
+];
+function isAssetLink(linkPath, assetExtensions) {
+  return assetExtensions.some((ext) => linkPath.toLowerCase().endsWith(ext));
+}
+function resolveLink(fromFilePath, linkPath, linkType, contentDir) {
+  if (linkType === "absolute") {
+    return linkPath;
+  }
+  const { isIndex, folder: sourceFolder, name: fileName } = getFileInfo(fromFilePath, contentDir);
+  const sourceParts = sourceFolder ? sourceFolder.split("/") : [];
+  if (linkType === "dotslash" || linkType === "simple") {
+    if (isIndex) {
+      return sourceFolder ? `${sourceFolder}/${linkPath}` : linkPath;
+    } else {
+      return sourceFolder ? `${sourceFolder}/${fileName}/${linkPath}` : `${fileName}/${linkPath}`;
+    }
+  }
+  if (linkType === "parent") {
+    if (isIndex) {
+      const newParts = [...sourceParts];
+      newParts.pop();
+      return newParts.length ? `${newParts.join("/")}/${linkPath}` : linkPath;
+    } else {
+      return sourceParts.length ? `${sourceParts.join("/")}/${linkPath}` : linkPath;
+    }
+  }
+  return linkPath;
+}
+function extractLinks(filePath, contentDir, assetExtensions) {
+  const content = fs.readFileSync(filePath, "utf-8");
+  const links = [];
+  for (const { regex, type } of LINK_PATTERNS) {
+    regex.lastIndex = 0;
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+      const rawLink = match[1];
+      if (!rawLink) continue;
+      if (isAssetLink(rawLink, assetExtensions)) continue;
+      const resolved = resolveLink(filePath, rawLink, type, contentDir);
+      links.push({
+        raw: rawLink,
+        resolved,
+        type,
+        line: content.substring(0, match.index).split("\n").length
+      });
+    }
+  }
+  return links;
+}
+function checkContentLinks(contentDir, config) {
+  const assetExtensions = config?.assetExtensions || [
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".svg",
+    ".webp",
+    ".ico",
+    ".pdf",
+    ".zip",
+    ".tar",
+    ".gz"
+  ];
+  const basePath = config?.basePath || "/docs";
+  const files = getAllMdxFiles(contentDir);
+  const brokenLinks = [];
+  const checkedLinks = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const links = extractLinks(file, contentDir, assetExtensions);
+    const relativePath = path.relative(contentDir, file);
+    for (const link of links) {
+      if (!checkedLinks.has(link.resolved)) {
+        checkedLinks.set(link.resolved, pathExists(link.resolved, contentDir));
+      }
+      if (!checkedLinks.get(link.resolved)) {
+        brokenLinks.push({
+          file: relativePath,
+          link: `${basePath}/${link.resolved}`,
+          type: link.type,
+          raw: link.raw,
+          line: link.line
+        });
+      }
+    }
+  }
+  return {
+    filesChecked: files.length,
+    uniqueLinks: checkedLinks.size,
+    brokenLinks,
+    success: brokenLinks.length === 0
+  };
+}
+function groupBrokenLinksByFile(brokenLinks) {
+  const byFile = /* @__PURE__ */ new Map();
+  for (const link of brokenLinks) {
+    const existing = byFile.get(link.file) || [];
+    existing.push(link);
+    byFile.set(link.file, existing);
+  }
+  return byFile;
+}
+function isAssetLink2(linkPath, assetExtensions) {
+  return assetExtensions.some((ext) => linkPath.toLowerCase().endsWith(ext));
+}
+function calculateRelativePath(sourceFile, targetDocsPath, contentDir) {
+  const { isIndex, folder: sourceFolder } = getFileInfo(sourceFile, contentDir);
+  const targetPath = targetDocsPath.replace(/^\//, "");
+  const sourceParts = sourceFolder ? sourceFolder.split("/") : [];
+  const targetParts = targetPath.split("/");
+  let commonLength = 0;
+  for (let i = 0; i < Math.min(sourceParts.length, targetParts.length); i++) {
+    if (sourceParts[i] === targetParts[i]) {
+      commonLength++;
+    } else {
+      break;
+    }
+  }
+  if (isIndex) {
+    if (targetPath.startsWith(sourceFolder + "/") || sourceFolder === "") {
+      const relative2 = sourceFolder ? targetPath.slice(sourceFolder.length + 1) : targetPath;
+      return "./" + relative2;
+    }
+    const upsNeeded = sourceParts.length - commonLength;
+    const downs = targetParts.slice(commonLength);
+    if (upsNeeded <= 1) {
+      return "../".repeat(upsNeeded) + downs.join("/");
+    }
+    return null;
+  } else {
+    if (targetPath.startsWith(sourceFolder + "/") || sourceFolder === "") {
+      const relative2 = sourceFolder ? targetPath.slice(sourceFolder.length + 1) : targetPath;
+      if (!relative2.includes("/")) {
+        return "../" + relative2;
+      }
+      return "../" + relative2;
+    }
+    const upsNeeded = sourceParts.length - commonLength + 1;
+    const downs = targetParts.slice(commonLength);
+    if (upsNeeded <= 2) {
+      return "../".repeat(upsNeeded) + downs.join("/");
+    }
+    return null;
+  }
+}
+function processFile(filePath, contentDir, assetExtensions) {
+  const content = fs.readFileSync(filePath, "utf-8");
+  const fixes = [];
+  const patterns = [
+    { regex: /(\]\()\/docs\/([^)#\s"]+)(\))/g },
+    { regex: /(href=")\/docs\/([^"#]+)(")/g }
+  ];
+  for (const { regex } of patterns) {
+    regex.lastIndex = 0;
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+      const targetPath = match[2];
+      if (!targetPath) continue;
+      if (isAssetLink2(targetPath, assetExtensions)) continue;
+      if (!pathExists(targetPath, contentDir)) continue;
+      const relativePath = calculateRelativePath(filePath, targetPath, contentDir);
+      if (relativePath) {
+        fixes.push({
+          from: `/docs/${targetPath}`,
+          to: relativePath,
+          line: content.substring(0, match.index).split("\n").length
+        });
+      }
+    }
+  }
+  return fixes;
+}
+function applyFixes(filePath, fixes) {
+  let content = fs.readFileSync(filePath, "utf-8");
+  for (const { from, to } of fixes) {
+    content = content.split(from).join(to);
+  }
+  fs.writeFileSync(filePath, content, "utf-8");
+}
+function fixContentLinks(contentDir, options = {}) {
+  const { apply = false, config } = options;
+  const assetExtensions = config?.assetExtensions || [
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".svg",
+    ".webp",
+    ".ico",
+    ".pdf"
+  ];
+  const files = getAllMdxFiles(contentDir);
+  let totalChanges = 0;
+  const fileChanges = [];
+  for (const file of files) {
+    const fixes = processFile(file, contentDir, assetExtensions);
+    if (fixes.length > 0) {
+      const relativePath = path.relative(contentDir, file);
+      fileChanges.push({
+        file: relativePath,
+        fullPath: file,
+        fixes
+      });
+      totalChanges += fixes.length;
+      if (apply) {
+        applyFixes(file, fixes);
+      }
+    }
+  }
+  return {
+    totalChanges,
+    fileChanges,
+    applied: apply
+  };
+}
+var PAGE_FILES = ["page.tsx", "page.ts", "page.jsx", "page.js"];
+var ROUTE_FILES = ["route.tsx", "route.ts", "route.jsx", "route.js"];
+var SPECIAL_FILES = ["layout", "loading", "error", "not-found", "template"];
+function findAppDir(startDir = process.cwd()) {
+  const candidates = [
+    join(startDir, "app"),
+    join(startDir, "src", "app")
+  ];
+  for (const dir of candidates) {
+    if (existsSync(dir) && statSync(dir).isDirectory()) {
+      return dir;
+    }
+  }
+  return null;
+}
+function scanRoutes(options = {}) {
+  const {
+    appDir = findAppDir() || "./app",
+    includeApi = true,
+    includeSpecial = false
+  } = options;
+  if (!existsSync(appDir)) {
+    throw new Error(`App directory not found: ${appDir}`);
+  }
+  const routes = [];
+  scanDirectory(appDir, "", routes, { includeApi, includeSpecial });
+  return {
+    routes,
+    staticRoutes: routes.filter((r) => !r.isDynamic && r.type === "page"),
+    dynamicRoutes: routes.filter((r) => r.isDynamic && r.type === "page"),
+    apiRoutes: routes.filter((r) => r.type === "api"),
+    appDir
+  };
+}
+function scanDirectory(dir, routePath, routes, options) {
+  let entries;
+  try {
+    entries = readdirSync(dir);
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const fullPath = join(dir, entry);
+    let stat;
+    try {
+      stat = statSync(fullPath);
+    } catch {
+      continue;
+    }
+    if (stat.isDirectory()) {
+      if (entry.startsWith("_") || entry.startsWith(".")) continue;
+      if (entry.startsWith("(") && entry.endsWith(")")) {
+        scanDirectory(fullPath, routePath, routes, options);
+        continue;
+      }
+      if (entry.startsWith("@")) {
+        scanDirectory(fullPath, routePath, routes, options);
+        continue;
+      }
+      if (entry.startsWith("(") && !entry.endsWith(")")) {
+        continue;
+      }
+      const segment = processSegment(entry);
+      const newRoutePath = routePath + "/" + segment.urlSegment;
+      scanDirectory(fullPath, newRoutePath, routes, options);
+    } else if (stat.isFile()) {
+      if (PAGE_FILES.includes(entry)) {
+        const route = createRouteInfo(routePath || "/", dir, "page");
+        routes.push(route);
+      }
+      if (options.includeApi && ROUTE_FILES.includes(entry)) {
+        const route = createRouteInfo(routePath || "/", dir, "api");
+        routes.push(route);
+      }
+      if (options.includeSpecial) {
+        const baseName = entry.replace(/\.(tsx?|jsx?|js)$/, "");
+        if (SPECIAL_FILES.includes(baseName)) {
+          const route = createRouteInfo(routePath || "/", dir, baseName);
+          routes.push(route);
+        }
+      }
+    }
+  }
+}
+function processSegment(segment) {
+  if (segment.startsWith("[[...") && segment.endsWith("]]")) {
+    const paramName = segment.slice(5, -2);
+    return {
+      urlSegment: segment,
+      isDynamic: true,
+      paramName,
+      isCatchAll: true,
+      isOptionalCatchAll: true
+    };
+  }
+  if (segment.startsWith("[...") && segment.endsWith("]")) {
+    const paramName = segment.slice(4, -1);
+    return {
+      urlSegment: segment,
+      isDynamic: true,
+      paramName,
+      isCatchAll: true,
+      isOptionalCatchAll: false
+    };
+  }
+  if (segment.startsWith("[") && segment.endsWith("]")) {
+    const paramName = segment.slice(1, -1);
+    return {
+      urlSegment: segment,
+      isDynamic: true,
+      paramName,
+      isCatchAll: false,
+      isOptionalCatchAll: false
+    };
+  }
+  return {
+    urlSegment: segment,
+    isDynamic: false,
+    isCatchAll: false,
+    isOptionalCatchAll: false
+  };
+}
+function createRouteInfo(path5, filePath, type) {
+  const segments = path5.split("/").filter(Boolean);
+  const dynamicSegments = [];
+  let isDynamic = false;
+  let isCatchAll = false;
+  let isOptionalCatchAll = false;
+  for (const segment of segments) {
+    const info = processSegment(segment);
+    if (info.isDynamic) {
+      isDynamic = true;
+      if (info.paramName) {
+        dynamicSegments.push(info.paramName);
+      }
+      if (info.isCatchAll) isCatchAll = true;
+      if (info.isOptionalCatchAll) isOptionalCatchAll = true;
+    }
+  }
+  let routeGroup;
+  const groupMatch = filePath.match(/\(([^)]+)\)/);
+  if (groupMatch) {
+    routeGroup = groupMatch[1];
+  }
+  return {
+    path: path5 || "/",
+    filePath,
+    type,
+    isDynamic,
+    dynamicSegments,
+    isCatchAll,
+    isOptionalCatchAll,
+    routeGroup
+  };
+}
+function routeToUrl(route, params) {
+  let url = route.path;
+  for (const segment of route.dynamicSegments) {
+    const value = params?.[segment] || `{${segment}}`;
+    if (route.isOptionalCatchAll) {
+      url = url.replace(`[[...${segment}]]`, value);
+    } else if (route.isCatchAll) {
+      url = url.replace(`[...${segment}]`, value);
+    } else {
+      url = url.replace(`[${segment}]`, value);
+    }
+  }
+  return url;
+}
+function getStaticUrls(scanResult, baseUrl) {
+  return scanResult.staticRoutes.map((route) => {
+    const url = new URL(route.path, baseUrl);
+    return url.href;
+  });
+}
+
+// src/content/sitemap-generator.ts
+async function getMeta(dir) {
+  const metaPath = path.join(dir, "_meta.ts");
+  if (!fs.existsSync(metaPath)) return {};
+  try {
+    const meta = await import(metaPath);
+    return meta.default || {};
+  } catch {
+    try {
+      const content = fs.readFileSync(metaPath, "utf-8");
+      const matches = content.matchAll(/'([^']+)':\s*['"]([^'"]+)['"]/g);
+      const result = {};
+      for (const match of matches) {
+        const key = match[1];
+        const value = match[2];
+        if (key && value) {
+          result[key] = value;
+        }
+      }
+      return result;
+    } catch {
+      return {};
+    }
+  }
+}
+function getTitleFromMeta(key, meta) {
+  const value = meta[key];
+  if (!value) return key;
+  if (typeof value === "string") return value;
+  if (typeof value === "object" && value !== null && "title" in value) {
+    return String(value.title);
+  }
+  return key;
+}
+async function scanContent(dir, baseUrl = "/docs") {
+  const items = [];
+  if (!fs.existsSync(dir)) return items;
+  const meta = await getMeta(dir);
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  const fileMap = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const key = entry.name.replace(/\.mdx?$/, "");
+    fileMap.set(key, entry);
+  }
+  const metaKeys = Object.keys(meta);
+  for (const key of metaKeys) {
+    const entry = fileMap.get(key);
+    if (!entry) continue;
+    fileMap.delete(key);
+    const fullPath = path.join(dir, entry.name);
+    const itemPath = path.join(baseUrl, key).replace(/\\/g, "/");
+    if (entry.isDirectory()) {
+      const children = await scanContent(fullPath, itemPath);
+      items.push({
+        title: getTitleFromMeta(key, meta),
+        path: itemPath,
+        children: children.length > 0 ? children : void 0
+      });
+    } else if (entry.isFile() && (entry.name.endsWith(".md") || entry.name.endsWith(".mdx"))) {
+      if (entry.name !== "index.mdx" && entry.name !== "index.md") {
+        items.push({
+          title: getTitleFromMeta(key, meta),
+          path: itemPath
+        });
+      }
+    }
+  }
+  for (const [key, entry] of fileMap.entries()) {
+    if (key.startsWith("_") || key.startsWith(".")) continue;
+    const fullPath = path.join(dir, entry.name);
+    const itemPath = path.join(baseUrl, key).replace(/\\/g, "/");
+    if (entry.isDirectory()) {
+      const children = await scanContent(fullPath, itemPath);
+      items.push({
+        title: key,
+        path: itemPath,
+        children: children.length > 0 ? children : void 0
+      });
+    } else if (entry.isFile() && (entry.name.endsWith(".md") || entry.name.endsWith(".mdx"))) {
+      if (entry.name !== "index.mdx" && entry.name !== "index.md") {
+        items.push({
+          title: key,
+          path: itemPath
+        });
+      }
+    }
+  }
+  return items;
+}
+function routeToTitle(routePath) {
+  const segment = routePath.split("/").filter(Boolean).pop() || "Home";
+  if (segment.startsWith("[")) return segment;
+  return segment.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+function routesToSitemapItems(routes) {
+  const root = /* @__PURE__ */ new Map();
+  const items = [];
+  const sortedRoutes = [...routes].filter((r) => r.type === "page" && !r.isDynamic).sort((a, b) => a.path.split("/").length - b.path.split("/").length);
+  for (const route of sortedRoutes) {
+    const segments = route.path.split("/").filter(Boolean);
+    if (segments.length === 0) {
+      items.push({
+        title: "Home",
+        path: "/"
+      });
+      continue;
+    }
+    let currentPath = "";
+    let parentChildren = items;
+    for (let i = 0; i < segments.length - 1; i++) {
+      currentPath += "/" + segments[i];
+      let parent = root.get(currentPath);
+      if (!parent) {
+        parent = {
+          title: routeToTitle(currentPath),
+          path: currentPath,
+          children: []
+        };
+        root.set(currentPath, parent);
+        parentChildren.push(parent);
+      }
+      parentChildren = parent.children || (parent.children = []);
+    }
+    const item = {
+      title: routeToTitle(route.path),
+      path: route.path
+    };
+    parentChildren.push(item);
+  }
+  return items;
+}
+async function generateSitemapData(cwd, config) {
+  const projectType = detectProjectType(cwd);
+  const contentDir = path.join(cwd, config?.contentDir || "content");
+  const appDir = path.join(cwd, config?.appDir || "app");
+  const basePath = config?.basePath || "/docs";
+  let docsItems = [];
+  let appItems = [];
+  if (projectType === "nextra" && fs.existsSync(contentDir)) {
+    docsItems = await scanContent(contentDir, basePath);
+  }
+  if (fs.existsSync(appDir)) {
+    try {
+      const scanResult = scanRoutes({ appDir, includeApi: false });
+      appItems = routesToSitemapItems(scanResult.routes);
+    } catch {
+      appItems = [];
+    }
+  }
+  return {
+    app: appItems,
+    docs: docsItems
+  };
+}
+function generateTsContent(data) {
+  return `
+// This file is auto-generated by @djangocfg/seo
+// Do not edit manually
+
+export interface SitemapItem {
+  title: string;
+  path: string;
+  children?: SitemapItem[];
+}
+
+export const sitemap: { app: SitemapItem[], docs: SitemapItem[] } = ${JSON.stringify(data, null, 2)};
+`;
+}
+async function generateSitemap(cwd, options = {}) {
+  const output = options.output || "app/_core/sitemap.ts";
+  const outputPath = path.join(cwd, output);
+  const data = await generateSitemapData(cwd, options.config);
+  const outputDir = path.dirname(outputPath);
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+  const content = generateTsContent(data);
+  fs.writeFileSync(outputPath, content);
+  return { outputPath, data };
+}
+function flattenSitemap(items) {
+  const paths = [];
+  function traverse(item) {
+    paths.push(item.path);
+    if (item.children) {
+      for (const child of item.children) {
+        traverse(child);
+      }
+    }
+  }
+  for (const item of items) {
+    traverse(item);
+  }
+  return paths;
+}
+function countSitemapItems(data) {
+  const appPaths = flattenSitemap(data.app);
+  const docsPaths = flattenSitemap(data.docs);
+  return {
+    app: appPaths.length,
+    docs: docsPaths.length,
+    total: appPaths.length + docsPaths.length
+  };
+}
+
+export { AI_REPORT_SCHEMA, GoogleConsoleClient, SeoAnalyzer, SiteCrawler, analyzeAllSitemaps, analyzeCrawlResults, analyzeInspectionResults, analyzeRobotsTxt, analyzeSitemap, checkContentLinks, checkLinks, chunk, countSitemapItems, createAuthClient, detectProjectType, findAppDir, fixContentLinks, flattenSitemap, formatBytes, formatDuration, generateAiSummary, generateAndSaveReports, generateJsonReport, generateMarkdownReport, generateSitemap, generateSitemapData, getStaticUrls, groupBrokenLinksByFile, isSameDomain, isUrlAllowed, linkResultsToSeoIssues, loadUrlsFromFile, mergeReports, normalizeUrl, printReportSummary, retry, routeToUrl, scanProject, scanRoutes, sleep, verifyAuth };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map