@djangocfg/seo 2.1.50

package/dist/cli.mjs

@@ -0,0 +1,3780 @@
+#!/usr/bin/env node
+import { parseArgs } from 'util';
+import consola3 from 'consola';
+import chalk2 from 'chalk';
+import fs4, { existsSync, readFileSync, readdirSync, rmSync, mkdirSync, writeFileSync, statSync } from 'fs';
+import path, { resolve, join, dirname } from 'path';
+import { searchconsole } from '@googleapis/searchconsole';
+import pLimit from 'p-limit';
+import pRetry from 'p-retry';
+import { JWT } from 'google-auth-library';
+import { load } from 'cheerio';
+import robotsParser from 'robots-parser';
+import { mkdir, writeFile } from 'fs/promises';
+import * as linkinator from 'linkinator';
+
+var config = {
+  env: {
+    prod: void 0,
+    dev: void 0
+  },
+  cwd: process.cwd()
+};
+function parseEnvFile(filePath) {
+  const content = readFileSync(filePath, "utf-8");
+  const vars = {};
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eqIndex = trimmed.indexOf("=");
+    if (eqIndex === -1) continue;
+    const key = trimmed.slice(0, eqIndex).trim();
+    let value = trimmed.slice(eqIndex + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    vars[key] = value;
+  }
+  return vars;
+}
+function loadEnvFiles(cwd) {
+  const workDir = process.cwd();
+  config.cwd = workDir;
+  const prodEnvPath = resolve(workDir, ".env.production");
+  if (existsSync(prodEnvPath)) {
+    const vars = parseEnvFile(prodEnvPath);
+    config.env.prod = vars.NEXT_PUBLIC_SITE_URL || vars.SITE_URL;
+  }
+  const devEnvPath = resolve(workDir, ".env.development");
+  if (existsSync(devEnvPath)) {
+    const vars = parseEnvFile(devEnvPath);
+    config.env.dev = vars.NEXT_PUBLIC_SITE_URL || vars.SITE_URL;
+  }
+  if (!config.env.prod && !config.env.dev) {
+    for (const envFile of [".env.local", ".env"]) {
+      const envPath = resolve(workDir, envFile);
+      if (existsSync(envPath)) {
+        const vars = parseEnvFile(envPath);
+        const url = vars.NEXT_PUBLIC_SITE_URL || vars.SITE_URL;
+        if (url) {
+          config.env.prod = url;
+          break;
+        }
+      }
+    }
+  }
+  return config.env;
+}
+function getSiteUrl(options) {
+  if (options.site) {
+    return options.site;
+  }
+  const env = options.env || "prod";
+  const isProd = env === "prod" || env === "production";
+  const url = isProd ? config.env.prod : config.env.dev;
+  if (url) {
+    const envLabel = isProd ? "production" : "development";
+    consola3.info(`Using ${chalk2.cyan(envLabel)} URL: ${chalk2.bold(url)}`);
+    return url;
+  }
+  const fallbackUrl = process.env.NEXT_PUBLIC_SITE_URL || process.env.SITE_URL || process.env.BASE_URL;
+  if (fallbackUrl) {
+    consola3.info(`Using URL from environment: ${fallbackUrl}`);
+    return fallbackUrl;
+  }
+  console.log("");
+  consola3.error("No site URL found!");
+  console.log("");
+  if (config.env.prod || config.env.dev) {
+    consola3.info("Available environments:");
+    if (config.env.prod) consola3.log(`  ${chalk2.green("prod")}: ${config.env.prod}`);
+    if (config.env.dev) consola3.log(`  ${chalk2.yellow("dev")}:  ${config.env.dev}`);
+    console.log("");
+    consola3.info(`Use ${chalk2.cyan("--env prod")} or ${chalk2.cyan("--env dev")} to select`);
+  } else {
+    consola3.info("Create .env.production or .env.development with NEXT_PUBLIC_SITE_URL");
+    consola3.info("Or use --site https://example.com");
+  }
+  process.exit(1);
+}
+var GSC_KEY_FILENAME = "gsc-key.json";
+function findGoogleServiceAccount(explicitPath) {
+  if (explicitPath) {
+    const resolved = resolve(config.cwd, explicitPath);
+    if (existsSync(resolved)) {
+      return resolved;
+    }
+    consola3.warn(`Service account file not found: ${explicitPath}`);
+    return void 0;
+  }
+  const defaultPath = resolve(config.cwd, GSC_KEY_FILENAME);
+  if (existsSync(defaultPath)) {
+    consola3.info(`Found Google service account: ${chalk2.cyan(GSC_KEY_FILENAME)}`);
+    return defaultPath;
+  }
+  return void 0;
+}
+function getGscKeyFilename() {
+  return GSC_KEY_FILENAME;
+}
+var SCOPES = [
+  "https://www.googleapis.com/auth/webmasters.readonly",
+  "https://www.googleapis.com/auth/webmasters"
+];
+function loadCredentials(config2) {
+  if (config2.serviceAccountJson) {
+    return config2.serviceAccountJson;
+  }
+  if (config2.serviceAccountPath) {
+    if (!existsSync(config2.serviceAccountPath)) {
+      throw new Error(`Service account file not found: ${config2.serviceAccountPath}`);
+    }
+    const content = readFileSync(config2.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(config2) {
+  const credentials = loadCredentials(config2);
+  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();
+    consola3.success("Google Search Console authentication verified");
+    consola3.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}`;
+      consola3.info(`Ensure this email has Full access in GSC: ${gscUrl}`);
+    }
+    return true;
+  } catch (error) {
+    consola3.error("Authentication failed");
+    consola3.info(`Service account email: ${email}`);
+    consola3.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(config2) {
+    this.auth = createAuthClient(config2);
+    this.searchconsole = searchconsole({ version: "v1", auth: this.auth });
+    this.siteUrl = config2.siteUrl;
+    if (config2.gscSiteUrl) {
+      this.gscSiteUrl = config2.gscSiteUrl;
+    } else {
+      const domain = new URL(config2.siteUrl).hostname;
+      this.gscSiteUrl = `sc-domain:${domain}`;
+    }
+    consola3.debug(`GSC site URL: ${this.gscSiteUrl}`);
+  }
+  /**
+   * Delay helper for rate limiting
+   */
+  delay(ms) {
+    return new Promise((resolve2) => setTimeout(resolve2, 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) {
+      consola3.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) {
+              consola3.warn(`Failed: ${url}`);
+            }
+          }
+        }
+      );
+    });
+  }
+  /**
+   * Inspect multiple URLs in batch
+   * Stops early if too many consecutive errors (likely rate limiting)
+   */
+  async inspectUrls(urls) {
+    consola3.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("");
+          consola3.error(`Stopping after ${maxConsecutiveErrors} consecutive failures`);
+          this.showRateLimitHelp();
+          break;
+        }
+      }
+    }
+    if (errors.length > 0 && consecutiveErrors < maxConsecutiveErrors) {
+      consola3.warn(`Failed to inspect ${errors.length} URLs`);
+    }
+    if (results.length > 0) {
+      consola3.success(`Successfully inspected ${results.length}/${urls.length} URLs`);
+    } else if (errors.length > 0) {
+      consola3.warn("No URLs were successfully inspected");
+    }
+    return results;
+  }
+  /**
+   * Show help message for rate limiting issues
+   */
+  showRateLimitHelp() {
+    consola3.info("Possible causes:");
+    consola3.info("  1. Google API quota exceeded (2000 requests/day)");
+    consola3.info("  2. Cloudflare blocking Google's crawler");
+    consola3.info("  3. Service account not added to GSC");
+    console.log("");
+    consola3.info("Solutions:");
+    consola3.info("  \u2022 Check GSC access: https://search.google.com/search-console/users");
+    console.log("");
+    consola3.info("  \u2022 Cloudflare WAF rule to allow Googlebot:");
+    consola3.info("    1. Dashboard \u2192 Security \u2192 WAF \u2192 Custom rules \u2192 Create rule");
+    consola3.info('    2. Name: "Allow Googlebot"');
+    consola3.info('    3. Field: "Known Bots" | Operator: "equals" | Value: "true"');
+    consola3.info('    4. Or click "Edit expression" and paste: (cf.client.bot)');
+    consola3.info("    5. Action: Skip \u2192 check all rules");
+    consola3.info("    6. Deploy");
+    consola3.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) {
+      consola3.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) {
+      consola3.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, config2) {
+    this.config = { ...DEFAULT_CONFIG, ...config2 };
+    this.baseUrl = new URL(siteUrl);
+    this.limit = pLimit(this.config.concurrency);
+  }
+  /**
+   * Start crawling the site
+   */
+  async crawl() {
+    consola3.info(`Starting crawl of ${this.baseUrl.origin}`);
+    consola3.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);
+    }
+    consola3.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);
+    consola3.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 path6 = line.trim().replace(/disallow:/i, "").trim();
+        if (path6) {
+          analysis.disallowedPaths.push(path6);
+        }
+      } else if (trimmed.startsWith("allow:")) {
+        const path6 = line.trim().replace(/allow:/i, "").trim();
+        if (path6) {
+          analysis.allowedPaths.push(path6);
+        }
+      } 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 path6 of importantPaths) {
+      if (!robots.isAllowed(new URL(path6, siteUrl).href, "Googlebot")) {
+        analysis.issues.push({
+          id: `blocked-important-path-${path6.replace(/\//g, "-")}`,
+          url: siteUrl,
+          category: "crawling",
+          severity: "error",
+          title: `Important path blocked: ${path6}`,
+          description: `The path ${path6} is blocked in robots.txt.`,
+          recommendation: `Ensure ${path6} is accessible to search engines.`,
+          detectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          metadata: { path: path6 }
+        });
+      }
+    }
+    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()
+      });
+    }
+    consola3.debug(`Analyzed robots.txt: ${analysis.disallowedPaths.length} disallow rules`);
+  } catch (error) {
+    consola3.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 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);
+        }
+      });
+      consola3.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;
+      }
+      consola3.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) {
+    consola3.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);
+}
+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 getSiteUrl2(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 = getSiteUrl2(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(chalk2.cyan(`
+\u{1F50D} Starting link check for: ${chalk2.bold(url)}`));
+    console.log(chalk2.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(chalk2.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(chalk2.dim(`   ... and ${internalErrors.length - 20} more`));
+          }
+        }
+        if (externalErrors.length > 0) {
+          console.log("");
+          console.log(chalk2.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(chalk2.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(chalk2.green(`
+\u{1F4C4} Report saved to: ${chalk2.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(chalk2.yellow(`\u26A0\uFE0F  Some links timed out after ${timeout}ms`));
+      console.warn(chalk2.dim(`   This is normal for slow or protected URLs.`));
+      if (total > 0) {
+        console.warn(chalk2.dim(`   Checked ${total} links before timeout.`));
+      }
+      if (broken.length > 0) {
+        console.log(chalk2.red(`
+\u274C Found ${broken.length} broken links:`));
+        for (const { url: url2, status, reason } of broken) {
+          const statusColor = typeof status === "number" && status >= 500 ? chalk2.red : chalk2.yellow;
+          console.log(
+            `   ${statusColor(`[${status}]`)} ${chalk2.cyan(url2)}${reason ? chalk2.dim(` (${reason})`) : ""}`
+          );
+        }
+      }
+    } else {
+      console.error(chalk2.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(chalk2.green(`
+\u{1F4C4} Report saved to: ${chalk2.cyan(outputFile)}`));
+      } catch (saveError) {
+        console.warn(
+          chalk2.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 = generateMarkdownReport(result);
+      break;
+    case "text":
+    default:
+      content = generateTextReport(result);
+      break;
+  }
+  await writeFile(filePath, content, "utf-8");
+}
+function generateMarkdownReport(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);
+}
+
+// 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);
+}
+
+// src/reports/markdown-report.ts
+function generateMarkdownReport2(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 chunk = chunks[i];
+      if (!chunk) continue;
+      const content = generateCategoryFile(report.siteUrl, category, chunk, {
+        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;
+    consola3.success(`JSON report saved: ${filepath}`);
+  }
+  if (formats.includes("markdown")) {
+    const filename = `seo-report-${siteName}${ts}.md`;
+    const filepath = join(outputDir, filename);
+    const content = generateMarkdownReport2(report, {
+      includeRawIssues: true,
+      includeUrls: true
+    });
+    writeFileSync(filepath, content, "utf-8");
+    result.files.markdown = filepath;
+    consola3.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;
+    consola3.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))
+    };
+    consola3.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");
+  consola3.success(`AI context saved: ${claudeFilepath}`);
+  return result;
+}
+function printReportSummary(report) {
+  consola3.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) {
+    consola3.error(`Critical issues: ${report.summary.issuesBySeverity.critical}`);
+  }
+  if (report.summary.issuesBySeverity.error) {
+    consola3.warn(`Errors: ${report.summary.issuesBySeverity.error}`);
+  }
+  if (report.summary.issuesBySeverity.warning) {
+    consola3.info(`Warnings: ${report.summary.issuesBySeverity.warning}`);
+  }
+  consola3.log("");
+  consola3.info("Top recommendations:");
+  for (const rec of report.recommendations.slice(0, 3)) {
+    consola3.log(`  ${rec.priority}. ${rec.title} (${rec.affectedUrls.length} URLs)`);
+  }
+}
+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(path6, filePath, type) {
+  const segments = path6.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: path6 || "/",
+    filePath,
+    type,
+    isDynamic,
+    dynamicSegments,
+    isCatchAll,
+    isOptionalCatchAll,
+    routeGroup
+  };
+}
+function compareWithSitemap(scanResult, sitemapUrls, baseUrl) {
+  const appRoutes = scanResult.routes.filter((r) => r.type === "page");
+  const sitemapPaths = new Set(
+    sitemapUrls.map((url) => {
+      try {
+        return new URL(url).pathname;
+      } catch {
+        return url;
+      }
+    })
+  );
+  const missingFromSitemap = [];
+  const matching = [];
+  for (const route of scanResult.staticRoutes) {
+    const path6 = route.path === "/" ? "/" : route.path;
+    if (sitemapPaths.has(path6) || sitemapPaths.has(path6 + "/") || sitemapPaths.has(path6.replace(/\/$/, ""))) {
+      matching.push(route);
+    } else {
+      missingFromSitemap.push(route);
+    }
+  }
+  const staticPaths = new Set(scanResult.staticRoutes.map((r) => r.path));
+  const dynamicPatterns = scanResult.dynamicRoutes.map((r) => routeToRegex(r.path));
+  const extraInSitemap = [];
+  for (const path6 of sitemapPaths) {
+    if (staticPaths.has(path6) || staticPaths.has(path6 + "/") || staticPaths.has(path6.replace(/\/$/, ""))) {
+      continue;
+    }
+    const matchesDynamic = dynamicPatterns.some((regex) => regex.test(path6));
+    if (matchesDynamic) continue;
+    extraInSitemap.push(path6);
+  }
+  return {
+    appRoutes,
+    sitemapUrls,
+    missingFromSitemap,
+    extraInSitemap,
+    matching
+  };
+}
+function routeToRegex(routePath) {
+  let pattern = routePath.replace(/[.+?^${}()|\\]/g, "\\$&").replace(/\[\[\.\.\.([^\]]+)\]\]/g, "(?:/.*)?").replace(/\[\.\.\.([^\]]+)\]/g, "/.+").replace(/\[([^\]]+)\]/g, "/[^/]+");
+  pattern = `^${pattern}/?$`;
+  return new RegExp(pattern);
+}
+async function verifyRoutes(scanResult, options) {
+  const {
+    baseUrl,
+    timeout = 1e4,
+    concurrency = 5,
+    staticOnly = true
+  } = options;
+  const routes = staticOnly ? scanResult.staticRoutes : scanResult.routes.filter((r) => r.type === "page");
+  const limit = pLimit(concurrency);
+  const results = await Promise.all(
+    routes.map(
+      (route) => limit(async () => {
+        const url = new URL(route.path, baseUrl).href;
+        const startTime = Date.now();
+        try {
+          const controller = new AbortController();
+          const timeoutId = setTimeout(() => controller.abort(), timeout);
+          const response = await fetch(url, {
+            method: "HEAD",
+            signal: controller.signal,
+            redirect: "follow"
+          });
+          clearTimeout(timeoutId);
+          return {
+            route,
+            url,
+            statusCode: response.status,
+            isAccessible: response.status >= 200 && response.status < 400,
+            responseTime: Date.now() - startTime
+          };
+        } catch (error) {
+          return {
+            route,
+            url,
+            statusCode: 0,
+            isAccessible: false,
+            error: error.message,
+            responseTime: Date.now() - startTime
+          };
+        }
+      })
+    )
+  );
+  return results;
+}
+function analyzeRoutes(scanResult, comparison, verification) {
+  const issues = [];
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  if (comparison && comparison.missingFromSitemap.length > 0) {
+    for (const route of comparison.missingFromSitemap) {
+      issues.push({
+        id: `route-missing-sitemap-${route.path}`,
+        category: "indexing",
+        severity: "warning",
+        title: "Route missing from sitemap",
+        description: `Static route ${route.path} is not in sitemap.xml`,
+        url: route.path,
+        recommendation: "Add this route to your sitemap for better indexing",
+        detectedAt: now
+      });
+    }
+  }
+  if (comparison && comparison.extraInSitemap.length > 0) {
+    for (const path6 of comparison.extraInSitemap.slice(0, 20)) {
+      issues.push({
+        id: `sitemap-orphan-${path6}`,
+        category: "indexing",
+        severity: "info",
+        title: "Sitemap URL without matching route",
+        description: `URL ${path6} in sitemap doesn't match any app/ route`,
+        url: path6,
+        recommendation: "Verify this URL is still valid or remove from sitemap",
+        detectedAt: now
+      });
+    }
+  }
+  if (scanResult.dynamicRoutes.length > scanResult.staticRoutes.length * 2) {
+    issues.push({
+      id: "too-many-dynamic-routes",
+      category: "content",
+      severity: "info",
+      title: "High ratio of dynamic routes",
+      description: `${scanResult.dynamicRoutes.length} dynamic vs ${scanResult.staticRoutes.length} static routes`,
+      url: "/",
+      recommendation: "Ensure dynamic routes have proper generateStaticParams for SSG",
+      detectedAt: now
+    });
+  }
+  return issues;
+}
+function generateRoutesSummary(scanResult, comparison, verification) {
+  const lines = [];
+  lines.push("## Routes Summary");
+  lines.push("");
+  lines.push(`Total routes: ${scanResult.routes.length}`);
+  lines.push(`\u251C\u2500\u2500 Static: ${scanResult.staticRoutes.length}`);
+  lines.push(`\u251C\u2500\u2500 Dynamic: ${scanResult.dynamicRoutes.length}`);
+  lines.push(`\u2514\u2500\u2500 API: ${scanResult.apiRoutes.length}`);
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/cli/types.ts
+function parseFormats(format) {
+  if (format === "all") {
+    return ["json", "markdown", "ai-summary", "split"];
+  }
+  if (format === "split") {
+    return ["ai-summary", "split"];
+  }
+  return format.split(",").map((f) => f.trim());
+}
+
+// src/cli/commands/audit.ts
+async function runAudit(options) {
+  const siteUrl = getSiteUrl(options);
+  const startTime = Date.now();
+  console.log("");
+  consola3.box(`${chalk2.bold("SEO Audit")}
+${siteUrl}`);
+  const serviceAccountPath = findGoogleServiceAccount(options["service-account"]);
+  const hasGsc = !!serviceAccountPath;
+  const appDir = options["app-dir"] || findAppDir();
+  const hasRoutes = !!appDir;
+  if (!serviceAccountPath) {
+    const keyFile = getGscKeyFilename();
+    console.log("");
+    consola3.info(chalk2.dim("GSC not configured. Save service account as " + chalk2.cyan(keyFile) + " for indexing data."));
+  }
+  const allIssues = [];
+  const allInspections = [];
+  const allCrawlResults = [];
+  const results = [];
+  let collectedSitemapUrls = [];
+  let totalSteps = 4;
+  if (hasRoutes) totalSteps++;
+  if (hasGsc) totalSteps++;
+  let completedSteps = 0;
+  const errors = [];
+  const updateProgress = (step, status) => {
+    const bar = "\u2588".repeat(completedSteps) + "\u2591".repeat(totalSteps - completedSteps);
+    const pct = Math.round(completedSteps / totalSteps * 100);
+    if (status === "running") {
+      process.stdout.write(`\r${chalk2.cyan("\u25B8")} ${bar} ${pct}% ${chalk2.dim(step)}`);
+    } else if (status === "done") {
+      completedSteps++;
+      const newBar = "\u2588".repeat(completedSteps) + "\u2591".repeat(totalSteps - completedSteps);
+      const newPct = Math.round(completedSteps / totalSteps * 100);
+      process.stdout.write(`\r${chalk2.green("\u2713")} ${newBar} ${newPct}% ${chalk2.dim(step)}${" ".repeat(20)}
+`);
+    } else {
+      process.stdout.write(`\r${chalk2.red("\u2717")} ${bar} ${pct}% ${chalk2.dim(step)}${" ".repeat(20)}
+`);
+    }
+  };
+  console.log("");
+  let sitemapUrls = [];
+  updateProgress("robots.txt", "running");
+  try {
+    const analysis = await analyzeRobotsTxt(siteUrl);
+    sitemapUrls = analysis.sitemaps;
+    results.push({ name: "robots.txt", issues: analysis.issues, meta: { exists: analysis.exists } });
+    allIssues.push(...analysis.issues);
+    updateProgress("robots.txt", "done");
+  } catch (e) {
+    errors.push(`robots.txt: ${e.message}`);
+    updateProgress("robots.txt", "error");
+  }
+  const parallelTasks = await Promise.allSettled([
+    // Sitemap
+    (async () => {
+      updateProgress("Sitemap", "running");
+      const issues = [];
+      const sitemapsToCheck = sitemapUrls.length > 0 ? sitemapUrls : [new URL("/sitemap.xml", siteUrl).href];
+      let totalUrls = 0;
+      for (const smUrl of sitemapsToCheck) {
+        const analyses = await analyzeAllSitemaps(smUrl);
+        for (const a of analyses) {
+          issues.push(...a.issues);
+          totalUrls += a.urls.length;
+          collectedSitemapUrls.push(...a.urls.map((u) => u.loc));
+        }
+      }
+      updateProgress("Sitemap", "done");
+      return { name: "Sitemap", issues, meta: { urls: totalUrls } };
+    })(),
+    // Crawl
+    (async () => {
+      updateProgress("Crawl", "running");
+      const crawler = new SiteCrawler(siteUrl, {
+        maxPages: parseInt(options["max-pages"], 10),
+        maxDepth: parseInt(options["max-depth"], 10)
+      });
+      const crawlResults = await crawler.crawl();
+      allCrawlResults.push(...crawlResults);
+      const issues = analyzeCrawlResults(crawlResults);
+      updateProgress("Crawl", "done");
+      return { name: "Crawl", issues, meta: { pages: crawlResults.length } };
+    })(),
+    // Links
+    (async () => {
+      updateProgress("Links", "running");
+      const result = await checkLinks({
+        url: siteUrl,
+        timeout: parseInt(options.timeout, 10),
+        concurrency: parseInt(options.concurrency, 10),
+        verbose: false
+      });
+      const issues = linkResultsToSeoIssues(result);
+      updateProgress("Links", "done");
+      return { name: "Links", issues, meta: { total: result.total, broken: result.broken } };
+    })()
+  ]);
+  for (const task of parallelTasks) {
+    if (task.status === "fulfilled") {
+      results.push(task.value);
+      allIssues.push(...task.value.issues);
+    } else {
+      errors.push(task.reason?.message || "Unknown error");
+    }
+  }
+  if (hasRoutes && appDir) {
+    updateProgress("Routes", "running");
+    try {
+      const scanResult = scanRoutes({ appDir });
+      const comparison = compareWithSitemap(scanResult, collectedSitemapUrls, siteUrl);
+      const issues = analyzeRoutes(scanResult, comparison);
+      results.push({
+        name: "Routes",
+        issues,
+        meta: {
+          static: scanResult.staticRoutes.length,
+          dynamic: scanResult.dynamicRoutes.length,
+          missing: comparison.missingFromSitemap.length
+        }
+      });
+      allIssues.push(...issues);
+      updateProgress("Routes", "done");
+    } catch (e) {
+      errors.push(`Routes: ${e.message}`);
+      updateProgress("Routes", "error");
+    }
+  }
+  if (hasGsc) {
+    updateProgress("GSC", "running");
+    try {
+      const client = new GoogleConsoleClient({
+        siteUrl,
+        serviceAccountPath
+      });
+      const isAuth = await client.verify();
+      if (isAuth) {
+        const urlsToInspect = allCrawlResults.filter((r) => r.statusCode === 200).slice(0, 50).map((r) => r.url);
+        const inspections = await client.inspectUrls(urlsToInspect);
+        allInspections.push(...inspections);
+        const issues = analyzeInspectionResults(inspections);
+        results.push({ name: "GSC", issues, meta: { inspected: inspections.length } });
+        allIssues.push(...issues);
+      } else {
+        results.push({ name: "GSC", issues: [], meta: { skipped: true } });
+      }
+      updateProgress("GSC", "done");
+    } catch (e) {
+      errors.push(`GSC: ${e.message}`);
+      updateProgress("GSC", "error");
+    }
+  }
+  if (errors.length > 0) {
+    console.log("");
+    for (const err of errors) {
+      consola3.error(err);
+    }
+  }
+  console.log("");
+  consola3.log(chalk2.bold("Results:"));
+  for (const r of results) {
+    const issueStr = r.issues.length > 0 ? chalk2.yellow(`${r.issues.length} issues`) : chalk2.green("OK");
+    const metaStr = r.meta ? chalk2.dim(` (${Object.entries(r.meta).map(([k, v]) => `${k}: ${v}`).join(", ")})`) : "";
+    consola3.log(`  ${r.name}: ${issueStr}${metaStr}`);
+  }
+  console.log("");
+  consola3.start("Generating reports...");
+  const formats = parseFormats(options.format);
+  const { report, files } = await generateAndSaveReports(
+    siteUrl,
+    {
+      issues: allIssues,
+      urlInspections: allInspections,
+      crawlResults: allCrawlResults
+    },
+    {
+      outputDir: options.output,
+      formats,
+      includeRawData: true
+    }
+  );
+  const duration = ((Date.now() - startTime) / 1e3).toFixed(1);
+  console.log("");
+  printReportSummary(report);
+  console.log("");
+  consola3.info(`Reports saved to: ${chalk2.cyan(options.output)}`);
+  if (files.json) consola3.log(`  ${chalk2.dim("\u2192")} ${files.json}`);
+  if (files.markdown) consola3.log(`  ${chalk2.dim("\u2192")} ${files.markdown}`);
+  if (files.aiSummary) consola3.log(`  ${chalk2.dim("\u2192")} ${files.aiSummary}`);
+  if (files.split) {
+    consola3.log(`  ${chalk2.dim("\u2192")} ${files.split.index} ${chalk2.dim("(index)")}`);
+    consola3.log(`  ${chalk2.dim("\u2192")} ${files.split.categories.length} category files`);
+  }
+  console.log("");
+  consola3.success(`Audit completed in ${duration}s`);
+}
+async function runRoutes(options) {
+  const siteUrl = getSiteUrl(options);
+  const appDir = options["app-dir"] || findAppDir();
+  if (!appDir) {
+    consola3.error("Could not find app/ directory. Use --app-dir to specify path.");
+    process.exit(1);
+  }
+  console.log("");
+  consola3.box(`${chalk2.bold("Routes Scanner")}
+${appDir}`);
+  consola3.start("Scanning app/ directory...");
+  const scanResult = scanRoutes({ appDir });
+  consola3.success(`Found ${scanResult.routes.length} routes`);
+  console.log(`  \u251C\u2500\u2500 Static: ${scanResult.staticRoutes.length}`);
+  console.log(`  \u251C\u2500\u2500 Dynamic: ${scanResult.dynamicRoutes.length}`);
+  console.log(`  \u2514\u2500\u2500 API: ${scanResult.apiRoutes.length}`);
+  if (scanResult.staticRoutes.length > 0) {
+    console.log("");
+    consola3.info("Static routes:");
+    for (const route of scanResult.staticRoutes.slice(0, 20)) {
+      console.log(`  ${chalk2.green("\u2192")} ${route.path}`);
+    }
+    if (scanResult.staticRoutes.length > 20) {
+      console.log(`  ${chalk2.dim(`... +${scanResult.staticRoutes.length - 20} more`)}`);
+    }
+  }
+  if (scanResult.dynamicRoutes.length > 0) {
+    console.log("");
+    consola3.info("Dynamic routes:");
+    for (const route of scanResult.dynamicRoutes.slice(0, 10)) {
+      const params = route.dynamicSegments.join(", ");
+      console.log(`  ${chalk2.yellow("\u2192")} ${route.path} ${chalk2.dim(`[${params}]`)}`);
+    }
+    if (scanResult.dynamicRoutes.length > 10) {
+      console.log(`  ${chalk2.dim(`... +${scanResult.dynamicRoutes.length - 10} more`)}`);
+    }
+  }
+  if (options.check) {
+    console.log("");
+    consola3.start("Loading sitemap...");
+    try {
+      const sitemapUrl = new URL("/sitemap.xml", siteUrl).href;
+      const sitemap = await analyzeSitemap(sitemapUrl);
+      const sitemapUrls = sitemap.urls.map((u) => u.loc);
+      consola3.success(`Loaded ${sitemapUrls.length} URLs from sitemap`);
+      const comparison = compareWithSitemap(scanResult, sitemapUrls, siteUrl);
+      console.log("");
+      consola3.info("Sitemap comparison:");
+      console.log(`  \u251C\u2500\u2500 Matching: ${comparison.matching.length}`);
+      console.log(`  \u251C\u2500\u2500 Missing from sitemap: ${chalk2.yellow(String(comparison.missingFromSitemap.length))}`);
+      console.log(`  \u2514\u2500\u2500 Extra in sitemap: ${comparison.extraInSitemap.length}`);
+      if (comparison.missingFromSitemap.length > 0) {
+        console.log("");
+        consola3.warn("Routes missing from sitemap:");
+        for (const route of comparison.missingFromSitemap.slice(0, 10)) {
+          console.log(`  ${chalk2.red("\u2717")} ${route.path}`);
+        }
+        if (comparison.missingFromSitemap.length > 10) {
+          console.log(`  ${chalk2.dim(`... +${comparison.missingFromSitemap.length - 10} more`)}`);
+        }
+      }
+    } catch (error) {
+      consola3.error(`Failed to load sitemap: ${error.message}`);
+    }
+  }
+  if (options.verify) {
+    console.log("");
+    consola3.start("Verifying routes...");
+    const verification = await verifyRoutes(scanResult, {
+      baseUrl: siteUrl,
+      timeout: parseInt(options.timeout, 10),
+      concurrency: 5,
+      staticOnly: true
+    });
+    const accessible = verification.filter((r) => r.isAccessible);
+    const broken = verification.filter((r) => !r.isAccessible);
+    consola3.success(`Verified ${verification.length} routes`);
+    console.log(`  \u251C\u2500\u2500 Accessible: ${chalk2.green(String(accessible.length))}`);
+    console.log(`  \u2514\u2500\u2500 Broken: ${chalk2.red(String(broken.length))}`);
+    if (broken.length > 0) {
+      console.log("");
+      consola3.error("Broken routes:");
+      for (const r of broken.slice(0, 10)) {
+        console.log(`  ${chalk2.red("\u2717")} ${r.route.path} \u2192 ${r.statusCode || r.error}`);
+      }
+      if (broken.length > 10) {
+        console.log(`  ${chalk2.dim(`... +${broken.length - 10} more`)}`);
+      }
+    }
+  }
+  console.log("");
+  console.log(generateRoutesSummary(scanResult));
+}
+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("#"));
+}
+
+// src/cli/commands/inspect.ts
+async function runInspect(options) {
+  const siteUrl = getSiteUrl(options);
+  consola3.start("Starting URL inspection via Google Search Console");
+  const client = new GoogleConsoleClient({
+    siteUrl,
+    serviceAccountPath: options["service-account"]
+  });
+  const isAuth = await client.verify();
+  if (!isAuth) {
+    consola3.error("Failed to authenticate with Google Search Console");
+    process.exit(1);
+  }
+  let urls;
+  if (options.urls) {
+    urls = loadUrlsFromFile(options.urls);
+    consola3.info(`Loaded ${urls.length} URLs from ${options.urls}`);
+  } else {
+    consola3.info("Fetching URLs from search analytics...");
+    const today = /* @__PURE__ */ new Date();
+    const startDate = new Date(today.getTime() - 30 * 24 * 60 * 60 * 1e3);
+    const rows = await client.getSearchAnalytics({
+      startDate: startDate.toISOString().split("T")[0],
+      endDate: today.toISOString().split("T")[0],
+      dimensions: ["page"],
+      rowLimit: 100
+    });
+    urls = rows.map((row) => row.keys?.[0] || "").filter(Boolean);
+    consola3.info(`Found ${urls.length} URLs from search analytics`);
+  }
+  const results = await client.inspectUrls(urls);
+  const issues = analyzeInspectionResults(results);
+  consola3.info(`Found ${issues.length} issues`);
+  const formats = parseFormats(options.format);
+  await generateAndSaveReports(siteUrl, { issues, urlInspections: results }, {
+    outputDir: options.output,
+    formats,
+    includeRawData: true
+  });
+}
+async function runCrawl(options) {
+  const siteUrl = getSiteUrl(options);
+  consola3.start(`Starting crawl of ${siteUrl}`);
+  const crawler = new SiteCrawler(siteUrl, {
+    maxPages: parseInt(options["max-pages"], 10),
+    maxDepth: parseInt(options["max-depth"], 10)
+  });
+  const crawlResults = await crawler.crawl();
+  const issues = analyzeCrawlResults(crawlResults);
+  consola3.info(`Found ${issues.length} issues from ${crawlResults.length} pages`);
+  const formats = parseFormats(options.format);
+  await generateAndSaveReports(siteUrl, { issues, crawlResults }, {
+    outputDir: options.output,
+    formats,
+    includeRawData: true
+  });
+}
+async function runLinks(options) {
+  const siteUrl = getSiteUrl(options);
+  consola3.start(`Checking links on ${siteUrl}`);
+  const result = await checkLinks({
+    url: siteUrl,
+    timeout: parseInt(options.timeout, 10),
+    concurrency: parseInt(options.concurrency, 10),
+    verbose: true
+  });
+  if (result.success) {
+    consola3.success(`All ${result.total} links are valid!`);
+  } else {
+    consola3.error(`Found ${result.broken} broken links out of ${result.total}`);
+    if (options.output !== "./seo-reports" || result.broken > 0) {
+      const issues = linkResultsToSeoIssues(result);
+      const formats = parseFormats(options.format);
+      await generateAndSaveReports(siteUrl, { issues }, {
+        outputDir: options.output,
+        formats,
+        includeRawData: false
+      });
+    }
+  }
+  process.exit(result.success ? 0 : 1);
+}
+async function runRobots(options) {
+  const siteUrl = getSiteUrl(options);
+  consola3.start(`Analyzing robots.txt for ${siteUrl}`);
+  const analysis = await analyzeRobotsTxt(siteUrl);
+  if (analysis.exists) {
+    consola3.success("robots.txt found");
+    consola3.info(`Sitemaps: ${analysis.sitemaps.length}`);
+    consola3.info(`Disallow rules: ${analysis.disallowedPaths.length}`);
+    consola3.info(`Allow rules: ${analysis.allowedPaths.length}`);
+    if (analysis.crawlDelay) {
+      consola3.info(`Crawl-delay: ${analysis.crawlDelay}`);
+    }
+    if (analysis.issues.length > 0) {
+      consola3.warn(`Issues found: ${analysis.issues.length}`);
+      for (const issue of analysis.issues) {
+        consola3.log(`  - [${issue.severity}] ${issue.title}`);
+      }
+    }
+  } else {
+    consola3.warn("robots.txt not found");
+  }
+}
+async function runSitemap(options) {
+  let sitemapUrl = getSiteUrl(options);
+  if (!sitemapUrl.endsWith(".xml")) {
+    sitemapUrl = new URL("/sitemap.xml", sitemapUrl).href;
+  }
+  consola3.start(`Validating sitemap: ${sitemapUrl}`);
+  const analyses = await analyzeAllSitemaps(sitemapUrl);
+  let totalUrls = 0;
+  let totalIssues = 0;
+  for (const analysis of analyses) {
+    if (analysis.exists) {
+      consola3.success(`${analysis.url}`);
+      consola3.info(`  Type: ${analysis.type}`);
+      if (analysis.type === "sitemap") {
+        consola3.info(`  URLs: ${analysis.urls.length}`);
+        totalUrls += analysis.urls.length;
+      } else {
+        consola3.info(`  Child sitemaps: ${analysis.childSitemaps.length}`);
+      }
+      if (analysis.issues.length > 0) {
+        totalIssues += analysis.issues.length;
+        for (const issue of analysis.issues) {
+          consola3.warn(`  [${issue.severity}] ${issue.title}`);
+        }
+      }
+    } else {
+      consola3.error(`${analysis.url} - Not found`);
+    }
+  }
+  consola3.box(`Total URLs: ${totalUrls}
+Total Issues: ${totalIssues}`);
+}
+function detectProjectType(cwd) {
+  const contentDir = path.join(cwd, "content");
+  const appDir = path.join(cwd, "app");
+  if (fs4.existsSync(contentDir)) {
+    if (hasMetaFiles(contentDir)) {
+      return "nextra";
+    }
+  }
+  if (fs4.existsSync(appDir)) {
+    return "nextjs";
+  }
+  return "unknown";
+}
+function hasMetaFiles(dir) {
+  if (!fs4.existsSync(dir)) return false;
+  const entries = fs4.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 getAllFiles(dir, extensions, files = []) {
+  if (!fs4.existsSync(dir)) return files;
+  const entries = fs4.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 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) => fs4.existsSync(p));
+}
+function findContentDir(cwd) {
+  const candidates = [
+    path.join(cwd, "content"),
+    path.join(cwd, "docs"),
+    path.join(cwd, "pages", "docs")
+  ];
+  for (const candidate of candidates) {
+    if (fs4.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+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 = fs4.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, config2) {
+  const assetExtensions = config2?.assetExtensions || [
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".svg",
+    ".webp",
+    ".ico",
+    ".pdf",
+    ".zip",
+    ".tar",
+    ".gz"
+  ];
+  const basePath = config2?.basePath;
+  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 = fs4.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 = fs4.readFileSync(filePath, "utf-8");
+  for (const { from, to } of fixes) {
+    content = content.split(from).join(to);
+  }
+  fs4.writeFileSync(filePath, content, "utf-8");
+}
+function fixContentLinks(contentDir, options = {}) {
+  const { apply = false, config: config2 } = options;
+  const assetExtensions = config2?.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
+  };
+}
+async function getMeta(dir) {
+  const metaPath = path.join(dir, "_meta.ts");
+  if (!fs4.existsSync(metaPath)) return {};
+  try {
+    const meta = await import(metaPath);
+    return meta.default || {};
+  } catch {
+    try {
+      const content = fs4.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 (!fs4.existsSync(dir)) return items;
+  const meta = await getMeta(dir);
+  const entries = fs4.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, config2) {
+  const projectType = detectProjectType(cwd);
+  const contentDir = path.join(cwd, config2?.contentDir || "content");
+  const appDir = path.join(cwd, config2?.appDir || "app");
+  const basePath = config2?.basePath || "/docs";
+  let docsItems = [];
+  let appItems = [];
+  if (projectType === "nextra" && fs4.existsSync(contentDir)) {
+    docsItems = await scanContent(contentDir, basePath);
+  }
+  if (fs4.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 (!fs4.existsSync(outputDir)) {
+    fs4.mkdirSync(outputDir, { recursive: true });
+  }
+  const content = generateTsContent(data);
+  fs4.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
+  };
+}
+
+// src/cli/commands/content.ts
+var CONTENT_HELP = `
+${chalk2.bold("Content Commands")} - MDX/Nextra content tools
+
+${chalk2.bold("Usage:")}
+  djangocfg-seo content <subcommand> [options]
+
+${chalk2.bold("Subcommands:")}
+  check     Check links in content/ directory
+  fix       Fix absolute links to relative
+  sitemap   Generate sitemap.ts from content/
+
+${chalk2.bold("Options:")}
+  --content-dir <path>  Content directory (default: content/)
+  --output <path>       Output file for sitemap (default: app/_core/sitemap.ts)
+  --fix                 Apply fixes (for 'fix' subcommand)
+  --base-path <path>    Base URL path (default: /docs)
+
+${chalk2.bold("Examples:")}
+  djangocfg-seo content check
+  djangocfg-seo content fix --fix
+  djangocfg-seo content sitemap --output app/_core/sitemap.ts
+`;
+async function runContent(options) {
+  const subcommand = options._[1];
+  if (!subcommand || subcommand === "help") {
+    console.log(CONTENT_HELP);
+    return;
+  }
+  const cwd = process.cwd();
+  const contentDir = options["content-dir"] ? path.resolve(cwd, options["content-dir"]) : findContentDir(cwd);
+  if (!contentDir && subcommand !== "sitemap") {
+    consola3.error("Could not find content/ directory. Use --content-dir to specify path.");
+    process.exit(1);
+  }
+  const projectType = detectProjectType(cwd);
+  console.log("");
+  consola3.box(`${chalk2.bold("Content Tools")}
+Project: ${projectType}
+Path: ${contentDir || cwd}`);
+  switch (subcommand) {
+    case "check":
+      await runCheck(contentDir, options);
+      break;
+    case "fix":
+      await runFix(contentDir, options);
+      break;
+    case "sitemap":
+      await runSitemapGenerate(cwd, options);
+      break;
+    default:
+      consola3.error(`Unknown subcommand: ${subcommand}`);
+      console.log(CONTENT_HELP);
+      process.exit(1);
+  }
+}
+async function runCheck(contentDir, options) {
+  consola3.start("Checking links in content/ folder...");
+  const basePath = options["base-path"] || "/docs";
+  const result = checkContentLinks(contentDir, { basePath });
+  if (result.success) {
+    console.log("");
+    consola3.success("All links are valid!");
+    console.log(`  Checked ${result.filesChecked} files, ${result.uniqueLinks} unique links.`);
+    return;
+  }
+  console.log("");
+  consola3.error(`Found ${result.brokenLinks.length} broken links:`);
+  console.log("");
+  const byFile = groupBrokenLinksByFile(result.brokenLinks);
+  for (const [file, links] of byFile) {
+    console.log(`${chalk2.cyan("\u{1F4C4}")} ${file}`);
+    for (const link of links) {
+      console.log(`   L${link.line}: ${chalk2.red("\u2717")} ${link.link} ${chalk2.dim(`(${link.type}: "${link.raw}")`)}`);
+    }
+    console.log("");
+  }
+  console.log(`${chalk2.bold("Summary:")} ${result.brokenLinks.length} broken links in ${byFile.size} files`);
+  console.log(`   Checked ${result.filesChecked} files, ${result.uniqueLinks} unique links.`);
+  process.exit(1);
+}
+async function runFix(contentDir, options) {
+  const applyFixes2 = options.fix === true;
+  consola3.start(applyFixes2 ? "Fixing links..." : "Checking for absolute links that can be relative...");
+  const result = fixContentLinks(contentDir, { apply: applyFixes2 });
+  if (result.totalChanges === 0) {
+    console.log("");
+    consola3.success("No absolute links that can be converted to relative.");
+    return;
+  }
+  console.log("");
+  console.log(`Found ${result.totalChanges} links that can be relative:`);
+  console.log("");
+  for (const { file, fixes } of result.fileChanges) {
+    console.log(`${chalk2.cyan("\u{1F4C4}")} ${file}`);
+    for (const { from, to, line } of fixes) {
+      console.log(`   L${line}: ${from} ${chalk2.yellow("\u2192")} ${to}`);
+    }
+    console.log("");
+  }
+  if (applyFixes2) {
+    consola3.success(`Fixed ${result.totalChanges} links in ${result.fileChanges.length} files.`);
+  } else {
+    console.log(`${chalk2.yellow("\u{1F4A1}")} Run with --fix to apply changes:`);
+    console.log(`   djangocfg-seo content fix --fix`);
+  }
+}
+async function runSitemapGenerate(cwd, options) {
+  consola3.start("Generating sitemap...");
+  const rawOutput = options.output;
+  const output = rawOutput?.endsWith(".ts") ? rawOutput : "app/_core/sitemap.ts";
+  const contentDir = options["content-dir"] || "content";
+  const basePath = options["base-path"] || "/docs";
+  const { outputPath, data } = await generateSitemap(cwd, {
+    output,
+    config: { contentDir, basePath }
+  });
+  const counts = countSitemapItems(data);
+  console.log("");
+  consola3.success(`Sitemap generated at ${outputPath}`);
+  console.log(`  \u251C\u2500\u2500 App pages: ${counts.app}`);
+  console.log(`  \u251C\u2500\u2500 Doc pages: ${counts.docs}`);
+  console.log(`  \u2514\u2500\u2500 Total: ${counts.total}`);
+}
+
+// src/cli/index.ts
+loadEnvFiles();
+var VERSION = "1.0.0";
+var HELP = `
+${chalk2.bold("@djangocfg/seo")} - SEO Analysis Tool v${VERSION}
+
+${chalk2.bold("Usage:")}
+  djangocfg-seo <command> [options]
+
+${chalk2.bold("Commands:")}
+  audit      Full SEO audit (robots + sitemap + crawl + links)
+  routes     Scan app/ directory and compare with sitemap
+  content    MDX content tools (check, fix, sitemap)
+  crawl      Crawl site and analyze SEO issues
+  links      Check all links for broken links
+  robots     Analyze robots.txt
+  sitemap    Validate sitemap
+  inspect    Inspect URLs via Google Search Console API
+
+${chalk2.bold("Options:")}
+  --env, -e          Environment: prod (default) or dev
+  --site, -s         Site URL (overrides env detection)
+  --output, -o       Output directory for reports
+  --format, -f       Report format: split (default), json, markdown, ai-summary, all
+  --max-pages        Maximum pages to crawl (default: 100)
+  --max-depth        Maximum crawl depth (default: 3)
+  --timeout          Request timeout in ms (default: 60000)
+  --concurrency      Max concurrent requests (default: 50)
+  --service-account  Path to Google service account JSON
+  --app-dir          Path to app/ directory (for routes command)
+  --content-dir      Path to content/ directory (for content command)
+  --base-path        Base URL path for docs (default: /docs)
+  --check            Compare routes with sitemap
+  --verify           Verify routes are accessible
+  --fix              Apply fixes (for content fix command)
+  --help, -h         Show this help
+  --version, -v      Show version
+
+${chalk2.bold("Examples:")}
+  ${chalk2.dim("# Full SEO audit")}
+  djangocfg-seo audit
+
+  ${chalk2.dim("# Scan app routes and compare with sitemap")}
+  djangocfg-seo routes --check
+
+  ${chalk2.dim("# Check links on production")}
+  djangocfg-seo links
+
+  ${chalk2.dim("# Check MDX content links")}
+  djangocfg-seo content check
+
+  ${chalk2.dim("# Fix absolute links to relative")}
+  djangocfg-seo content fix --fix
+
+  ${chalk2.dim("# Generate sitemap.ts from content")}
+  djangocfg-seo content sitemap
+`;
+async function main() {
+  const { values, positionals } = parseArgs({
+    allowPositionals: true,
+    options: {
+      env: { type: "string", short: "e", default: "prod" },
+      site: { type: "string", short: "s" },
+      output: { type: "string", short: "o", default: "./seo-reports" },
+      urls: { type: "string", short: "u" },
+      "max-pages": { type: "string", default: "100" },
+      "max-depth": { type: "string", default: "3" },
+      timeout: { type: "string", default: "60000" },
+      concurrency: { type: "string", default: "50" },
+      format: { type: "string", short: "f", default: "split" },
+      "service-account": { type: "string" },
+      "app-dir": { type: "string" },
+      "content-dir": { type: "string" },
+      "base-path": { type: "string" },
+      check: { type: "boolean" },
+      verify: { type: "boolean" },
+      fix: { type: "boolean" },
+      help: { type: "boolean", short: "h" },
+      version: { type: "boolean", short: "v" }
+    }
+  });
+  if (values.version) {
+    console.log(VERSION);
+    process.exit(0);
+  }
+  if (values.help || positionals.length === 0) {
+    console.log(HELP);
+    process.exit(0);
+  }
+  const command = positionals[0];
+  const options = { ...values, _: positionals };
+  try {
+    switch (command) {
+      case "audit":
+      case "report":
+        await runAudit(options);
+        break;
+      case "routes":
+        await runRoutes(options);
+        break;
+      case "inspect":
+        await runInspect(options);
+        break;
+      case "crawl":
+        await runCrawl(options);
+        break;
+      case "links":
+        await runLinks(options);
+        break;
+      case "robots":
+        await runRobots(options);
+        break;
+      case "sitemap":
+        await runSitemap(options);
+        break;
+      case "content":
+        await runContent(options);
+        break;
+      default:
+        consola3.error(`Unknown command: ${command}`);
+        console.log(HELP);
+        process.exit(1);
+    }
+  } catch (error) {
+    consola3.error(error);
+    process.exit(1);
+  }
+}
+main().catch(consola3.error);
+//# sourceMappingURL=cli.mjs.map
+//# sourceMappingURL=cli.mjs.map