@djangocfg/seo 2.1.140 → 2.1.143

package/dist/cli.mjs

@@ -1,17 +1,17 @@
 #!/usr/bin/env node
-import { parseArgs } from 'util';
-import consola3 from 'consola';
 import chalk2 from 'chalk';
+import consola6 from 'consola';
+import { parseArgs } from 'util';
 import fs4, { existsSync, readFileSync, readdirSync, rmSync, mkdirSync, writeFileSync, statSync } from 'fs';
 import path, { resolve, join, dirname } from 'path';
-import { searchconsole } from '@googleapis/searchconsole';
+import { parseHTML, DOMParser } from 'linkedom';
 import pLimit from 'p-limit';
+import robotsParser from 'robots-parser';
 import pRetry from 'p-retry';
+import { searchconsole } from '@googleapis/searchconsole';
 import { JWT } from 'google-auth-library';
-import { parseHTML, DOMParser } from 'linkedom';
-import robotsParser from 'robots-parser';
-import { mkdir, writeFile } from 'fs/promises';
 import * as linkinator from 'linkinator';
+import { mkdir, writeFile } from 'fs/promises';
 
 var config = {
   env: {
@@ -74,26 +74,26 @@ function getSiteUrl(options) {
   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)}`);
+    consola6.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}`);
+    consola6.info(`Using URL from environment: ${fallbackUrl}`);
     return fallbackUrl;
   }
   console.log("");
-  consola3.error("No site URL found!");
+  consola6.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}`);
+    consola6.info("Available environments:");
+    if (config.env.prod) consola6.log(`  ${chalk2.green("prod")}: ${config.env.prod}`);
+    if (config.env.dev) consola6.log(`  ${chalk2.yellow("dev")}:  ${config.env.dev}`);
     console.log("");
-    consola3.info(`Use ${chalk2.cyan("--env prod")} or ${chalk2.cyan("--env dev")} to select`);
+    consola6.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");
+    consola6.info("Create .env.production or .env.development with NEXT_PUBLIC_SITE_URL");
+    consola6.info("Or use --site https://example.com");
   }
   process.exit(1);
 }
@@ -104,12 +104,12 @@ function findGoogleServiceAccount(explicitPath) {
     if (existsSync(resolved)) {
       return resolved;
     }
-    consola3.warn(`Service account file not found: ${explicitPath}`);
+    consola6.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)}`);
+    consola6.info(`Found Google service account: ${chalk2.cyan(GSC_KEY_FILENAME)}`);
     return defaultPath;
   }
   return void 0;
@@ -117,511 +117,336 @@ function findGoogleServiceAccount(explicitPath) {
 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);
+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);
   }
   /**
-   * List all sites in Search Console
+   * Start crawling the site
    */
-  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;
+  async crawl() {
+    consola6.info(`Starting crawl of ${this.baseUrl.origin}`);
+    consola6.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);
     }
+    consola6.success(`Crawl complete. Crawled ${this.results.length} pages.`);
+    return this.results;
   }
   /**
-   * Inspect a single URL
+   * Crawl a single page
    */
-  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);
+  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"
         },
-        {
-          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;
+        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);
         }
       }
     }
-    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;
+    result.loadTime = Date.now() - startTime;
+    this.results.push(result);
+    consola6.debug(`Crawled: ${normalizedUrl} (${result.statusCode}) - ${result.loadTime}ms`);
   }
   /**
-   * Show help message for rate limiting issues
+   * Parse HTML and extract SEO-relevant data
    */
-  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
+  parseHtml(html, result, pageUrl, depth) {
+    const { document } = parseHTML(html);
+    const titleEl = document.querySelector("title");
+    result.title = titleEl?.textContent?.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)`);
+    }
+    const metaDesc = document.querySelector('meta[name="description"]');
+    result.metaDescription = metaDesc?.getAttribute("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)`
+      );
+    }
+    const metaRobots = document.querySelector('meta[name="robots"]');
+    result.metaRobots = metaRobots?.getAttribute("content")?.trim() || void 0;
+    const xRobots = document.querySelector('meta[http-equiv="X-Robots-Tag"]');
+    const xRobotsContent = xRobots?.getAttribute("content")?.trim();
+    if (xRobotsContent) {
+      result.metaRobots = result.metaRobots ? `${result.metaRobots}, ${xRobotsContent}` : xRobotsContent;
+    }
+    const canonical = document.querySelector('link[rel="canonical"]');
+    result.canonicalUrl = canonical?.getAttribute("href")?.trim() || void 0;
+    if (!result.canonicalUrl) {
+      result.warnings.push("Missing canonical tag");
+    }
+    result.h1 = Array.from(document.querySelectorAll("h1")).map((el) => el.textContent?.trim() || "");
+    result.h2 = Array.from(document.querySelectorAll("h2")).map((el) => el.textContent?.trim() || "");
+    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})`);
+    }
+    for (const el of document.querySelectorAll("a[href]")) {
+      const href = el.getAttribute("href");
+      if (!href) continue;
+      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);
         }
-      });
-      return response.data.rows || [];
-    } catch (error) {
-      consola3.error("Failed to get search analytics:", error);
-      throw error;
+      } catch {
+      }
+    }
+    for (const el of document.querySelectorAll("img")) {
+      const src = el.getAttribute("src");
+      const alt = el.getAttribute("alt");
+      const hasAltAttr = alt !== null;
+      if (src) {
+        result.images.push({
+          src,
+          alt: alt ?? void 0,
+          hasAlt: hasAltAttr && 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`);
     }
   }
   /**
-   * Get list of sitemaps
+   * Normalize URL for deduplication
    */
-  async getSitemaps() {
+  normalizeUrl(url) {
     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;
+      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;
     }
   }
   /**
-   * Map API response to our types
+   * Check if URL should be excluded
    */
-  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
-    };
+  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));
   }
 };
-
-// src/google-console/analyzer.ts
-function analyzeInspectionResults(results) {
+function analyzeCrawlResults(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":
+    if (result.statusCode >= 400) {
       issues.push({
-        id: `crawled-not-indexed-${hash(result.url)}`,
+        id: `http-error-${hash(result.url)}`,
         url: result.url,
-        category: "indexing",
+        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-${hash(result.url)}`,
+        url: result.url,
+        category: "content",
         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 }
+        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
       });
-      break;
-    case "DISCOVERED_CURRENTLY_NOT_INDEXED":
+    }
+    if (!result.metaDescription && result.statusCode === 200) {
       issues.push({
-        id: `discovered-not-indexed-${hash(result.url)}`,
+        id: `missing-meta-desc-${hash(result.url)}`,
         url: result.url,
-        category: "indexing",
+        category: "content",
         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 }
+        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
       });
-      break;
-    case "DUPLICATE_WITHOUT_USER_SELECTED_CANONICAL":
+    }
+    if (result.h1 && result.h1.length === 0 && result.statusCode === 200) {
       issues.push({
-        id: `duplicate-no-canonical-${hash(result.url)}`,
+        id: `missing-h1-${hash(result.url)}`,
         url: result.url,
-        category: "indexing",
+        category: "content",
         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
-        }
+        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
       });
-      break;
-    case "DUPLICATE_GOOGLE_CHOSE_DIFFERENT_CANONICAL":
+    }
+    if (result.h1 && result.h1.length > 1) {
       issues.push({
-        id: `canonical-mismatch-${hash(result.url)}`,
+        id: `multiple-h1-${hash(result.url)}`,
         url: result.url,
-        category: "indexing",
+        category: "content",
         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
-        }
+        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 }
       });
-      break;
-  }
-  switch (indexStatusResult.indexingState) {
-    case "BLOCKED_BY_META_TAG":
+    }
+    const imagesWithoutAlt = result.images.filter((img) => !img.hasAlt);
+    if (imagesWithoutAlt.length > 0) {
       issues.push({
-        id: `blocked-meta-noindex-${hash(result.url)}`,
+        id: `images-no-alt-${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 }
+        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 }
       });
-      break;
-    case "REDIRECT_ERROR":
+    }
+    if (result.loadTime > 3e3) {
       issues.push({
-        id: `redirect-error-${hash(result.url)}`,
+        id: `slow-page-${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 }
+        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 }
       });
-      break;
-    case "ACCESS_DENIED":
-    case "ACCESS_FORBIDDEN":
+    }
+    if (result.ttfb && result.ttfb > 800) {
       issues.push({
-        id: `access-denied-${hash(result.url)}`,
+        id: `slow-ttfb-${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 }
+        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 }
       });
-      break;
-  }
-  if (mobileUsabilityResult?.verdict === "FAIL" && mobileUsabilityResult.issues) {
-    for (const issue of mobileUsabilityResult.issues) {
+    }
+    if (result.metaRobots?.includes("noindex")) {
       issues.push({
-        id: `mobile-${issue.issueType}-${hash(result.url)}`,
+        id: `noindex-${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 }
+        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 }
       });
     }
   }
-  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++) {
@@ -631,622 +456,784 @@ function hash(str) {
   }
   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."
+async function analyzeRobotsTxt(siteUrl) {
+  const robotsUrl = new URL("/robots.txt", siteUrl).href;
+  const analysis = {
+    exists: false,
+    sitemaps: [],
+    allowedPaths: [],
+    disallowedPaths: [],
+    issues: []
   };
-  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);
+  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;
     }
-    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()
-    };
+    analysis.exists = true;
+    analysis.content = await response.text();
+    if (analysis.content.includes("content-signal") || analysis.content.includes("Content-Signal") || analysis.content.includes("ai-input") || analysis.content.includes("ai-train")) {
+      analysis.issues.push({
+        id: "cloudflare-managed-robots",
+        url: robotsUrl,
+        category: "technical",
+        severity: "warning",
+        title: "Cloudflare managed robots.txt detected",
+        description: `Your robots.txt is being overwritten by Cloudflare's "Content Signals Policy". Your app/robots.ts file is not being served.`,
+        recommendation: 'Disable in Cloudflare Dashboard: Security \u2192 Settings \u2192 "Manage your robots.txt" \u2192 Set to "Off".',
+        detectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        metadata: {
+          cloudflareFeature: "Managed robots.txt",
+          docsUrl: "https://developers.cloudflare.com/bots/additional-configurations/managed-robots-txt/"
+        }
+      });
+    }
+    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()
+      });
+    }
+    consola6.debug(`Analyzed robots.txt: ${analysis.disallowedPaths.length} disallow rules`);
+  } catch (error) {
+    consola6.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-${hash2(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-${hash2(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 parser = new DOMParser();
+    const doc = parser.parseFromString(content, "text/xml");
+    const sitemapIndex = doc.querySelector("sitemapindex");
+    if (sitemapIndex) {
+      analysis.type = "sitemap-index";
+      for (const sitemap of doc.querySelectorAll("sitemap")) {
+        const loc = sitemap.querySelector("loc")?.textContent?.trim();
+        if (loc) {
+          analysis.childSitemaps.push(loc);
+        }
+      }
+      consola6.debug(`Sitemap index contains ${analysis.childSitemaps.length} sitemaps`);
+    } else {
+      analysis.type = "sitemap";
+      for (const url of doc.querySelectorAll("url")) {
+        const loc = url.querySelector("loc")?.textContent?.trim();
+        if (loc) {
+          analysis.urls.push(loc);
+        }
+        if (!analysis.lastmod) {
+          const lastmod = url.querySelector("lastmod")?.textContent?.trim();
+          if (lastmod) {
+            analysis.lastmod = lastmod;
+          }
+        }
+      }
+      consola6.debug(`Sitemap contains ${analysis.urls.length} URLs`);
+    }
+    if (analysis.type === "sitemap" && analysis.urls.length === 0) {
+      analysis.issues.push({
+        id: `sitemap-empty-${hash2(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-${hash2(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-${hash2(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) {
+    consola6.error("Failed to analyze sitemap:", error);
+    analysis.issues.push({
+      id: `sitemap-error-${hash2(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 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);
+}
+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();
+    consola6.success("Google Search Console authentication verified");
+    consola6.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}`;
+      consola6.info(`Ensure this email has Full access in GSC: ${gscUrl}`);
+    }
+    return true;
+  } catch (error) {
+    consola6.error("Authentication failed");
+    consola6.info(`Service account email: ${email}`);
+    consola6.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}`;
+    }
+    consola6.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 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}`);
-      }
+      const response = await this.searchconsole.sites.list();
+      return response.data.siteEntry?.map((site) => site.siteUrl || "") || [];
     } catch (error) {
-      if (error instanceof Error) {
-        if (error.name === "AbortError") {
-          result.errors.push("Request timeout");
-        } else {
-          result.errors.push(error.message);
-        }
-      }
+      consola6.error("Failed to list sites:", error);
+      throw error;
     }
-    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
+   * Inspect a single URL
    */
-  parseHtml(html, result, pageUrl, depth) {
-    const { document } = parseHTML(html);
-    const titleEl = document.querySelector("title");
-    result.title = titleEl?.textContent?.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)`);
-    }
-    const metaDesc = document.querySelector('meta[name="description"]');
-    result.metaDescription = metaDesc?.getAttribute("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)`
+  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) {
+              consola6.warn(`Failed: ${url}`);
+            }
+          }
+        }
       );
-    }
-    const metaRobots = document.querySelector('meta[name="robots"]');
-    result.metaRobots = metaRobots?.getAttribute("content")?.trim() || void 0;
-    const xRobots = document.querySelector('meta[http-equiv="X-Robots-Tag"]');
-    const xRobotsContent = xRobots?.getAttribute("content")?.trim();
-    if (xRobotsContent) {
-      result.metaRobots = result.metaRobots ? `${result.metaRobots}, ${xRobotsContent}` : xRobotsContent;
-    }
-    const canonical = document.querySelector('link[rel="canonical"]');
-    result.canonicalUrl = canonical?.getAttribute("href")?.trim() || void 0;
-    if (!result.canonicalUrl) {
-      result.warnings.push("Missing canonical tag");
-    }
-    result.h1 = Array.from(document.querySelectorAll("h1")).map((el) => el.textContent?.trim() || "");
-    result.h2 = Array.from(document.querySelectorAll("h2")).map((el) => el.textContent?.trim() || "");
-    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})`);
-    }
-    for (const el of document.querySelectorAll("a[href]")) {
-      const href = el.getAttribute("href");
-      if (!href) continue;
+    });
+  }
+  /**
+   * Inspect multiple URLs in batch
+   * Stops early if too many consecutive errors (likely rate limiting)
+   */
+  async inspectUrls(urls) {
+    consola6.info(`Inspecting ${urls.length} URLs...`);
+    const results = [];
+    const errors = [];
+    let consecutiveErrors = 0;
+    const maxConsecutiveErrors = 3;
+    for (const url of urls) {
       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);
+        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("");
+          consola6.error(`Stopping after ${maxConsecutiveErrors} consecutive failures`);
+          this.showRateLimitHelp();
+          break;
         }
-      } catch {
       }
     }
-    for (const el of document.querySelectorAll("img")) {
-      const src = el.getAttribute("src");
-      const alt = el.getAttribute("alt");
-      const hasAltAttr = alt !== null;
-      if (src) {
-        result.images.push({
-          src,
-          alt: alt ?? void 0,
-          hasAlt: hasAltAttr && alt.trim().length > 0
-        });
-      }
+    if (errors.length > 0 && consecutiveErrors < maxConsecutiveErrors) {
+      consola6.warn(`Failed to inspect ${errors.length} URLs`);
     }
-    const imagesWithoutAlt = result.images.filter((img) => !img.hasAlt);
-    if (imagesWithoutAlt.length > 0) {
-      result.warnings.push(`${imagesWithoutAlt.length} images without alt text`);
+    if (results.length > 0) {
+      consola6.success(`Successfully inspected ${results.length}/${urls.length} URLs`);
+    } else if (errors.length > 0) {
+      consola6.warn("No URLs were successfully inspected");
     }
+    return results;
   }
   /**
-   * Normalize URL for deduplication
+   * Show help message for rate limiting issues
    */
-  normalizeUrl(url) {
+  showRateLimitHelp() {
+    consola6.info("Possible causes:");
+    consola6.info("  1. Google API quota exceeded (2000 requests/day)");
+    consola6.info("  2. Cloudflare blocking Google's crawler");
+    consola6.info("  3. Service account not added to GSC");
+    console.log("");
+    consola6.info("Solutions:");
+    consola6.info("  \u2022 Check GSC access: https://search.google.com/search-console/users");
+    console.log("");
+    consola6.info("  \u2022 Cloudflare WAF rule to allow Googlebot:");
+    consola6.info("    1. Dashboard \u2192 Security \u2192 WAF \u2192 Custom rules \u2192 Create rule");
+    consola6.info('    2. Name: "Allow Googlebot"');
+    consola6.info('    3. Field: "Known Bots" | Operator: "equals" | Value: "true"');
+    consola6.info('    4. Or click "Edit expression" and paste: (cf.client.bot)');
+    consola6.info("    5. Action: Skip \u2192 check all rules");
+    consola6.info("    6. Deploy");
+    consola6.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 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;
+      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) {
+      consola6.error("Failed to get search analytics:", error);
+      throw error;
     }
   }
   /**
-   * Check if URL should be excluded
+   * Get list of sitemaps
    */
-  shouldExclude(url) {
-    if (this.config.includePatterns.length > 0) {
-      const included = this.config.includePatterns.some(
-        (pattern) => url.includes(pattern)
-      );
-      if (!included) return true;
+  async getSitemaps() {
+    try {
+      const response = await this.searchconsole.sitemaps.list({
+        siteUrl: this.gscSiteUrl
+      });
+      return response.data.sitemap || [];
+    } catch (error) {
+      consola6.error("Failed to get sitemaps:", error);
+      throw error;
     }
-    return this.config.excludePatterns.some((pattern) => url.includes(pattern));
+  }
+  /**
+   * 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
+    };
   }
 };
-function analyzeCrawlResults(results) {
+
+// src/google-console/analyzer.ts
+function analyzeInspectionResults(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(...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: `missing-title-${hash2(result.url)}`,
+        id: `crawled-not-indexed-${hash3(result.url)}`,
         url: result.url,
-        category: "content",
+        category: "indexing",
         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
+        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 }
       });
-    }
-    if (result.h1 && result.h1.length > 1) {
+      break;
+    case "DISCOVERED_CURRENTLY_NOT_INDEXED":
       issues.push({
-        id: `multiple-h1-${hash2(result.url)}`,
+        id: `discovered-not-indexed-${hash3(result.url)}`,
         url: result.url,
-        category: "content",
+        category: "indexing",
         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 }
+        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 }
       });
-    }
-    if (result.metaRobots?.includes("noindex")) {
+      break;
+    case "DUPLICATE_WITHOUT_USER_SELECTED_CANONICAL":
       issues.push({
-        id: `noindex-${hash2(result.url)}`,
+        id: `duplicate-no-canonical-${hash3(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();
-    if (analysis.content.includes("content-signal") || analysis.content.includes("Content-Signal") || analysis.content.includes("ai-input") || analysis.content.includes("ai-train")) {
-      analysis.issues.push({
-        id: "cloudflare-managed-robots",
-        url: robotsUrl,
-        category: "technical",
         severity: "warning",
-        title: "Cloudflare managed robots.txt detected",
-        description: `Your robots.txt is being overwritten by Cloudflare's "Content Signals Policy". Your app/robots.ts file is not being served.`,
-        recommendation: 'Disable in Cloudflare Dashboard: Security \u2192 Settings \u2192 "Manage your robots.txt" \u2192 Set to "Off".',
+        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: {
-          cloudflareFeature: "Managed robots.txt",
-          docsUrl: "https://developers.cloudflare.com/bots/additional-configurations/managed-robots-txt/"
+          coverageState: indexStatusResult.coverageState,
+          googleCanonical: indexStatusResult.googleCanonical
         }
       });
-    }
-    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;
+      break;
+    case "DUPLICATE_GOOGLE_CHOSE_DIFFERENT_CANONICAL":
+      issues.push({
+        id: `canonical-mismatch-${hash3(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
         }
-      }
-    }
-    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,
+      });
+      break;
+  }
+  switch (indexStatusResult.indexingState) {
+    case "BLOCKED_BY_META_TAG":
+      issues.push({
+        id: `blocked-meta-noindex-${hash3(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-${hash3(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-${hash3(result.url)}`,
+        url: result.url,
         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()
+        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 }
       });
-    }
-    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()
-    });
+      break;
   }
-  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,
+  switch (indexStatusResult.pageFetchState) {
+    case "SOFT_404":
+      issues.push({
+        id: `soft-404-${hash3(result.url)}`,
+        url: result.url,
         category: "technical",
         severity: "error",
-        title: "Sitemap not accessible",
-        description: `Sitemap returned HTTP ${response.status}.`,
-        recommendation: "Ensure the sitemap URL is correct and accessible.",
+        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: { statusCode: response.status }
+        metadata: { pageFetchState: indexStatusResult.pageFetchState }
       });
-      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,
+      break;
+    case "NOT_FOUND":
+      issues.push({
+        id: `404-error-${hash3(result.url)}`,
+        url: result.url,
         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.",
+        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: { contentType }
+        metadata: { pageFetchState: indexStatusResult.pageFetchState }
       });
-    }
-    const parser = new DOMParser();
-    const doc = parser.parseFromString(content, "text/xml");
-    const sitemapIndex = doc.querySelector("sitemapindex");
-    if (sitemapIndex) {
-      analysis.type = "sitemap-index";
-      for (const sitemap of doc.querySelectorAll("sitemap")) {
-        const loc = sitemap.querySelector("loc")?.textContent?.trim();
-        if (loc) {
-          analysis.childSitemaps.push(loc);
-        }
-      }
-      consola3.debug(`Sitemap index contains ${analysis.childSitemaps.length} sitemaps`);
-    } else {
-      analysis.type = "sitemap";
-      for (const url of doc.querySelectorAll("url")) {
-        const loc = url.querySelector("loc")?.textContent?.trim();
-        if (loc) {
-          analysis.urls.push(loc);
-        }
-        if (!analysis.lastmod) {
-          const lastmod = url.querySelector("lastmod")?.textContent?.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,
+      break;
+    case "SERVER_ERROR":
+      issues.push({
+        id: `server-error-${hash3(result.url)}`,
+        url: result.url,
         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()
+        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 }
       });
-    }
-    if (analysis.urls.length > 5e4) {
-      analysis.issues.push({
-        id: `sitemap-too-large-${hash3(sitemapUrl)}`,
-        url: sitemapUrl,
+      break;
+    case "REDIRECT_ERROR":
+      issues.push({
+        id: `redirect-error-${hash3(result.url)}`,
+        url: result.url,
         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.",
+        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: { urlCount: analysis.urls.length }
+        metadata: { pageFetchState: indexStatusResult.pageFetchState }
       });
-    }
-    const sizeInMB = new Blob([content]).size / (1024 * 1024);
-    if (sizeInMB > 50) {
-      analysis.issues.push({
-        id: `sitemap-too-large-size-${hash3(sitemapUrl)}`,
-        url: sitemapUrl,
+      break;
+    case "ACCESS_DENIED":
+    case "ACCESS_FORBIDDEN":
+      issues.push({
+        id: `access-denied-${hash3(result.url)}`,
+        url: result.url,
         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.",
+        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: { sizeMB: sizeInMB }
+        metadata: { pageFetchState: indexStatusResult.pageFetchState }
       });
-    }
-  } 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()
-    });
+      break;
   }
-  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);
+  if (mobileUsabilityResult?.verdict === "FAIL" && mobileUsabilityResult.issues) {
+    for (const issue of mobileUsabilityResult.issues) {
+      issues.push({
+        id: `mobile-${issue.issueType}-${hash3(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}-${hash3(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 }
+          });
+        }
+      }
     }
   }
-  await analyze(sitemapUrl, 0);
-  return results;
+  return issues;
+}
+function severityOrder(severity) {
+  const order = {
+    critical: 0,
+    error: 1,
+    warning: 2,
+    info: 3
+  };
+  return order[severity];
 }
 function hash3(str) {
   let hash5 = 0;
@@ -1257,6 +1244,19 @@ function hash3(str) {
   }
   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_SKIP_PATTERN = [
   "github.com",
   "twitter.com",
@@ -1514,65 +1514,248 @@ 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(`**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/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("## SEO Files (Next.js App Router)");
+  lines.push("");
+  lines.push("**Required files in `app/`:**");
+  lines.push("");
+  lines.push("### sitemap.xml/route.ts");
+  lines.push("```typescript");
+  lines.push("import { createSitemapHandler } from '@djangocfg/nextjs/sitemap';");
+  lines.push("");
+  lines.push('export const dynamic = "force-static";');
+  lines.push("export const { GET } = createSitemapHandler({");
+  lines.push("  siteUrl,");
+  lines.push("  staticPages: [");
+  lines.push('    { loc: "/", priority: 1.0, changefreq: "daily" },');
+  lines.push('    { loc: "/about", priority: 0.8 },');
+  lines.push("  ],");
+  lines.push("  dynamicPages: async () => fetchPagesFromAPI(),");
+  lines.push("});");
+  lines.push("```");
+  lines.push("");
+  lines.push("### robots.ts");
+  lines.push("```typescript");
+  lines.push("import type { MetadataRoute } from 'next';");
+  lines.push("");
+  lines.push("export default function robots(): MetadataRoute.Robots {");
+  lines.push("  return {");
+  lines.push('    rules: { userAgent: "*", allow: "/" },');
+  lines.push("    sitemap: `${siteUrl}/sitemap.xml`,");
+  lines.push("  };");
+  lines.push("}");
+  lines.push("```");
+  lines.push("");
+  lines.push("### Cloudflare Override");
+  lines.push("");
+  lines.push('If robots.txt shows "Content-Signal" or "ai-train" \u2014 Cloudflare is overriding your file.');
+  lines.push('**Fix:** Dashboard \u2192 Security \u2192 Settings \u2192 "Manage your robots.txt" \u2192 Set to "Off"');
+  lines.push("");
+  lines.push("### Declarative Routes with SEO");
+  lines.push("");
+  lines.push("Create `app/_routes/` with SEO metadata for sitemap:");
+  lines.push("```typescript");
+  lines.push("import { defineRoute } from '@djangocfg/nextjs/navigation';");
+  lines.push("");
+  lines.push("export const home = defineRoute('/', {");
+  lines.push("  label: 'Home',");
+  lines.push("  protected: false,");
+  lines.push("  priority: 1.0,        // Sitemap priority 0.0-1.0");
+  lines.push("  changefreq: 'daily',  // always|hourly|daily|weekly|monthly|yearly|never");
+  lines.push("  noindex: false,       // Exclude from sitemap");
+  lines.push("});");
+  lines.push("");
+  lines.push("export const staticRoutes = [home, about, contact];");
+  lines.push("```");
+  lines.push("");
+  lines.push("Then in `sitemap.xml/route.ts`:");
+  lines.push("```typescript");
+  lines.push("import { routes } from '@/app/_routes';");
+  lines.push("routes.getAllStaticRoutes().filter(r => !r.metadata.noindex)");
+  lines.push("```");
+  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("");
-  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}`);
+  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("");
-  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("### 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(
-    `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("### 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("");
-  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 = {}) {
@@ -2058,189 +2241,6 @@ 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("## SEO Files (Next.js App Router)");
-  lines.push("");
-  lines.push("**Required files in `app/`:**");
-  lines.push("");
-  lines.push("### sitemap.xml/route.ts");
-  lines.push("```typescript");
-  lines.push("import { createSitemapHandler } from '@djangocfg/nextjs/sitemap';");
-  lines.push("");
-  lines.push('export const dynamic = "force-static";');
-  lines.push("export const { GET } = createSitemapHandler({");
-  lines.push("  siteUrl,");
-  lines.push("  staticPages: [");
-  lines.push('    { loc: "/", priority: 1.0, changefreq: "daily" },');
-  lines.push('    { loc: "/about", priority: 0.8 },');
-  lines.push("  ],");
-  lines.push("  dynamicPages: async () => fetchPagesFromAPI(),");
-  lines.push("});");
-  lines.push("```");
-  lines.push("");
-  lines.push("### robots.ts");
-  lines.push("```typescript");
-  lines.push("import type { MetadataRoute } from 'next';");
-  lines.push("");
-  lines.push("export default function robots(): MetadataRoute.Robots {");
-  lines.push("  return {");
-  lines.push('    rules: { userAgent: "*", allow: "/" },');
-  lines.push("    sitemap: `${siteUrl}/sitemap.xml`,");
-  lines.push("  };");
-  lines.push("}");
-  lines.push("```");
-  lines.push("");
-  lines.push("### Cloudflare Override");
-  lines.push("");
-  lines.push('If robots.txt shows "Content-Signal" or "ai-train" \u2014 Cloudflare is overriding your file.');
-  lines.push('**Fix:** Dashboard \u2192 Security \u2192 Settings \u2192 "Manage your robots.txt" \u2192 Set to "Off"');
-  lines.push("");
-  lines.push("### Declarative Routes with SEO");
-  lines.push("");
-  lines.push("Create `app/_routes/` with SEO metadata for sitemap:");
-  lines.push("```typescript");
-  lines.push("import { defineRoute } from '@djangocfg/nextjs/navigation';");
-  lines.push("");
-  lines.push("export const home = defineRoute('/', {");
-  lines.push("  label: 'Home',");
-  lines.push("  protected: false,");
-  lines.push("  priority: 1.0,        // Sitemap priority 0.0-1.0");
-  lines.push("  changefreq: 'daily',  // always|hourly|daily|weekly|monthly|yearly|never");
-  lines.push("  noindex: false,       // Exclude from sitemap");
-  lines.push("});");
-  lines.push("");
-  lines.push("export const staticRoutes = [home, about, contact];");
-  lines.push("```");
-  lines.push("");
-  lines.push("Then in `sitemap.xml/route.ts`:");
-  lines.push("```typescript");
-  lines.push("import { routes } from '@/app/_routes';");
-  lines.push("routes.getAllStaticRoutes().filter(r => !r.metadata.noindex)");
-  lines.push("```");
-  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 {
@@ -2278,7 +2278,7 @@ async function generateAndSaveReports(siteUrl, data, options) {
     const content = exportJsonReport(report, true);
     writeFileSync(filepath, content, "utf-8");
     result.files.json = filepath;
-    consola3.success(`JSON report saved: ${filepath}`);
+    consola6.success(`JSON report saved: ${filepath}`);
   }
   if (formats.includes("markdown")) {
     const filename = `seo-report-${siteName}${ts}.md`;
@@ -2289,7 +2289,7 @@ async function generateAndSaveReports(siteUrl, data, options) {
     });
     writeFileSync(filepath, content, "utf-8");
     result.files.markdown = filepath;
-    consola3.success(`Markdown report saved: ${filepath}`);
+    consola6.success(`Markdown report saved: ${filepath}`);
   }
   if (formats.includes("ai-summary")) {
     const filename = `seo-ai-summary-${siteName}${ts}.md`;
@@ -2297,7 +2297,7 @@ async function generateAndSaveReports(siteUrl, data, options) {
     const content = generateAiSummary(report);
     writeFileSync(filepath, content, "utf-8");
     result.files.aiSummary = filepath;
-    consola3.success(`AI summary saved: ${filepath}`);
+    consola6.success(`AI summary saved: ${filepath}`);
   }
   if (formats.includes("split")) {
     const splitResult = generateSplitReports(report, {
@@ -2309,16 +2309,16 @@ async function generateAndSaveReports(siteUrl, data, options) {
       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)`);
+    consola6.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}`);
+  consola6.success(`AI context saved: ${claudeFilepath}`);
   return result;
 }
 function printReportSummary(report) {
-  consola3.box(
+  consola6.box(
     `SEO Report: ${report.siteUrl}
 Health Score: ${report.summary.healthScore}/100
 Total URLs: ${report.summary.totalUrls}
@@ -2326,18 +2326,18 @@ Indexed: ${report.summary.indexedUrls} | Not Indexed: ${report.summary.notIndexe
 Issues: ${report.issues.length}`
   );
   if (report.summary.issuesBySeverity.critical) {
-    consola3.error(`Critical issues: ${report.summary.issuesBySeverity.critical}`);
+    consola6.error(`Critical issues: ${report.summary.issuesBySeverity.critical}`);
   }
   if (report.summary.issuesBySeverity.error) {
-    consola3.warn(`Errors: ${report.summary.issuesBySeverity.error}`);
+    consola6.warn(`Errors: ${report.summary.issuesBySeverity.error}`);
   }
   if (report.summary.issuesBySeverity.warning) {
-    consola3.info(`Warnings: ${report.summary.issuesBySeverity.warning}`);
+    consola6.info(`Warnings: ${report.summary.issuesBySeverity.warning}`);
   }
-  consola3.log("");
-  consola3.info("Top recommendations:");
+  consola6.log("");
+  consola6.info("Top recommendations:");
   for (const rec of report.recommendations.slice(0, 3)) {
-    consola3.log(`  ${rec.priority}. ${rec.title} (${rec.affectedUrls.length} URLs)`);
+    consola6.log(`  ${rec.priority}. ${rec.title} (${rec.affectedUrls.length} URLs)`);
   }
 }
 var PAGE_FILES = ["page.tsx", "page.ts", "page.jsx", "page.js"];
@@ -2660,7 +2660,7 @@ async function runAudit(options) {
   const siteUrl = getSiteUrl(options);
   const startTime = Date.now();
   console.log("");
-  consola3.box(`${chalk2.bold("SEO Audit")}
+  consola6.box(`${chalk2.bold("SEO Audit")}
 ${siteUrl}`);
   const serviceAccountPath = findGoogleServiceAccount(options["service-account"]);
   const hasGsc = !!serviceAccountPath;
@@ -2669,7 +2669,7 @@ ${siteUrl}`);
   if (!serviceAccountPath) {
     const keyFile = getGscKeyFilename();
     console.log("");
-    consola3.info(chalk2.dim("GSC not configured. Save service account as " + chalk2.cyan(keyFile) + " for indexing data."));
+    consola6.info(chalk2.dim("GSC not configured. Save service account as " + chalk2.cyan(keyFile) + " for indexing data."));
   }
   const allIssues = [];
   const allInspections = [];
@@ -2722,7 +2722,7 @@ ${siteUrl}`);
         for (const a of analyses) {
           issues.push(...a.issues);
           totalUrls += a.urls.length;
-          collectedSitemapUrls.push(...a.urls.map((u) => u.loc));
+          collectedSitemapUrls.push(...a.urls);
         }
       }
       updateProgress("Sitemap", "done");
@@ -2812,18 +2812,18 @@ ${siteUrl}`);
   if (errors.length > 0) {
     console.log("");
     for (const err of errors) {
-      consola3.error(err);
+      consola6.error(err);
     }
   }
   console.log("");
-  consola3.log(chalk2.bold("Results:"));
+  consola6.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}`);
+    consola6.log(`  ${r.name}: ${issueStr}${metaStr}`);
   }
   console.log("");
-  consola3.start("Generating reports...");
+  consola6.start("Generating reports...");
   const formats = parseFormats(options.format);
   const { report, files } = await generateAndSaveReports(
     siteUrl,
@@ -2842,36 +2842,36 @@ ${siteUrl}`);
   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}`);
+  consola6.info(`Reports saved to: ${chalk2.cyan(options.output)}`);
+  if (files.json) consola6.log(`  ${chalk2.dim("\u2192")} ${files.json}`);
+  if (files.markdown) consola6.log(`  ${chalk2.dim("\u2192")} ${files.markdown}`);
+  if (files.aiSummary) consola6.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`);
+    consola6.log(`  ${chalk2.dim("\u2192")} ${files.split.index} ${chalk2.dim("(index)")}`);
+    consola6.log(`  ${chalk2.dim("\u2192")} ${files.split.categories.length} category files`);
   }
   console.log("");
-  consola3.success(`Audit completed in ${duration}s`);
+  consola6.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.");
+    consola6.error("Could not find app/ directory. Use --app-dir to specify path.");
     process.exit(1);
   }
   console.log("");
-  consola3.box(`${chalk2.bold("Routes Scanner")}
+  consola6.box(`${chalk2.bold("Routes Scanner")}
 ${appDir}`);
-  consola3.start("Scanning app/ directory...");
+  consola6.start("Scanning app/ directory...");
   const scanResult = scanRoutes({ appDir });
-  consola3.success(`Found ${scanResult.routes.length} routes`);
+  consola6.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:");
+    consola6.info("Static routes:");
     for (const route of scanResult.staticRoutes.slice(0, 20)) {
       console.log(`  ${chalk2.green("\u2192")} ${route.path}`);
     }
@@ -2881,7 +2881,7 @@ ${appDir}`);
   }
   if (scanResult.dynamicRoutes.length > 0) {
     console.log("");
-    consola3.info("Dynamic routes:");
+    consola6.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}]`)}`);
@@ -2892,21 +2892,21 @@ ${appDir}`);
   }
   if (options.check) {
     console.log("");
-    consola3.start("Loading sitemap...");
+    consola6.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 sitemapUrls = sitemap.urls;
+      consola6.success(`Loaded ${sitemapUrls.length} URLs from sitemap`);
       const comparison = compareWithSitemap(scanResult, sitemapUrls, siteUrl);
       console.log("");
-      consola3.info("Sitemap comparison:");
+      consola6.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:");
+        consola6.warn("Routes missing from sitemap:");
         for (const route of comparison.missingFromSitemap.slice(0, 10)) {
           console.log(`  ${chalk2.red("\u2717")} ${route.path}`);
         }
@@ -2915,12 +2915,12 @@ ${appDir}`);
         }
       }
     } catch (error) {
-      consola3.error(`Failed to load sitemap: ${error.message}`);
+      consola6.error(`Failed to load sitemap: ${error.message}`);
     }
   }
   if (options.verify) {
     console.log("");
-    consola3.start("Verifying routes...");
+    consola6.start("Verifying routes...");
     const verification = await verifyRoutes(scanResult, {
       baseUrl: siteUrl,
       timeout: parseInt(options.timeout, 10),
@@ -2929,12 +2929,12 @@ ${appDir}`);
     });
     const accessible = verification.filter((r) => r.isAccessible);
     const broken = verification.filter((r) => !r.isAccessible);
-    consola3.success(`Verified ${verification.length} routes`);
+    consola6.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:");
+      consola6.error("Broken routes:");
       for (const r of broken.slice(0, 10)) {
         console.log(`  ${chalk2.red("\u2717")} ${r.route.path} \u2192 ${r.statusCode || r.error}`);
       }
@@ -2957,22 +2957,22 @@ function loadUrlsFromFile(filePath) {
 // src/cli/commands/inspect.ts
 async function runInspect(options) {
   const siteUrl = getSiteUrl(options);
-  consola3.start("Starting URL inspection via Google Search Console");
+  consola6.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");
+    consola6.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}`);
+    consola6.info(`Loaded ${urls.length} URLs from ${options.urls}`);
   } else {
-    consola3.info("Fetching URLs from search analytics...");
+    consola6.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({
@@ -2982,11 +2982,11 @@ async function runInspect(options) {
       rowLimit: 100
     });
     urls = rows.map((row) => row.keys?.[0] || "").filter(Boolean);
-    consola3.info(`Found ${urls.length} URLs from search analytics`);
+    consola6.info(`Found ${urls.length} URLs from search analytics`);
   }
   const results = await client.inspectUrls(urls);
   const issues = analyzeInspectionResults(results);
-  consola3.info(`Found ${issues.length} issues`);
+  consola6.info(`Found ${issues.length} issues`);
   const formats = parseFormats(options.format);
   await generateAndSaveReports(siteUrl, { issues, urlInspections: results }, {
     outputDir: options.output,
@@ -2996,14 +2996,14 @@ async function runInspect(options) {
 }
 async function runCrawl(options) {
   const siteUrl = getSiteUrl(options);
-  consola3.start(`Starting crawl of ${siteUrl}`);
+  consola6.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`);
+  consola6.info(`Found ${issues.length} issues from ${crawlResults.length} pages`);
   const formats = parseFormats(options.format);
   await generateAndSaveReports(siteUrl, { issues, crawlResults }, {
     outputDir: options.output,
@@ -3013,7 +3013,7 @@ async function runCrawl(options) {
 }
 async function runLinks(options) {
   const siteUrl = getSiteUrl(options);
-  consola3.start(`Checking links on ${siteUrl}`);
+  consola6.start(`Checking links on ${siteUrl}`);
   const result = await checkLinks({
     url: siteUrl,
     timeout: parseInt(options.timeout, 10),
@@ -3021,9 +3021,9 @@ async function runLinks(options) {
     verbose: true
   });
   if (result.success) {
-    consola3.success(`All ${result.total} links are valid!`);
+    consola6.success(`All ${result.total} links are valid!`);
   } else {
-    consola3.error(`Found ${result.broken} broken links out of ${result.total}`);
+    consola6.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);
@@ -3038,24 +3038,24 @@ async function runLinks(options) {
 }
 async function runRobots(options) {
   const siteUrl = getSiteUrl(options);
-  consola3.start(`Analyzing robots.txt for ${siteUrl}`);
+  consola6.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}`);
+    consola6.success("robots.txt found");
+    consola6.info(`Sitemaps: ${analysis.sitemaps.length}`);
+    consola6.info(`Disallow rules: ${analysis.disallowedPaths.length}`);
+    consola6.info(`Allow rules: ${analysis.allowedPaths.length}`);
     if (analysis.crawlDelay) {
-      consola3.info(`Crawl-delay: ${analysis.crawlDelay}`);
+      consola6.info(`Crawl-delay: ${analysis.crawlDelay}`);
     }
     if (analysis.issues.length > 0) {
-      consola3.warn(`Issues found: ${analysis.issues.length}`);
+      consola6.warn(`Issues found: ${analysis.issues.length}`);
       for (const issue of analysis.issues) {
-        consola3.log(`  - [${issue.severity}] ${issue.title}`);
+        consola6.log(`  - [${issue.severity}] ${issue.title}`);
       }
     }
   } else {
-    consola3.warn("robots.txt not found");
+    consola6.warn("robots.txt not found");
   }
 }
 async function runSitemap(options) {
@@ -3063,31 +3063,31 @@ async function runSitemap(options) {
   if (!sitemapUrl.endsWith(".xml")) {
     sitemapUrl = new URL("/sitemap.xml", sitemapUrl).href;
   }
-  consola3.start(`Validating sitemap: ${sitemapUrl}`);
+  consola6.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}`);
+      consola6.success(`${analysis.url}`);
+      consola6.info(`  Type: ${analysis.type}`);
       if (analysis.type === "sitemap") {
-        consola3.info(`  URLs: ${analysis.urls.length}`);
+        consola6.info(`  URLs: ${analysis.urls.length}`);
         totalUrls += analysis.urls.length;
       } else {
-        consola3.info(`  Child sitemaps: ${analysis.childSitemaps.length}`);
+        consola6.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}`);
+          consola6.warn(`  [${issue.severity}] ${issue.title}`);
         }
       }
     } else {
-      consola3.error(`${analysis.url} - Not found`);
+      consola6.error(`${analysis.url} - Not found`);
     }
   }
-  consola3.box(`Total URLs: ${totalUrls}
+  consola6.box(`Total URLs: ${totalUrls}
 Total Issues: ${totalIssues}`);
 }
 function detectProjectType(cwd) {
@@ -3632,7 +3632,7 @@ ${chalk2.bold("Examples:")}
   djangocfg-seo content sitemap --output app/_core/sitemap.ts
 `;
 async function runContent(options) {
-  const subcommand = options._[1];
+  const subcommand = options._?.[1];
   if (!subcommand || subcommand === "help") {
     console.log(CONTENT_HELP);
     return;
@@ -3640,12 +3640,12 @@ async function runContent(options) {
   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.");
+    consola6.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")}
+  consola6.box(`${chalk2.bold("Content Tools")}
 Project: ${projectType}
 Path: ${contentDir || cwd}`);
   switch (subcommand) {
@@ -3659,23 +3659,23 @@ Path: ${contentDir || cwd}`);
       await runSitemapGenerate(cwd, options);
       break;
     default:
-      consola3.error(`Unknown subcommand: ${subcommand}`);
+      consola6.error(`Unknown subcommand: ${subcommand}`);
       console.log(CONTENT_HELP);
       process.exit(1);
   }
 }
 async function runCheck(contentDir, options) {
-  consola3.start("Checking links in content/ folder...");
+  consola6.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!");
+    consola6.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:`);
+  consola6.error(`Found ${result.brokenLinks.length} broken links:`);
   console.log("");
   const byFile = groupBrokenLinksByFile(result.brokenLinks);
   for (const [file, links] of byFile) {
@@ -3691,11 +3691,11 @@ async function runCheck(contentDir, options) {
 }
 async function runFix(contentDir, options) {
   const applyFixes2 = options.fix === true;
-  consola3.start(applyFixes2 ? "Fixing links..." : "Checking for absolute links that can be relative...");
+  consola6.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.");
+    consola6.success("No absolute links that can be converted to relative.");
     return;
   }
   console.log("");
@@ -3709,14 +3709,14 @@ async function runFix(contentDir, options) {
     console.log("");
   }
   if (applyFixes2) {
-    consola3.success(`Fixed ${result.totalChanges} links in ${result.fileChanges.length} files.`);
+    consola6.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...");
+  consola6.start("Generating sitemap...");
   const rawOutput = options.output;
   const output = rawOutput?.endsWith(".ts") ? rawOutput : "app/_core/sitemap.ts";
   const contentDir = options["content-dir"] || "content";
@@ -3727,7 +3727,7 @@ async function runSitemapGenerate(cwd, options) {
   });
   const counts = countSitemapItems(data);
   console.log("");
-  consola3.success(`Sitemap generated at ${outputPath}`);
+  consola6.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}`);
@@ -3852,15 +3852,15 @@ async function main() {
         await runContent(options);
         break;
       default:
-        consola3.error(`Unknown command: ${command}`);
+        consola6.error(`Unknown command: ${command}`);
         console.log(HELP);
         process.exit(1);
     }
   } catch (error) {
-    consola3.error(error);
+    consola6.error(error);
     process.exit(1);
   }
 }
-main().catch(consola3.error);
+main().catch(consola6.error);
 //# sourceMappingURL=cli.mjs.map
 //# sourceMappingURL=cli.mjs.map