crawlemon 0.1.0

package/dist/index.js

@@ -0,0 +1,1986 @@
+// src/index.ts
+import fs3 from "node:fs";
+import path4 from "node:path";
+import { spawnSync } from "node:child_process";
+
+// ../next-adapter/src/parser.ts
+function parsePageSource(content) {
+  const metadata = {};
+  const headings = [];
+  const images = [];
+  const links = [];
+  const lineAt = (index) => content.slice(0, index).split("\n").length;
+  const titleMatch = content.match(/title\s*:\s*["'`]([^"'`]+)["'`]/) || content.match(/title\s*:\s*\{[\s\S]*?default\s*:\s*["'`]([^"'`]+)["'`]/) || content.match(/<title[^>]*>([^<]+)<\/title>/i);
+  if (titleMatch) {
+    metadata.title = titleMatch[1].trim();
+  }
+  const descMatch = content.match(/description\s*:\s*["'`]([^"'`]+)["'`]/) || content.match(/<meta[^>]*name=["']description["'][^>]*content=["']([^"']+)["']/i) || content.match(/<meta[^>]*content=["']([^"']+)["'][^>]*name=["']description["']/i);
+  if (descMatch) {
+    metadata.description = descMatch[1].trim();
+  }
+  const canonicalMatch = content.match(/canonical\s*:\s*["'`]([^"'`]+)["'`]/) || content.match(/<link[^>]*rel=["']canonical["'][^>]*href=["']([^"']+)["']/i);
+  if (canonicalMatch) {
+    metadata.canonical = canonicalMatch[1].trim();
+  }
+  const robotsMatch = content.match(/robots\s*:\s*["'`]([^"'`]+)["'`]/) || content.match(/<meta[^>]*name=["']robots["'][^>]*content=["']([^"']+)["']/i);
+  if (robotsMatch) {
+    metadata.robots = robotsMatch[1].trim();
+  }
+  const jsonLdMatches = content.matchAll(/<script[^>]*type=["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi);
+  const jsonLd = [];
+  for (const match of jsonLdMatches) {
+    try {
+      const parsed = JSON.parse(match[1].trim());
+      jsonLd.push(parsed);
+    } catch {
+      jsonLd.push({ invalid: true });
+    }
+  }
+  if (jsonLd.length > 0) {
+    metadata.jsonLd = jsonLd;
+  }
+  const declarationCount = [
+    /export\s+const\s+metadata\b/.test(content),
+    /export\s+(?:async\s+)?function\s+generateMetadata\b/.test(content),
+    /<Head\b/.test(content)
+  ].filter(Boolean).length;
+  metadata.hasConflictingDeclarations = declarationCount > 1;
+  for (const match of content.matchAll(/<h([1-6])\b[^>]*>([\s\S]*?)<\/h\1>/gi)) {
+    headings.push({
+      level: parseInt(match[1], 10),
+      text: match[2].replace(/<[^>]+>/g, "").replace(/[{}]/g, "").trim(),
+      line: lineAt(match.index || 0)
+    });
+  }
+  for (const match of content.matchAll(/<(img|Image)\b([^>]*?)\/?>/g)) {
+    const attrs = match[2];
+    const srcMatch = attrs.match(/src\s*=\s*["'`]([^"'`]+)["'`]/);
+    const altMatch = attrs.match(/alt\s*=\s*["'`]([^"'`]*?)["'`]/);
+    images.push({
+      src: srcMatch ? srcMatch[1] : "unknown-image",
+      alt: altMatch ? altMatch[1] : void 0,
+      isNextImage: match[1] === "Image",
+      line: lineAt(match.index || 0)
+    });
+  }
+  for (const match of content.matchAll(/<(a|Link)\b[^>]*?href\s*=\s*["']([^"']+)["'][^>]*>([\s\S]*?)<\/\1>/g)) {
+    const href = match[2].trim();
+    const anchorRaw = match[3].replace(/<[^>]+>/g, "").replace(/[{}]/g, "").trim();
+    const isInternal = href.startsWith("/") || !/^(https?:|mailto:|tel:|javascript:)/i.test(href);
+    links.push({
+      href,
+      anchorText: anchorRaw || "(empty anchor)",
+      line: lineAt(match.index || 0),
+      isInternal
+    });
+  }
+  const cleanBodyText = content.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+  const words = cleanBodyText.split(/\s+/).filter((w) => w.length > 2);
+  const hasLittleContent = words.length < 20;
+  return {
+    metadata,
+    headings,
+    images,
+    links,
+    textContent: cleanBodyText,
+    hasLittleContent
+  };
+}
+
+// ../next-adapter/src/scanner.ts
+import fs from "node:fs";
+import path from "node:path";
+function normalizeRouteGroup(segment) {
+  return segment.startsWith("(") && segment.endsWith(")") ? "" : segment;
+}
+var NextJsAdapter = class {
+  /**
+   * Detects if the given directory contains a Next.js application.
+   */
+  static async detect(projectRoot) {
+    const pkgPath = path.join(projectRoot, "package.json");
+    if (fs.existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+        const deps = { ...pkg.dependencies || {}, ...pkg.devDependencies || {} };
+        if (deps.next) return true;
+      } catch {
+      }
+    }
+    return fs.existsSync(path.join(projectRoot, "app")) || fs.existsSync(path.join(projectRoot, "src", "app")) || fs.existsSync(path.join(projectRoot, "pages")) || fs.existsSync(path.join(projectRoot, "src", "pages")) || fs.existsSync(path.join(projectRoot, "next.config.js")) || fs.existsSync(path.join(projectRoot, "next.config.mjs"));
+  }
+  /**
+   * Loads optional seo.config.ts or returns default configuration.
+   */
+  static async loadConfig(projectRoot) {
+    const configCandidates = [
+      path.join(projectRoot, "seo.config.ts"),
+      path.join(projectRoot, "seo.config.js"),
+      path.join(projectRoot, "seo.config.json")
+    ];
+    for (const candidate of configCandidates) {
+      if (fs.existsSync(candidate)) {
+        try {
+          if (candidate.endsWith(".json")) {
+            return JSON.parse(fs.readFileSync(candidate, "utf8"));
+          }
+          const content = fs.readFileSync(candidate, "utf8");
+          const siteUrlMatch = content.match(/siteUrl\s*:\s*["']([^"']+)["']/);
+          const ignoreMatch = content.match(/ignore\s*:\s*\[([\s\S]*?)\]/);
+          const ignore = ignoreMatch ? Array.from(ignoreMatch[1].matchAll(/["']([^"']+)["']/g), (match) => match[1]) : void 0;
+          const rulesMatch = content.match(/rules\s*:\s*\{([\s\S]*?)\}/);
+          const rules = {};
+          if (rulesMatch) {
+            for (const match of rulesMatch[1].matchAll(/([A-Za-z][A-Za-z0-9_-]*)\s*:\s*(true|false)/g)) {
+              rules[match[1]] = match[2] === "true";
+            }
+          }
+          return {
+            siteUrl: siteUrlMatch ? siteUrlMatch[1] : void 0,
+            ignore,
+            rules
+          };
+        } catch {
+        }
+      }
+    }
+    return {
+      siteUrl: void 0,
+      ignore: ["/admin/**", "/api/**"]
+    };
+  }
+  /**
+   * Scans project directory and builds complete route inventory.
+   */
+  static async scan(projectRoot) {
+    const isNext = await this.detect(projectRoot);
+    const config = await this.loadConfig(projectRoot);
+    let appDir = path.join(projectRoot, "app");
+    if (!fs.existsSync(appDir) && fs.existsSync(path.join(projectRoot, "src", "app"))) {
+      appDir = path.join(projectRoot, "src", "app");
+    }
+    let pagesDir = path.join(projectRoot, "pages");
+    if (!fs.existsSync(pagesDir) && fs.existsSync(path.join(projectRoot, "src", "pages"))) {
+      pagesDir = path.join(projectRoot, "src", "pages");
+    }
+    const isAppRouter = fs.existsSync(appDir);
+    const routes = [];
+    const redirects = [];
+    for (const configName of ["next.config.js", "next.config.mjs", "next.config.ts"]) {
+      const configPath = path.join(projectRoot, configName);
+      if (!fs.existsSync(configPath)) continue;
+      const content = fs.readFileSync(configPath, "utf8");
+      for (const match of content.matchAll(/source\s*:\s*["'`]([^"'`]+)["'`][\s\S]{0,500}?destination\s*:\s*["'`]([^"'`]+)["'`][\s\S]{0,200}?permanent\s*:\s*(true|false)/g)) {
+        redirects.push({ source: match[1], destination: match[2], permanent: match[3] === "true" });
+      }
+      break;
+    }
+    let rootLayoutMetadata = {};
+    if (isAppRouter) {
+      const layoutFileCandidates = [
+        path.join(appDir, "layout.tsx"),
+        path.join(appDir, "layout.jsx"),
+        path.join(appDir, "layout.js")
+      ];
+      for (const layoutFile of layoutFileCandidates) {
+        if (fs.existsSync(layoutFile)) {
+          const content = fs.readFileSync(layoutFile, "utf8");
+          const parsed = parsePageSource(content);
+          rootLayoutMetadata = parsed.metadata;
+          break;
+        }
+      }
+    }
+    if (isAppRouter) {
+      const scanAppDir = (currentDir, relativePath = "") => {
+        const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+          const fullPath = path.join(currentDir, entry.name);
+          if (entry.isDirectory()) {
+            if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "api") {
+              continue;
+            }
+            const normalized = normalizeRouteGroup(entry.name);
+            const nextRelative = normalized ? path.join(relativePath, normalized) : relativePath;
+            scanAppDir(fullPath, nextRelative);
+          } else if (entry.isFile()) {
+            if (/^page\.(tsx|jsx|js|ts)$/.test(entry.name)) {
+              const routePath = relativePath === "" ? "/" : `/${relativePath.replace(/\\/g, "/")}`;
+              const content = fs.readFileSync(fullPath, "utf8");
+              const parsed = parsePageSource(content);
+              routes.push({
+                route: routePath,
+                filePath: fullPath,
+                metadata: {
+                  ...rootLayoutMetadata,
+                  ...parsed.metadata
+                },
+                headings: parsed.headings,
+                images: parsed.images,
+                links: parsed.links,
+                textContent: parsed.textContent,
+                hasLittleContent: parsed.hasLittleContent,
+                hasDynamicSegments: routePath.includes("[")
+              });
+            }
+          }
+        }
+      };
+      scanAppDir(appDir);
+    }
+    if (fs.existsSync(pagesDir)) {
+      const scanPagesDir = (currentDir, relativePath = "") => {
+        const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+          const fullPath = path.join(currentDir, entry.name);
+          if (entry.isDirectory()) {
+            if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "api") {
+              continue;
+            }
+            scanPagesDir(fullPath, path.join(relativePath, entry.name));
+          } else if (entry.isFile()) {
+            if (/\.(tsx|jsx|js)$/.test(entry.name)) {
+              const baseName = entry.name.replace(/\.(tsx|jsx|js)$/, "");
+              if (baseName.startsWith("_") || baseName === "api") {
+                continue;
+              }
+              let routePath = `/${path.join(relativePath, baseName === "index" ? "" : baseName).replace(/\\/g, "/")}`;
+              if (routePath === "//" || routePath === "") routePath = "/";
+              const content = fs.readFileSync(fullPath, "utf8");
+              const parsed = parsePageSource(content);
+              routes.push({
+                route: routePath,
+                filePath: fullPath,
+                metadata: parsed.metadata,
+                headings: parsed.headings,
+                images: parsed.images,
+                links: parsed.links,
+                textContent: parsed.textContent,
+                hasLittleContent: parsed.hasLittleContent,
+                hasDynamicSegments: routePath.includes("[")
+              });
+            }
+          }
+        }
+      };
+      scanPagesDir(pagesDir);
+    }
+    const sitemapCandidates = [
+      path.join(appDir, "sitemap.ts"),
+      path.join(appDir, "sitemap.js"),
+      path.join(projectRoot, "public", "sitemap.xml")
+    ];
+    let sitemapFound = false;
+    let sitemapMalformed = false;
+    const sitemapUrls = [];
+    for (const candidate of sitemapCandidates) {
+      if (fs.existsSync(candidate)) {
+        sitemapFound = true;
+        const content = fs.readFileSync(candidate, "utf8");
+        if (candidate.endsWith(".xml") && (!/<urlset\b/i.test(content) || !/<loc>[^<]+<\/loc>/i.test(content))) {
+          sitemapMalformed = true;
+        }
+        const urlMatches = content.matchAll(/url\s*:\s*['"`]([^'"`]+)['"`]|<loc>([^<]+)<\/loc>/gi);
+        for (const m of urlMatches) {
+          const url = m[1] || m[2];
+          if (url) sitemapUrls.push(url.trim());
+        }
+        break;
+      }
+    }
+    const robotsCandidates = [
+      path.join(appDir, "robots.ts"),
+      path.join(appDir, "robots.js"),
+      path.join(projectRoot, "public", "robots.txt")
+    ];
+    const robotsFile = robotsCandidates.find((candidate) => fs.existsSync(candidate));
+    const robotsFound = Boolean(robotsFile);
+    const robotsContent = robotsFile ? fs.readFileSync(robotsFile, "utf8") : "";
+    routes.sort((a, b) => a.route.localeCompare(b.route));
+    return {
+      isNextJs: isNext,
+      isAppRouter,
+      routes,
+      sitemapFound,
+      sitemapUrls,
+      sitemapMalformed,
+      robotsFound,
+      robotsContent,
+      redirects,
+      config,
+      projectRoot
+    };
+  }
+};
+
+// ../core/src/rules/metadata-title.ts
+var metadataTitleRule = {
+  id: "metadata-title",
+  name: "Page Title Validation",
+  category: "metadata",
+  analyze(context) {
+    const findings = [];
+    const titleMap = /* @__PURE__ */ new Map();
+    for (const route of context.routes) {
+      const title = route.metadata.title;
+      if (!title || title.trim() === "") {
+        findings.push({
+          id: `title-missing-${route.route}`,
+          rule: "metadata-title",
+          severity: "error",
+          category: "metadata",
+          message: `Missing or empty <title> metadata for route "${route.route}".`,
+          file: route.filePath,
+          route: route.route,
+          fixable: false,
+          explanation: "Search engines rely on page titles to understand context and display search snippets. Missing titles critically harm click-through rates."
+        });
+        continue;
+      }
+      const trimmed = title.trim();
+      const existing = titleMap.get(trimmed) || [];
+      existing.push(route.route);
+      titleMap.set(trimmed, existing);
+      if (trimmed.length < 10) {
+        findings.push({
+          id: `title-short-${route.route}`,
+          rule: "metadata-title",
+          severity: "warning",
+          category: "metadata",
+          message: `Page title is suspiciously short (${trimmed.length} chars) on "${route.route}". Recommended: 30-60 characters.`,
+          file: route.filePath,
+          route: route.route,
+          fixable: false,
+          explanation: "Titles shorter than 10 characters lack sufficient topical context for ranking."
+        });
+      } else if (trimmed.length > 65) {
+        findings.push({
+          id: `title-long-${route.route}`,
+          rule: "metadata-title",
+          severity: "warning",
+          category: "metadata",
+          message: `Page title is suspiciously long (${trimmed.length} chars) on "${route.route}". Recommended: under 65 characters to prevent truncation.`,
+          file: route.filePath,
+          route: route.route,
+          fixable: false,
+          explanation: "Search engine result pages (SERPs) typically truncate titles exceeding ~60-65 characters."
+        });
+      }
+    }
+    for (const [title, routes] of titleMap.entries()) {
+      if (routes.length > 1) {
+        for (const r of routes) {
+          findings.push({
+            id: `title-duplicate-${r}`,
+            rule: "metadata-title",
+            severity: "error",
+            category: "metadata",
+            message: `Duplicate title "${title}" shared across multiple routes (${routes.join(", ")}).`,
+            route: r,
+            fixable: false,
+            explanation: "Every indexable page should have a unique, descriptive title to avoid keyword cannibalization."
+          });
+        }
+      }
+    }
+    return findings;
+  }
+};
+
+// ../core/src/rules/metadata-description.ts
+var metadataDescriptionRule = {
+  id: "metadata-description",
+  name: "Meta Description Validation",
+  category: "metadata",
+  analyze(context) {
+    const findings = [];
+    const descMap = /* @__PURE__ */ new Map();
+    for (const route of context.routes) {
+      const desc = route.metadata.description;
+      if (!desc || desc.trim() === "") {
+        findings.push({
+          id: `desc-missing-${route.route}`,
+          rule: "metadata-description",
+          severity: "warning",
+          category: "metadata",
+          message: `Missing meta description on route "${route.route}".`,
+          file: route.filePath,
+          route: route.route,
+          fixable: false,
+          explanation: "Meta descriptions provide the summary text displayed under your title in search results, directly influencing organic CTR."
+        });
+        continue;
+      }
+      const trimmed = desc.trim();
+      const existing = descMap.get(trimmed) || [];
+      existing.push(route.route);
+      descMap.set(trimmed, existing);
+      if (trimmed.length < 50) {
+        findings.push({
+          id: `desc-short-${route.route}`,
+          rule: "metadata-description",
+          severity: "info",
+          category: "metadata",
+          message: `Meta description is very short (${trimmed.length} chars) on "${route.route}". Ideal length: 120-160 characters.`,
+          file: route.filePath,
+          route: route.route,
+          fixable: false,
+          explanation: "Descriptions under 50 characters rarely provide enough context to attract user clicks."
+        });
+      } else if (trimmed.length > 165) {
+        findings.push({
+          id: `desc-long-${route.route}`,
+          rule: "metadata-description",
+          severity: "info",
+          category: "metadata",
+          message: `Meta description is long (${trimmed.length} chars) on "${route.route}" and will likely be truncated on SERPs.`,
+          file: route.filePath,
+          route: route.route,
+          fixable: false,
+          explanation: "Google usually truncates descriptions beyond 155-160 characters on desktop and mobile."
+        });
+      }
+    }
+    for (const [desc, routes] of descMap.entries()) {
+      if (routes.length > 1) {
+        for (const r of routes) {
+          findings.push({
+            id: `desc-duplicate-${r}`,
+            rule: "metadata-description",
+            severity: "warning",
+            category: "metadata",
+            message: `Duplicate meta description shared across routes (${routes.join(", ")}).`,
+            route: r,
+            fixable: false,
+            explanation: "Each page should feature a unique description summarizing its specific content."
+          });
+        }
+      }
+    }
+    return findings;
+  }
+};
+
+// ../core/src/rules/canonical.ts
+var canonicalRule = {
+  id: "canonical",
+  name: "Canonical URL Validation",
+  category: "technical",
+  analyze(context) {
+    const findings = [];
+    let expectedDomain = null;
+    let configuredSiteUrl = null;
+    const canonicalRoutes = /* @__PURE__ */ new Map();
+    if (context.config.siteUrl) {
+      try {
+        configuredSiteUrl = new URL(context.config.siteUrl);
+        if (!["http:", "https:"].includes(configuredSiteUrl.protocol)) throw new Error("Unsupported siteUrl protocol");
+        expectedDomain = configuredSiteUrl.hostname;
+      } catch {
+        findings.push({
+          id: "canonical-config-site-url-invalid",
+          rule: "canonical",
+          severity: "error",
+          category: "technical",
+          message: `Configured siteUrl "${context.config.siteUrl}" is not a valid absolute URL.`,
+          fixable: false
+        });
+      }
+    }
+    for (const route of context.routes) {
+      const canonical = route.metadata.canonical;
+      if (!canonical || canonical.trim() === "") {
+        findings.push({
+          id: `canonical-missing-${route.route}`,
+          rule: "canonical",
+          severity: "error",
+          category: "technical",
+          message: `Missing canonical URL on route "${route.route}".`,
+          file: route.filePath,
+          route: route.route,
+          fixable: Boolean(configuredSiteUrl),
+          explanation: "A canonical tag tells search engines which URL represents the master copy of a page, preventing duplicate content penalties."
+        });
+        continue;
+      }
+      try {
+        const parsed = new URL(canonical);
+        const canonicalKey = `${parsed.origin}${parsed.pathname.replace(/\/$/, "") || "/"}`;
+        canonicalRoutes.set(canonicalKey, [...canonicalRoutes.get(canonicalKey) || [], route.route]);
+        if (expectedDomain && parsed.hostname !== expectedDomain) {
+          findings.push({
+            id: `canonical-domain-mismatch-${route.route}`,
+            rule: "canonical",
+            severity: "warning",
+            category: "technical",
+            message: `Canonical URL on "${route.route}" points to external domain "${parsed.hostname}" instead of configured "${expectedDomain}".`,
+            file: route.filePath,
+            route: route.route,
+            fixable: false,
+            explanation: "Cross-domain canonicals signal to search engines that another site owns this content. Ensure this is intentional."
+          });
+        }
+        if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
+          findings.push({
+            id: `canonical-invalid-protocol-${route.route}`,
+            rule: "canonical",
+            severity: "error",
+            category: "technical",
+            message: `Canonical URL "${canonical}" on "${route.route}" must use http or https protocol.`,
+            file: route.filePath,
+            route: route.route,
+            fixable: false
+          });
+        }
+        if (configuredSiteUrl && parsed.protocol === "http:" && configuredSiteUrl.protocol === "https:") {
+          findings.push({
+            id: `canonical-insecure-protocol-${route.route}`,
+            rule: "canonical",
+            severity: "warning",
+            category: "technical",
+            message: `Canonical URL on "${route.route}" uses HTTP while siteUrl uses HTTPS.`,
+            file: route.filePath,
+            route: route.route,
+            fixable: false
+          });
+        }
+        if (configuredSiteUrl && parsed.hostname === configuredSiteUrl.hostname) {
+          const basePath = configuredSiteUrl.pathname.replace(/\/$/, "");
+          const expectedPath = `${basePath}${route.route === "/" ? "" : route.route}` || "/";
+          const actualPath = parsed.pathname.replace(/\/$/, "") || "/";
+          const normalizedExpected = expectedPath.replace(/\/$/, "") || "/";
+          if (actualPath !== normalizedExpected) {
+            findings.push({
+              id: `canonical-route-mismatch-${route.route}`,
+              rule: "canonical",
+              severity: "warning",
+              category: "technical",
+              message: `Canonical URL on "${route.route}" points to path "${parsed.pathname}" instead of "${expectedPath}".`,
+              file: route.filePath,
+              route: route.route,
+              fixable: false
+            });
+          }
+        }
+      } catch {
+        findings.push({
+          id: `canonical-malformed-${route.route}`,
+          rule: "canonical",
+          severity: "error",
+          category: "technical",
+          message: `Malformed canonical URL "${canonical}" on route "${route.route}". Must be an absolute valid URL.`,
+          file: route.filePath,
+          route: route.route,
+          fixable: false
+        });
+      }
+    }
+    for (const [canonical, routes] of canonicalRoutes) {
+      if (routes.length < 2) continue;
+      for (const route of routes) {
+        findings.push({
+          id: `canonical-duplicate-${route}`,
+          rule: "canonical",
+          severity: "error",
+          category: "technical",
+          message: `Canonical URL "${canonical}" is shared by routes ${routes.join(", ")}.`,
+          route,
+          fixable: false
+        });
+      }
+    }
+    return findings;
+  }
+};
+
+// ../core/src/rules/headings.ts
+var headingsRule = {
+  id: "headings",
+  name: "Heading Hierarchy & Structure",
+  category: "content",
+  analyze(context) {
+    const findings = [];
+    for (const route of context.routes) {
+      const headings = route.headings;
+      const h1s = headings.filter((h) => h.level === 1);
+      if (h1s.length === 0) {
+        findings.push({
+          id: `heading-missing-h1-${route.route}`,
+          rule: "headings",
+          severity: "error",
+          category: "content",
+          message: `Missing <h1> heading on route "${route.route}".`,
+          file: route.filePath,
+          route: route.route,
+          fixable: false,
+          explanation: "Every page should have exactly one <h1> element defining its primary topic for search engines and accessibility."
+        });
+      } else if (h1s.length > 1) {
+        findings.push({
+          id: `heading-multiple-h1-${route.route}`,
+          rule: "headings",
+          severity: "warning",
+          category: "content",
+          message: `Found ${h1s.length} <h1> tags on route "${route.route}". Best practice is a single prominent <h1>.`,
+          file: route.filePath,
+          line: h1s[1].line,
+          route: route.route,
+          fixable: false,
+          explanation: "Multiple <h1> tags can dilute topical hierarchy and confuse screen readers."
+        });
+      }
+      let prevLevel = 1;
+      for (const h of headings) {
+        if (h.level > prevLevel + 1 && prevLevel > 0) {
+          findings.push({
+            id: `heading-skipped-level-${route.route}-${h.line ?? h.text}`,
+            rule: "headings",
+            severity: "info",
+            category: "content",
+            message: `Heading hierarchy skip on "${route.route}": jumped from <h${prevLevel}> to <h${h.level}> ("${h.text.slice(0, 30)}...").`,
+            file: route.filePath,
+            line: h.line,
+            route: route.route,
+            fixable: false,
+            explanation: "Maintain sequential heading levels (h1 -> h2 -> h3) for clear structural semantics."
+          });
+          break;
+        }
+        prevLevel = h.level;
+      }
+      if (route.hasLittleContent) {
+        findings.push({
+          id: `content-thin-${route.route}`,
+          rule: "headings",
+          severity: "warning",
+          category: "content",
+          message: `Route "${route.route}" has thin or minimal text content.`,
+          file: route.filePath,
+          route: route.route,
+          fixable: false,
+          explanation: "Thin pages risk being classified as low-value by search engine indexers."
+        });
+      }
+    }
+    return findings;
+  }
+};
+
+// ../core/src/rules/images.ts
+var imagesRule = {
+  id: "images",
+  name: "Image Accessibility & Alt Attributes",
+  category: "content",
+  analyze(context) {
+    const findings = [];
+    for (const route of context.routes) {
+      for (const img of route.images) {
+        if (img.alt === void 0 || img.alt === null) {
+          findings.push({
+            id: `img-missing-alt-${route.route}-${img.src}`,
+            rule: "images",
+            severity: "error",
+            category: "content",
+            message: `Image "${img.src}" on route "${route.route}" is missing an alt attribute.`,
+            file: route.filePath,
+            line: img.line,
+            route: route.route,
+            fixable: false,
+            // Never invent alt descriptions without AI
+            explanation: "Missing alt attributes harm accessibility and prevent images from ranking in Google Image Search."
+          });
+        } else if (img.alt.trim() === "" && !img.src.includes("icon") && !img.src.includes("decorative")) {
+          findings.push({
+            id: `img-empty-alt-${route.route}-${img.src}`,
+            rule: "images",
+            severity: "warning",
+            category: "content",
+            message: `Image "${img.src}" has an empty alt attribute on route "${route.route}".`,
+            file: route.filePath,
+            line: img.line,
+            route: route.route,
+            fixable: false,
+            explanation: 'Empty alt="" marks images as decorative. If this image conveys meaning, provide a descriptive alt attribute.'
+          });
+        }
+      }
+    }
+    return findings;
+  }
+};
+
+// ../core/src/rules/links.ts
+var linksRule = {
+  id: "links",
+  name: "Internal Link Validation",
+  category: "links",
+  analyze(context) {
+    const findings = [];
+    const validRoutes = new Set(context.routes.map((r) => r.route));
+    const normalizeRoute = (r) => r.endsWith("/") && r.length > 1 ? r.slice(0, -1) : r;
+    const normalizedValidRoutes = new Set([...validRoutes].map(normalizeRoute));
+    const redirects = new Map((context.redirects || []).map((redirect) => [normalizeRoute(redirect.source), redirect.destination]));
+    for (const route of context.routes) {
+      for (const link of route.links) {
+        if (!link.isInternal) continue;
+        const href = link.href.trim();
+        if (href === "" || href === "#") {
+          findings.push({
+            id: `link-empty-${route.route}-${link.line ?? href}`,
+            rule: "links",
+            severity: "warning",
+            category: "links",
+            message: `Empty or placeholder href ("${href}") found on route "${route.route}".`,
+            file: route.filePath,
+            line: link.line,
+            route: route.route,
+            fixable: false,
+            explanation: "Placeholder links degrade crawl efficiency and waste link equity."
+          });
+          continue;
+        }
+        const cleanHref = normalizeRoute(href.split("?")[0].split("#")[0]);
+        if (cleanHref.startsWith("/")) {
+          const redirectTarget = redirects.get(cleanHref);
+          if (redirectTarget) {
+            findings.push({
+              id: `link-internal-redirect-${route.route}-${cleanHref}`,
+              rule: "links",
+              severity: "warning",
+              category: "links",
+              message: `Internal link "${href}" on "${route.route}" redirects to "${redirectTarget}".`,
+              file: route.filePath,
+              line: link.line,
+              route: route.route,
+              fixable: false,
+              explanation: "Link directly to the final internal route to avoid unnecessary crawl hops."
+            });
+          }
+          if (!normalizedValidRoutes.has(cleanHref) && !redirectTarget) {
+            let isTypoFixable = false;
+            for (const valid of normalizedValidRoutes) {
+              if (valid.toLowerCase() === cleanHref.toLowerCase()) {
+                isTypoFixable = true;
+                break;
+              }
+            }
+            findings.push({
+              id: `link-broken-${route.route}-${cleanHref}`,
+              rule: "links",
+              severity: "error",
+              category: "links",
+              message: `Broken internal link to nonexistent route "${href}" on "${route.route}".`,
+              file: route.filePath,
+              line: link.line,
+              route: route.route,
+              fixable: isTypoFixable,
+              explanation: "Broken internal links return 404s to search bots and users, impairing crawl discovery."
+            });
+          }
+        }
+      }
+    }
+    return findings;
+  }
+};
+
+// ../core/src/rules/crawlability.ts
+var crawlabilityRule = {
+  id: "crawlability",
+  name: "Crawlability & Indexing (Robots & Sitemap)",
+  category: "technical",
+  analyze(context) {
+    const findings = [];
+    if (!context.robotsFound) {
+      findings.push({
+        id: "robots-missing",
+        rule: "crawlability",
+        severity: "warning",
+        category: "technical",
+        message: "Missing robots.txt or app/robots.ts file.",
+        fixable: true,
+        explanation: "Robots.txt directs search crawler access to public sections and points crawlers to your sitemap."
+      });
+    } else if (context.robotsContent) {
+      const directives = context.robotsContent.split(/\r?\n/).map((line) => line.replace(/#.*/, "").trim()).filter(Boolean);
+      const disallowed = directives.filter((line) => /^disallow\s*:/i.test(line)).map((line) => line.replace(/^disallow\s*:/i, "").trim()).filter(Boolean);
+      const allowed = new Set(
+        directives.filter((line) => /^allow\s*:/i.test(line)).map((line) => line.replace(/^allow\s*:/i, "").trim())
+      );
+      for (const blocked of disallowed) {
+        if (allowed.has(blocked)) {
+          findings.push({
+            id: `robots-contradictory-${blocked}`,
+            rule: "crawlability",
+            severity: "warning",
+            category: "technical",
+            message: `robots rules both allow and disallow "${blocked}".`,
+            fixable: false
+          });
+        }
+        for (const route of context.routes) {
+          if (blocked === "/" || route.route === blocked || route.route.startsWith(`${blocked.replace(/\/$/, "")}/`)) {
+            findings.push({
+              id: `robots-route-blocked-${route.route}`,
+              rule: "crawlability",
+              severity: route.route === "/" ? "error" : "warning",
+              category: "technical",
+              message: `Public route "${route.route}" appears blocked by robots rule "${blocked}".`,
+              route: route.route,
+              file: route.filePath,
+              fixable: false
+            });
+          }
+        }
+      }
+    }
+    if (!context.sitemapFound) {
+      findings.push({
+        id: "sitemap-missing",
+        rule: "crawlability",
+        severity: "error",
+        category: "technical",
+        message: "Missing sitemap.xml or app/sitemap.ts file.",
+        fixable: Boolean(context.config.siteUrl),
+        explanation: "An XML sitemap communicates your full URL catalog to Google, ensuring newly published routes are indexed quickly."
+      });
+    } else {
+      if (context.sitemapMalformed) {
+        findings.push({
+          id: "sitemap-malformed",
+          rule: "crawlability",
+          severity: "error",
+          category: "technical",
+          message: "sitemap.xml is malformed or contains no URL entries.",
+          fixable: Boolean(context.config.siteUrl)
+        });
+      }
+      const validRoutes = new Set(context.routes.map((r) => r.route));
+      for (const url of context.sitemapUrls) {
+        try {
+          const pathname = url.startsWith("http") ? new URL(url).pathname : url;
+          const clean = pathname.endsWith("/") && pathname.length > 1 ? pathname.slice(0, -1) : pathname;
+          if (!validRoutes.has(clean) && clean !== "") {
+            findings.push({
+              id: `sitemap-orphan-url-${clean}`,
+              rule: "crawlability",
+              severity: "warning",
+              category: "technical",
+              message: `Sitemap contains URL "${url}" which does not correspond to any known route.`,
+              fixable: false,
+              explanation: "Listing nonexistent routes in sitemaps wastes search engine crawl budgets."
+            });
+          }
+        } catch {
+        }
+      }
+    }
+    for (const route of context.routes) {
+      const robots = route.metadata.robots?.toLowerCase() || "";
+      if (robots.includes("noindex")) {
+        const listedInSitemap = context.sitemapUrls.some((url) => {
+          try {
+            return (url.startsWith("http") ? new URL(url).pathname : url).replace(/\/$/, "") === route.route.replace(/\/$/, "");
+          } catch {
+            return false;
+          }
+        });
+        if (listedInSitemap) {
+          findings.push({
+            id: `robots-noindex-sitemap-${route.route}`,
+            rule: "crawlability",
+            severity: "warning",
+            category: "technical",
+            message: `Route "${route.route}" is marked noindex but is also listed in the sitemap.`,
+            file: route.filePath,
+            route: route.route,
+            fixable: false
+          });
+        }
+        if (route.route === "/") {
+          findings.push({
+            id: "robots-noindex-homepage",
+            rule: "crawlability",
+            severity: "error",
+            category: "technical",
+            message: 'Homepage ("/") is configured with "noindex", blocking entire domain from search engines.',
+            file: route.filePath,
+            route: route.route,
+            fixable: false,
+            explanation: "Applying noindex to your homepage prevents Google from indexing your primary domain."
+          });
+        }
+      }
+    }
+    return findings;
+  }
+};
+
+// ../core/src/rules/structured-data.ts
+var SUPPORTED_SCHEMAS = /* @__PURE__ */ new Set(["Organization", "WebSite", "Article", "BreadcrumbList", "Product", "SoftwareApplication", "FAQPage"]);
+var structuredDataRule = {
+  id: "structured-data",
+  name: "JSON-LD Structured Data Validation",
+  category: "technical",
+  analyze(context) {
+    const findings = [];
+    for (const route of context.routes) {
+      const jsonLdList = route.metadata.jsonLd || [];
+      for (const item of jsonLdList) {
+        if (item.invalid === true) {
+          findings.push({
+            id: `jsonld-malformed-${route.route}`,
+            rule: "structured-data",
+            severity: "error",
+            category: "technical",
+            message: `JSON-LD block on route "${route.route}" is not valid JSON.`,
+            file: route.filePath,
+            route: route.route,
+            fixable: false
+          });
+          continue;
+        }
+        const contextVal = item["@context"];
+        if (!contextVal || !contextVal.includes("schema.org") && !contextVal.includes("https://schema.org")) {
+          findings.push({
+            id: `jsonld-context-missing-${route.route}`,
+            rule: "structured-data",
+            severity: "warning",
+            category: "technical",
+            message: `JSON-LD block on route "${route.route}" has missing or invalid @context. Expected "https://schema.org".`,
+            file: route.filePath,
+            route: route.route,
+            fixable: false
+          });
+        }
+        const typeVal = item["@type"];
+        if (!typeVal) {
+          findings.push({
+            id: `jsonld-type-missing-${route.route}`,
+            rule: "structured-data",
+            severity: "error",
+            category: "technical",
+            message: `JSON-LD structured data on route "${route.route}" is missing the @type field.`,
+            file: route.filePath,
+            route: route.route,
+            fixable: false
+          });
+        } else if (SUPPORTED_SCHEMAS.has(typeVal) && typeVal === "Article" && !item.headline) {
+          findings.push({
+            id: `jsonld-article-missing-headline-${route.route}`,
+            rule: "structured-data",
+            severity: "warning",
+            category: "technical",
+            message: `Article structured data on route "${route.route}" is missing recommended "headline" property.`,
+            file: route.filePath,
+            route: route.route,
+            fixable: false
+          });
+        } else if (SUPPORTED_SCHEMAS.has(typeVal) && ["Organization", "WebSite", "Product"].includes(typeVal) && !item.name) {
+          findings.push({
+            id: `jsonld-${typeVal.toLowerCase()}-missing-name-${route.route}`,
+            rule: "structured-data",
+            severity: "warning",
+            category: "technical",
+            message: `${typeVal} structured data on route "${route.route}" is missing the required "name" property.`,
+            file: route.filePath,
+            route: route.route,
+            fixable: false
+          });
+        } else if (SUPPORTED_SCHEMAS.has(typeVal) && typeVal === "BreadcrumbList" && !item.itemListElement) {
+          findings.push({
+            id: `jsonld-breadcrumb-missing-items-${route.route}`,
+            rule: "structured-data",
+            severity: "warning",
+            category: "technical",
+            message: `BreadcrumbList structured data on route "${route.route}" has no itemListElement entries.`,
+            file: route.filePath,
+            route: route.route,
+            fixable: false
+          });
+        }
+      }
+    }
+    return findings;
+  }
+};
+
+// ../core/src/rules/routes.ts
+var routesRule = {
+  id: "routes",
+  name: "Route Consistency",
+  category: "technical",
+  analyze(context) {
+    const findings = [];
+    const seen = /* @__PURE__ */ new Map();
+    for (const route of context.routes) {
+      const existing = seen.get(route.route);
+      if (existing) {
+        findings.push({
+          id: `route-duplicate-${route.route}-${route.filePath}`,
+          rule: "routes",
+          severity: "error",
+          category: "technical",
+          message: `Route "${route.route}" is defined by both "${existing}" and "${route.filePath}".`,
+          file: route.filePath,
+          route: route.route,
+          fixable: false
+        });
+      } else {
+        seen.set(route.route, route.filePath);
+      }
+    }
+    return findings;
+  }
+};
+
+// ../core/src/rules/metadata-conflicts.ts
+var metadataConflictsRule = {
+  id: "metadata-conflicts",
+  name: "Conflicting Metadata Declarations",
+  category: "metadata",
+  analyze(context) {
+    return context.routes.filter((route) => route.metadata.hasConflictingDeclarations).map((route) => ({
+      id: `metadata-conflict-${route.route}`,
+      rule: "metadata-conflicts",
+      severity: "warning",
+      category: "metadata",
+      message: `Route "${route.route}" contains multiple metadata declaration mechanisms.`,
+      file: route.filePath,
+      route: route.route,
+      fixable: false,
+      explanation: "Mixing Metadata exports, generateMetadata, and next/head can produce conflicting search metadata."
+    }));
+  }
+};
+
+// ../core/src/rules/redirects.ts
+var redirectsRule = {
+  id: "redirects",
+  name: "Redirect Consistency",
+  category: "technical",
+  analyze(context) {
+    const findings = [];
+    const redirects = new Map((context.redirects || []).map((redirect) => [redirect.source, redirect.destination]));
+    for (const [source, destination] of redirects) {
+      if (source === destination) {
+        findings.push({
+          id: `redirect-self-loop-${source}`,
+          rule: "redirects",
+          severity: "error",
+          category: "technical",
+          message: `Redirect "${source}" points to itself.`,
+          route: source,
+          fixable: false
+        });
+        continue;
+      }
+      const visited = /* @__PURE__ */ new Set([source]);
+      let current = destination;
+      while (current && redirects.has(current)) {
+        if (visited.has(current)) {
+          findings.push({
+            id: `redirect-loop-${source}`,
+            rule: "redirects",
+            severity: "error",
+            category: "technical",
+            message: `Redirect starting at "${source}" forms a loop.`,
+            route: source,
+            fixable: false
+          });
+          break;
+        }
+        visited.add(current);
+        current = redirects.get(current);
+      }
+    }
+    return findings;
+  }
+};
+
+// ../core/src/rules/index.ts
+var allRules = [
+  metadataTitleRule,
+  metadataDescriptionRule,
+  metadataConflictsRule,
+  canonicalRule,
+  headingsRule,
+  imagesRule,
+  linksRule,
+  crawlabilityRule,
+  structuredDataRule,
+  routesRule,
+  redirectsRule
+];
+
+// ../core/src/scoring.ts
+var PENALTIES = {
+  error: 15,
+  warning: 6,
+  info: 2
+};
+var CATEGORY_WEIGHTS = {
+  technical: 0.3,
+  metadata: 0.3,
+  content: 0.2,
+  links: 0.2
+};
+var MAX_PENALTY_PER_RULE_AND_CATEGORY = 30;
+function calculateScore(findings) {
+  const categoryPenalties = {
+    technical: 0,
+    metadata: 0,
+    content: 0,
+    links: 0
+  };
+  const groupedPenalties = /* @__PURE__ */ new Map();
+  for (const finding of findings) {
+    const key = `${finding.category}:${finding.rule}`;
+    groupedPenalties.set(key, (groupedPenalties.get(key) || 0) + (PENALTIES[finding.severity] || 0));
+  }
+  for (const [key, penalty] of groupedPenalties) {
+    const category = key.split(":", 1)[0];
+    categoryPenalties[category] += Math.min(MAX_PENALTY_PER_RULE_AND_CATEGORY, penalty);
+  }
+  const breakdown = {
+    technical: Math.max(0, 100 - categoryPenalties.technical),
+    metadata: Math.max(0, 100 - categoryPenalties.metadata),
+    content: Math.max(0, 100 - categoryPenalties.content),
+    links: Math.max(0, 100 - categoryPenalties.links)
+  };
+  const weightedOverall = breakdown.technical * CATEGORY_WEIGHTS.technical + breakdown.metadata * CATEGORY_WEIGHTS.metadata + breakdown.content * CATEGORY_WEIGHTS.content + breakdown.links * CATEGORY_WEIGHTS.links;
+  const overall = Math.round(Math.max(0, Math.min(100, weightedOverall)));
+  return {
+    overall,
+    breakdown
+  };
+}
+
+// ../core/src/graph.ts
+function buildLinkGraph(routes, redirects = []) {
+  const nodeSet = new Set(routes.map((r) => r.route));
+  const nodes = Array.from(nodeSet);
+  const edges = [];
+  const incomingCount = {};
+  const outgoingCount = {};
+  const adjacencyList = {};
+  for (const node of nodes) {
+    incomingCount[node] = 0;
+    outgoingCount[node] = 0;
+    adjacencyList[node] = [];
+  }
+  const normalize = (path5) => path5.endsWith("/") && path5.length > 1 ? path5.slice(0, -1) : path5;
+  const redirectMap = new Map(redirects.map((redirect) => [normalize(redirect.source), normalize(redirect.destination)]));
+  for (const route of routes) {
+    const source = route.route;
+    for (const link of route.links) {
+      if (!link.isInternal) continue;
+      const cleanHref = normalize(link.href.split("?")[0].split("#")[0]);
+      const resolvedTarget = redirectMap.get(cleanHref) || cleanHref;
+      const targetExists = nodeSet.has(resolvedTarget);
+      edges.push({
+        source,
+        target: resolvedTarget,
+        anchorText: link.anchorText,
+        isBroken: !targetExists
+      });
+      if (targetExists) {
+        outgoingCount[source] = (outgoingCount[source] || 0) + 1;
+        incomingCount[resolvedTarget] = (incomingCount[resolvedTarget] || 0) + 1;
+        adjacencyList[source].push(resolvedTarget);
+      }
+    }
+  }
+  const depths = {};
+  for (const node of nodes) {
+    depths[node] = node === "/" ? 0 : -1;
+  }
+  if (nodeSet.has("/")) {
+    const queue = ["/"];
+    const visited = /* @__PURE__ */ new Set(["/"]);
+    while (queue.length > 0) {
+      const current = queue.shift();
+      const currDepth = depths[current];
+      for (const neighbor of adjacencyList[current] || []) {
+        if (!visited.has(neighbor)) {
+          visited.add(neighbor);
+          depths[neighbor] = currDepth + 1;
+          queue.push(neighbor);
+        }
+      }
+    }
+  }
+  const metrics = {};
+  const orphans = [];
+  const deadEnds = [];
+  const brokenEdges = edges.filter((e) => e.isBroken);
+  const lowConnectivity = [];
+  const highlyLinked = [];
+  const highLinkThreshold = Math.max(10, Math.ceil(nodes.length * 0.8));
+  for (const node of nodes) {
+    const inc = incomingCount[node] || 0;
+    const out = outgoingCount[node] || 0;
+    const isOrphan = node !== "/" && inc === 0;
+    const isDeadEnd = out === 0;
+    if (isOrphan) orphans.push(node);
+    if (isDeadEnd) deadEnds.push(node);
+    if (node !== "/" && inc + out <= 1) lowConnectivity.push(node);
+    if (inc >= highLinkThreshold) highlyLinked.push(node);
+    metrics[node] = {
+      route: node,
+      incomingLinks: inc,
+      outgoingLinks: out,
+      depthFromHome: depths[node] ?? -1,
+      isOrphan,
+      isDeadEnd,
+      centrality: nodes.length > 1 ? Number((inc / (nodes.length - 1)).toFixed(3)) : 0
+    };
+  }
+  return {
+    nodes,
+    edges,
+    metrics,
+    orphans,
+    deadEnds,
+    brokenEdges,
+    lowConnectivity,
+    highlyLinked
+  };
+}
+
+// ../core/src/recommender.ts
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "and",
+  "are",
+  "as",
+  "at",
+  "be",
+  "by",
+  "for",
+  "from",
+  "has",
+  "he",
+  "in",
+  "is",
+  "it",
+  "its",
+  "of",
+  "on",
+  "that",
+  "the",
+  "to",
+  "was",
+  "were",
+  "will",
+  "with",
+  "the",
+  "this",
+  "but",
+  "or",
+  "yang",
+  "dan",
+  "di",
+  "ke",
+  "dari",
+  "ini",
+  "itu",
+  "untuk",
+  "pada",
+  "adalah",
+  "dengan",
+  "page",
+  "home",
+  "about",
+  "contact",
+  "index"
+]);
+function tokenize(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").replace(/[-_]/g, " ").split(/\s+/).filter((word) => word.length >= 3 && !STOP_WORDS.has(word));
+}
+function extractRouteTokens(route) {
+  const weights = /* @__PURE__ */ new Map();
+  const addTokens = (words, weightMultiplier) => {
+    for (const w of words) {
+      weights.set(w, (weights.get(w) || 0) + weightMultiplier);
+    }
+  };
+  const slugTokens = tokenize(route.route);
+  addTokens(slugTokens, 4);
+  if (route.metadata.title) {
+    const titleTokens = tokenize(route.metadata.title);
+    addTokens(titleTokens, 3);
+  }
+  for (const h of route.headings.filter((h2) => h2.level === 1)) {
+    addTokens(tokenize(h.text), 2.5);
+  }
+  for (const h of route.headings.filter((h2) => h2.level > 1)) {
+    addTokens(tokenize(h.text), 1.5);
+  }
+  if (route.textContent) {
+    addTokens(tokenize(route.textContent), 1);
+  }
+  const tokens = Array.from(weights.keys());
+  return { tokens, weights };
+}
+function generateLinkRecommendations(routes, minScore = 35) {
+  const recommendations = [];
+  const eligibleRoutes = routes.filter(
+    (r) => !r.route.startsWith("/api") && !r.route.startsWith("/admin") && !r.route.startsWith("/_")
+  );
+  const routeProfiles = eligibleRoutes.map((route) => ({
+    route,
+    ...extractRouteTokens(route)
+  }));
+  const existingLinksMap = /* @__PURE__ */ new Map();
+  for (const r of eligibleRoutes) {
+    const set = /* @__PURE__ */ new Set();
+    for (const link of r.links) {
+      const clean = link.href.split("?")[0].split("#")[0];
+      set.add(clean.endsWith("/") && clean.length > 1 ? clean.slice(0, -1) : clean);
+    }
+    existingLinksMap.set(r.route, set);
+  }
+  for (let i = 0; i < routeProfiles.length; i++) {
+    const source = routeProfiles[i];
+    const existing = existingLinksMap.get(source.route.route) || /* @__PURE__ */ new Set();
+    for (let j = 0; j < routeProfiles.length; j++) {
+      if (i === j) continue;
+      const target = routeProfiles[j];
+      if (existing.has(target.route.route)) continue;
+      let intersectionScore = 0;
+      const sharedKeywords = [];
+      for (const [token, weight] of source.weights.entries()) {
+        const targetWeight = target.weights.get(token);
+        if (targetWeight !== void 0) {
+          const overlap = Math.min(weight, targetWeight);
+          intersectionScore += overlap;
+          sharedKeywords.push(token);
+        }
+      }
+      if (sharedKeywords.length === 0) continue;
+      const maxPossible = Math.max(1, (source.tokens.length + target.tokens.length) * 1.5);
+      const rawRatio = intersectionScore / maxPossible;
+      const percentage = Math.min(96, Math.max(15, Math.round(rawRatio * 100)));
+      if (percentage >= minScore) {
+        sharedKeywords.sort((a, b) => {
+          const scoreA = (source.weights.get(a) || 0) + (target.weights.get(a) || 0);
+          const scoreB = (source.weights.get(b) || 0) + (target.weights.get(b) || 0);
+          return scoreB - scoreA;
+        });
+        const topKeywords = sharedKeywords.slice(0, 3);
+        const reason = `"${topKeywords.join('", "')}" appears prominently in route path and headings on both pages.`;
+        recommendations.push({
+          sourceRoute: source.route.route,
+          targetRoute: target.route.route,
+          score: percentage,
+          reason,
+          prominentKeywords: topKeywords
+        });
+      }
+    }
+  }
+  return recommendations.sort((a, b) => b.score - a.score);
+}
+
+// ../core/src/opportunities.ts
+var COMMON_NICHES = {
+  invoice: ["freelancer", "agency", "consultant", "umkm", "startup", "contractor", "software-house", "creator"],
+  tools: ["invoice-generator", "utm-builder", "meta-tag-generator", "qr-generator", "salary-calculator", "pdf-compressor"],
+  templates: ["invoice", "quotation", "contract", "receipt", "proposal", "resume"],
+  blog: ["tutorial", "case-study", "comparison", "guide", "best-practices", "review"],
+  integrations: ["stripe", "midtrans", "xendit", "github", "slack", "notion"]
+};
+function detectContentOpportunities(routes, providedKeywords = {}) {
+  const clusters = [];
+  const prefixGroups = /* @__PURE__ */ new Map();
+  for (const route of routes) {
+    if (route.route === "/" || route.route.startsWith("/api") || route.route.startsWith("/admin")) {
+      continue;
+    }
+    const segments = route.route.split("/").filter(Boolean);
+    if (segments.length >= 2) {
+      const prefix = `/${segments[0]}`;
+      const subSegment = segments[1];
+      const group = prefixGroups.get(prefix) || { fullRoutes: [], subSegments: [] };
+      group.fullRoutes.push(route.route);
+      group.subSegments.push(subSegment);
+      prefixGroups.set(prefix, group);
+    }
+  }
+  for (const [prefix, group] of prefixGroups.entries()) {
+    const cleanPrefix = prefix.replace("/", "");
+    const existingSubSegments = new Set(group.subSegments);
+    const nicheKeywords = providedKeywords[cleanPrefix] || COMMON_NICHES[cleanPrefix] || [
+      "starter-guide",
+      "tips",
+      "best-practices",
+      "faq",
+      "pricing-plans",
+      "case-studies"
+    ];
+    const opportunities = nicheKeywords.filter((niche) => !existingSubSegments.has(niche)).map((niche) => `${prefix}/${niche}`);
+    if (group.fullRoutes.length >= 2 || group.fullRoutes.length >= 1 && opportunities.length > 0) {
+      const topicName = cleanPrefix.charAt(0).toUpperCase() + cleanPrefix.slice(1) + " Expansion Cluster";
+      clusters.push({
+        pattern: `${prefix}/{topic}`,
+        topic: topicName,
+        existingPages: group.fullRoutes,
+        potentialOpportunities: opportunities.slice(0, 5)
+      });
+    }
+  }
+  return clusters;
+}
+
+// ../core/src/fixer.ts
+import path2 from "node:path";
+import fs2 from "node:fs";
+function createUnifiedDiff(filename, oldText, newText) {
+  const oldLines = oldText ? oldText.split("\n") : [];
+  const newLines = newText ? newText.split("\n") : [];
+  let prefix = 0;
+  while (prefix < oldLines.length && prefix < newLines.length && oldLines[prefix] === newLines[prefix]) prefix += 1;
+  let suffix = 0;
+  while (suffix < oldLines.length - prefix && suffix < newLines.length - prefix && oldLines[oldLines.length - 1 - suffix] === newLines[newLines.length - 1 - suffix]) suffix += 1;
+  const contextStart = Math.max(0, prefix - 3);
+  const oldChangeEnd = oldLines.length - suffix;
+  const newChangeEnd = newLines.length - suffix;
+  const oldContextEnd = Math.min(oldLines.length, oldChangeEnd + 3);
+  const newContextEnd = Math.min(newLines.length, newChangeEnd + 3);
+  const oldCount = oldContextEnd - contextStart;
+  const newCount = newContextEnd - contextStart;
+  let diff = `--- a/${filename}
++++ b/${filename}
+@@ -${contextStart + 1},${oldCount} +${contextStart + 1},${newCount} @@
+`;
+  for (let index = contextStart; index < prefix; index += 1) diff += ` ${oldLines[index]}
+`;
+  for (let index = prefix; index < oldChangeEnd; index += 1) diff += `-${oldLines[index]}
+`;
+  for (let index = prefix; index < newChangeEnd; index += 1) diff += `+${newLines[index]}
+`;
+  const suffixStart = oldLines.length - suffix;
+  for (let index = suffixStart; index < Math.min(oldLines.length, suffixStart + 3); index += 1) {
+    diff += ` ${oldLines[index]}
+`;
+  }
+  return diff;
+}
+async function applySafeFixes(options) {
+  const { projectRoot, routes, findings, config, dryRun = false, isAppRouter = true } = options;
+  const appliedChanges = [];
+  const skippedFindings = [];
+  const scoreBefore = calculateScore(findings);
+  let siteUrl;
+  if (config.siteUrl) {
+    try {
+      const parsedSiteUrl = new URL(config.siteUrl);
+      if (parsedSiteUrl.protocol === "http:" || parsedSiteUrl.protocol === "https:") {
+        siteUrl = config.siteUrl.replace(/\/$/, "");
+      }
+    } catch {
+      siteUrl = void 0;
+    }
+  }
+  const validRoutes = routes.filter((r) => !r.hasDynamicSegments).map((r) => r.route);
+  const fixedFindingIds = /* @__PURE__ */ new Set();
+  const virtualFiles = /* @__PURE__ */ new Map();
+  const appDirectory = fs2.existsSync(path2.join(projectRoot, "app")) ? path2.join(projectRoot, "app") : path2.join(projectRoot, "src", "app");
+  const safeFile = (candidate) => {
+    const root = path2.resolve(projectRoot);
+    const resolved = path2.resolve(candidate);
+    return resolved === root || resolved.startsWith(`${root}${path2.sep}`) ? resolved : null;
+  };
+  const readCurrent = (candidate) => {
+    if (virtualFiles.has(candidate)) return virtualFiles.get(candidate);
+    return fs2.existsSync(candidate) ? fs2.readFileSync(candidate, "utf8") : "";
+  };
+  const recordChange = (change, findingId) => {
+    appliedChanges.push(change);
+    fixedFindingIds.add(findingId);
+    virtualFiles.set(change.filePath, change.newContent);
+    if (!dryRun) {
+      fs2.mkdirSync(path2.dirname(change.filePath), { recursive: true });
+      fs2.writeFileSync(change.filePath, change.newContent, "utf8");
+    }
+  };
+  const robotsFinding = findings.find((f) => f.rule === "crawlability" && f.id === "robots-missing");
+  if (robotsFinding) {
+    if (isAppRouter) {
+      const robotsFilePath = path2.join(appDirectory, "robots.ts");
+      const relativePath = path2.relative(projectRoot, robotsFilePath);
+      const oldContent = fs2.existsSync(robotsFilePath) ? fs2.readFileSync(robotsFilePath, "utf8") : "";
+      const sitemapLine = siteUrl ? `
+    sitemap: '${siteUrl}/sitemap.xml',` : "";
+      const newContent = `import { MetadataRoute } from 'next';
+
+export default function robots(): MetadataRoute.Robots {
+  return {
+    rules: {
+      userAgent: '*',
+      allow: '/',
+      disallow: ['/api/', '/admin/'],
+    },
+    ${sitemapLine.trimStart()}
+  };
+}
+`;
+      recordChange({
+        filePath: robotsFilePath,
+        originalContent: oldContent,
+        newContent,
+        diff: createUnifiedDiff(relativePath, oldContent, newContent),
+        description: "Generated app/robots.ts with standard crawler rules and sitemap reference."
+      }, robotsFinding.id);
+    } else {
+      const robotsFilePath = path2.join(projectRoot, "public", "robots.txt");
+      const relativePath = "public/robots.txt";
+      const oldContent = fs2.existsSync(robotsFilePath) ? fs2.readFileSync(robotsFilePath, "utf8") : "";
+      const newContent = `User-agent: *
+Allow: /
+Disallow: /api/
+Disallow: /admin/
+${siteUrl ? `
+Sitemap: ${siteUrl}/sitemap.xml
+` : ""}`;
+      recordChange({
+        filePath: robotsFilePath,
+        originalContent: oldContent,
+        newContent,
+        diff: createUnifiedDiff(relativePath, oldContent, newContent),
+        description: "Generated public/robots.txt with standard crawler rules and sitemap pointer."
+      }, robotsFinding.id);
+    }
+  }
+  const sitemapFinding = findings.find(
+    (f) => f.rule === "crawlability" && (f.id === "sitemap-missing" || f.id === "sitemap-malformed")
+  );
+  if (sitemapFinding && siteUrl) {
+    if (isAppRouter) {
+      const sitemapFilePath = path2.join(appDirectory, "sitemap.ts");
+      const relativePath = path2.relative(projectRoot, sitemapFilePath);
+      const oldContent = fs2.existsSync(sitemapFilePath) ? fs2.readFileSync(sitemapFilePath, "utf8") : "";
+      const routeEntries = validRoutes.map(
+        (r) => `    {
+      url: '${siteUrl}${r === "/" ? "" : r}',
+      lastModified: new Date(),
+      changeFrequency: '${r === "/" ? "daily" : "weekly"}',
+      priority: ${r === "/" ? 1 : 0.8},
+    }`
+      ).join(",\n");
+      const newContent = `import { MetadataRoute } from 'next';
+
+export default function sitemap(): MetadataRoute.Sitemap {
+  return [
+${routeEntries}
+  ];
+}
+`;
+      recordChange({
+        filePath: sitemapFilePath,
+        originalContent: oldContent,
+        newContent,
+        diff: createUnifiedDiff(relativePath, oldContent, newContent),
+        description: `Generated app/sitemap.ts containing ${validRoutes.length} discovered routes.`
+      }, sitemapFinding.id);
+    } else {
+      const sitemapFilePath = path2.join(projectRoot, "public", "sitemap.xml");
+      const relativePath = "public/sitemap.xml";
+      const oldContent = fs2.existsSync(sitemapFilePath) ? fs2.readFileSync(sitemapFilePath, "utf8") : "";
+      const xmlEntries = validRoutes.map(
+        (r) => `  <url>
+    <loc>${siteUrl}${r === "/" ? "" : r}</loc>
+    <changefreq>${r === "/" ? "daily" : "weekly"}</changefreq>
+    <priority>${r === "/" ? "1.0" : "0.8"}</priority>
+  </url>`
+      ).join("\n");
+      const newContent = `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+${xmlEntries}
+</urlset>
+`;
+      recordChange({
+        filePath: sitemapFilePath,
+        originalContent: oldContent,
+        newContent,
+        diff: createUnifiedDiff(relativePath, oldContent, newContent),
+        description: `Generated public/sitemap.xml containing ${validRoutes.length} discovered routes.`
+      }, sitemapFinding.id);
+    }
+  }
+  if (siteUrl) {
+    const canonicalFindings = findings.filter((f) => f.rule === "canonical" && f.fixable && f.file);
+    for (const finding of canonicalFindings) {
+      const findingFile = finding.file ? safeFile(finding.file) : null;
+      if (!findingFile || !fs2.existsSync(findingFile)) continue;
+      const fileContent = readCurrent(findingFile);
+      const route = finding.route || "/";
+      const canonicalUrl = `${siteUrl}${route === "/" ? "" : route}`;
+      if (fileContent.includes("export const metadata")) {
+        if (!fileContent.includes("alternates")) {
+          const updatedContent = fileContent.replace(
+            /(export\s+const\s+metadata(?:\s*:\s*Metadata)?\s*=\s*\{)/,
+            `$1
+  alternates: {
+    canonical: '${canonicalUrl}',
+  },`
+          );
+          if (updatedContent !== fileContent) {
+            recordChange({
+              filePath: findingFile,
+              originalContent: fileContent,
+              newContent: updatedContent,
+              diff: createUnifiedDiff(path2.relative(projectRoot, findingFile), fileContent, updatedContent),
+              description: `Added canonical alternate "${canonicalUrl}" to metadata in ${path2.basename(findingFile)}.`
+            }, finding.id);
+          }
+        }
+      } else if (fileContent.includes("export default function")) {
+        const metadataBoilerplate = `import type { Metadata } from 'next';
+
+export const metadata: Metadata = {
+  alternates: {
+    canonical: '${canonicalUrl}',
+  },
+};
+
+`;
+        const updatedContent = metadataBoilerplate + fileContent;
+        recordChange({
+          filePath: findingFile,
+          originalContent: fileContent,
+          newContent: updatedContent,
+          diff: createUnifiedDiff(path2.relative(projectRoot, findingFile), fileContent, updatedContent),
+          description: `Injected canonical metadata export in ${path2.basename(findingFile)}.`
+        }, finding.id);
+      }
+    }
+  }
+  const fixableLinkFindings = findings.filter((f) => f.rule === "links" && f.fixable && f.file);
+  for (const lf of fixableLinkFindings) {
+    const linkFile = lf.file ? safeFile(lf.file) : null;
+    if (!linkFile || !fs2.existsSync(linkFile)) continue;
+    const fileContent = readCurrent(linkFile);
+    const match = lf.message.match(/nonexistent route "([^"]+)"/);
+    if (match) {
+      const brokenHref = match[1];
+      const normalizedTarget = validRoutes.find(
+        (r) => r.toLowerCase() === brokenHref.toLowerCase()
+      );
+      if (normalizedTarget) {
+        const escapedHref = brokenHref.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        const updatedContent = fileContent.replace(
+          new RegExp(`href=["']${escapedHref}["']`, "g"),
+          `href="${normalizedTarget}"`
+        );
+        if (updatedContent !== fileContent) {
+          recordChange({
+            filePath: linkFile,
+            originalContent: fileContent,
+            newContent: updatedContent,
+            diff: createUnifiedDiff(path2.relative(projectRoot, linkFile), fileContent, updatedContent),
+            description: `Fixed casing of internal link: "${brokenHref}" -> "${normalizedTarget}".`
+          }, lf.id);
+        }
+      }
+    }
+  }
+  for (const f of findings) {
+    if (!fixedFindingIds.has(f.id)) {
+      skippedFindings.push(f);
+    }
+  }
+  const remainingFindings = findings.filter((f) => !fixedFindingIds.has(f.id));
+  const scoreAfter = calculateScore(remainingFindings);
+  return {
+    appliedChanges,
+    skippedFindings,
+    scoreBefore,
+    scoreAfter,
+    dryRun
+  };
+}
+
+// ../core/src/engine.ts
+function runSEOAudit(options) {
+  const {
+    routes,
+    config = {},
+    sitemapFound = false,
+    robotsFound = false,
+    robotsContent = "",
+    sitemapUrls = [],
+    sitemapMalformed = false,
+    redirects = [],
+    projectRoot = "",
+    isAppRouter = true
+  } = options;
+  const ignored = config.ignore || ["/admin/**", "/api/**"];
+  const matchesIgnore = (route, pattern) => {
+    const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*");
+    return new RegExp(`^${escaped}$`).test(route);
+  };
+  const analyzedRoutes = routes.filter((route) => !ignored.some((pattern) => matchesIgnore(route.route, pattern))).sort((a, b) => a.route.localeCompare(b.route));
+  const ruleContext = {
+    routes: analyzedRoutes,
+    config,
+    sitemapFound,
+    robotsFound,
+    robotsContent,
+    sitemapUrls,
+    sitemapMalformed,
+    redirects,
+    projectRoot,
+    isAppRouter
+  };
+  const ruleAliases = {
+    canonical: "requireCanonical",
+    "metadata-description": "requireDescription"
+  };
+  const ruleSetting = (ruleId) => config.rules?.[ruleId] ?? (ruleAliases[ruleId] ? config.rules?.[ruleAliases[ruleId]] : void 0);
+  const findings = allRules.filter((rule) => ruleSetting(rule.id) !== false).flatMap((rule) => {
+    const results = rule.analyze(ruleContext);
+    const configured = ruleSetting(rule.id);
+    if (configured && typeof configured === "object" && configured.severity) {
+      return results.map((finding) => ({ ...finding, severity: configured.severity }));
+    }
+    return results;
+  }).sort((a, b) => a.id.localeCompare(b.id));
+  const score = calculateScore(findings);
+  const linkGraph = buildLinkGraph(analyzedRoutes, redirects);
+  const recommendations = generateLinkRecommendations(analyzedRoutes);
+  const opportunities = detectContentOpportunities(analyzedRoutes, config.opportunityKeywords);
+  return {
+    score,
+    findings,
+    routes: analyzedRoutes,
+    linkGraph,
+    recommendations,
+    opportunities,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    engineVersion: "0.1.0"
+  };
+}
+
+// src/formatter.ts
+import path3 from "node:path";
+var colors = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  cyan: "\x1B[36m",
+  bgRed: "\x1B[41m",
+  bgGreen: "\x1B[42m"
+};
+function formatScoreBadge(score) {
+  if (score >= 85) return `${colors.green}${colors.bold}${score}/100${colors.reset}`;
+  if (score >= 70) return `${colors.yellow}${colors.bold}${score}/100${colors.reset}`;
+  return `${colors.red}${colors.bold}${score}/100${colors.reset}`;
+}
+function printAuditReport(result, projectRoot) {
+  const { score, findings, routes } = result;
+  console.log("\n" + colors.cyan + colors.bold + "\u{1F50D} Crawlemon Audit" + colors.reset + ` (${routes.length} routes scanned)`);
+  console.log(colors.dim + "\u2500".repeat(50) + colors.reset);
+  console.log(`
+  SEO Score: ${formatScoreBadge(score.overall)}`);
+  console.log(`  ${colors.dim}Technical:     ${score.breakdown.technical.toString().padEnd(4)} Metadata:       ${score.breakdown.metadata}`);
+  console.log(`  Content:       ${score.breakdown.content.toString().padEnd(4)} Internal Links: ${score.breakdown.links}${colors.reset}
+`);
+  if (findings.length === 0) {
+    console.log(`${colors.green}\u2713 All checks passed! No SEO regressions or issues found.${colors.reset}
+`);
+    return;
+  }
+  const errors = findings.filter((f) => f.severity === "error");
+  const warnings = findings.filter((f) => f.severity === "warning");
+  const infos = findings.filter((f) => f.severity === "info");
+  const fixable = findings.filter((f) => f.fixable);
+  console.log(
+    `Found ${colors.red}${errors.length} errors${colors.reset}, ${colors.yellow}${warnings.length} warnings${colors.reset}, ${colors.blue}${infos.length} notices${colors.reset} (${colors.green}${fixable.length} safe auto-fixes available${colors.reset})
+`
+  );
+  for (const f of findings) {
+    let icon = colors.blue + "\u2139" + colors.reset;
+    if (f.severity === "error") icon = colors.red + "\u2716" + colors.reset;
+    if (f.severity === "warning") icon = colors.yellow + "\u26A0" + colors.reset;
+    const fixTag = f.fixable ? ` ${colors.green}[fixable]${colors.reset}` : "";
+    const routeTag = f.route ? ` ${colors.cyan}(${f.route})${colors.reset}` : "";
+    const relativeFile = f.file ? path3.relative(projectRoot, f.file) : "";
+    const fileTag = relativeFile ? `
+    ${colors.dim}${relativeFile}${f.line ? `:${f.line}` : ""}${colors.reset}` : "";
+    console.log(`  ${icon} ${f.message}${fixTag}${routeTag}${fileTag}`);
+  }
+  console.log("\n" + colors.dim + "\u2500".repeat(50) + colors.reset);
+  if (fixable.length > 0) {
+    console.log(`Run ${colors.bold}npx crawlemon fix${colors.reset} to automatically apply safe deterministic fixes.
+`);
+  }
+}
+function printFixReport(result) {
+  const { appliedChanges, skippedFindings, scoreBefore, scoreAfter, dryRun } = result;
+  console.log(
+    "\n" + (dryRun ? colors.yellow + "\u{1F9EA} Crawlemon Fix (Dry Run)" : colors.green + "\u2728 Crawlemon Fix") + colors.reset
+  );
+  console.log(colors.dim + "\u2500".repeat(50) + colors.reset);
+  console.log(`
+  Score Before: ${formatScoreBadge(scoreBefore.overall)}`);
+  console.log(`  Score After:  ${formatScoreBadge(scoreAfter.overall)}
+`);
+  if (appliedChanges.length === 0) {
+    console.log("No safe automatic fixes were applicable.\n");
+  } else {
+    console.log(`${colors.green}\u2713 ${appliedChanges.length} safe fixes ${dryRun ? "would be applied" : "applied"}:${colors.reset}
+`);
+    for (const change of appliedChanges) {
+      console.log(`  \u2022 ${colors.bold}${change.description}${colors.reset}`);
+      if (change.diff) {
+        console.log(colors.dim + change.diff.split("\n").map((l) => "    " + l).join("\n") + colors.reset);
+      }
+    }
+  }
+  if (skippedFindings.length > 0) {
+    console.log(`
+${colors.yellow}\u26A0 ${skippedFindings.length} issues require manual review.${colors.reset}
+`);
+  }
+}
+function printLinkGraphReport(graph, recommendations) {
+  console.log("\n" + colors.cyan + colors.bold + "\u{1F310} Internal Link Graph & Orphans" + colors.reset);
+  console.log(colors.dim + "\u2500".repeat(50) + colors.reset);
+  console.log(`
+  Routes Analyzed:   ${graph.nodes.length}`);
+  console.log(`  Internal Edges:    ${graph.edges.length}`);
+  console.log(`  Orphan Routes:     ${graph.orphans.length > 0 ? colors.red + graph.orphans.length : colors.green + "0"}${colors.reset}`);
+  console.log(`  Broken Edges:      ${graph.brokenEdges.length > 0 ? colors.red + graph.brokenEdges.length : colors.green + "0"}${colors.reset}
+`);
+  console.log(`  Dead-end Routes:   ${graph.deadEnds.length}`);
+  console.log(`  Low Connectivity:  ${graph.lowConnectivity.length}`);
+  console.log(`  Highly Linked:     ${graph.highlyLinked.length}
+`);
+  if (graph.orphans.length > 0) {
+    console.log(`${colors.red}\u26A0 Orphan Pages (No incoming links):${colors.reset}`);
+    for (const orphan of graph.orphans) {
+      console.log(`  \u2022 ${orphan}`);
+    }
+    console.log("");
+  }
+  if (recommendations.length > 0) {
+    console.log(`${colors.green}\u{1F4A1} Recommended Internal Links (Non-AI, TF-IDF Term Overlap):${colors.reset}
+`);
+    for (const rec of recommendations.slice(0, 10)) {
+      console.log(`  ${colors.bold}${rec.sourceRoute}${colors.reset} \u2500\u2500(${rec.score}%)\u2500\u2500> ${colors.cyan}${rec.targetRoute}${colors.reset}`);
+      console.log(`    ${colors.dim}Reason: ${rec.reason}${colors.reset}
+`);
+    }
+  }
+}
+function printOpportunitiesReport(clusters) {
+  console.log("\n" + colors.cyan + colors.bold + "\u{1F680} Content Clusters & Expansion Opportunities" + colors.reset);
+  console.log(colors.dim + "\u2500".repeat(50) + colors.reset);
+  if (clusters.length === 0) {
+    console.log("\nNo repeated topic/slug patterns detected yet. Add more topic pages to generate expansion clusters.\n");
+    return;
+  }
+  for (const c of clusters) {
+    console.log(`
+${colors.bold}Cluster: ${c.topic}${colors.reset} (${colors.dim}${c.pattern}${colors.reset})`);
+    console.log(`  Existing Pages (${c.existingPages.length}):`);
+    for (const p of c.existingPages) {
+      console.log(`    \u2713 ${p}`);
+    }
+    console.log(`  Suggested Expansion Opportunities (${c.potentialOpportunities.length}):`);
+    for (const opp of c.potentialOpportunities) {
+      console.log(`    + ${colors.green}${opp}${colors.reset}`);
+    }
+  }
+  console.log("");
+}
+
+// src/index.ts
+function checkSecretRisk(projectRoot) {
+  const envCandidates = fs3.readdirSync(projectRoot).filter((name) => name !== ".env.example" && (name === ".env" || name.startsWith(".env.")));
+  const gitignorePath = path4.join(projectRoot, ".gitignore");
+  let gitignoreContent = "";
+  if (fs3.existsSync(gitignorePath)) {
+    gitignoreContent = fs3.readFileSync(gitignorePath, "utf8");
+  }
+  for (const env of envCandidates) {
+    const envPath = path4.join(projectRoot, env);
+    if (fs3.existsSync(envPath)) {
+      const tracked = spawnSync("git", ["ls-files", "--error-unmatch", "--", env], {
+        cwd: projectRoot,
+        stdio: "ignore"
+      }).status === 0;
+      if (tracked || !gitignoreContent.includes(env) && !gitignoreContent.includes(".env*")) {
+        console.warn(`\x1B[33m\u26A0 Potential secret risk: "${env}" exists but may not be ignored in .gitignore.\x1B[0m`);
+      }
+    }
+  }
+}
+async function runCli(args) {
+  const command = args[0] || "audit";
+  const projectRoot = process.cwd();
+  if (command === "--help" || command === "help") {
+    console.log("Crawlemon \u2014 deterministic SEO CI for Next.js\n\nCommands:\n  audit\n  fix [--dry-run]\n  links\n  opportunities");
+    return;
+  }
+  if (command === "--version" || command === "-v") {
+    console.log("0.1.0");
+    return;
+  }
+  checkSecretRisk(projectRoot);
+  const isNext = await NextJsAdapter.detect(projectRoot);
+  if (!isNext) {
+    console.error(`\x1B[31m\u2716 Error: No Next.js application detected in "${projectRoot}".\x1B[0m`);
+    process.exit(1);
+  }
+  const scanData = await NextJsAdapter.scan(projectRoot);
+  const auditResult = runSEOAudit({
+    routes: scanData.routes,
+    config: scanData.config,
+    sitemapFound: scanData.sitemapFound,
+    robotsFound: scanData.robotsFound,
+    robotsContent: scanData.robotsContent,
+    sitemapUrls: scanData.sitemapUrls,
+    sitemapMalformed: scanData.sitemapMalformed,
+    redirects: scanData.redirects,
+    projectRoot: scanData.projectRoot,
+    isAppRouter: scanData.isAppRouter
+  });
+  if (command === "audit") {
+    printAuditReport(auditResult, projectRoot);
+    const hasErrors = auditResult.findings.some((f) => f.severity === "error");
+    if (hasErrors && process.env.CI) {
+      process.exit(1);
+    }
+  } else if (command === "fix") {
+    const dryRun = args.includes("--dry-run");
+    const fixResult = await applySafeFixes({
+      projectRoot,
+      routes: scanData.routes,
+      findings: auditResult.findings,
+      config: scanData.config,
+      dryRun,
+      isAppRouter: scanData.isAppRouter
+    });
+    printFixReport(fixResult);
+  } else if (command === "links") {
+    printLinkGraphReport(auditResult.linkGraph, auditResult.recommendations);
+  } else if (command === "opportunities") {
+    printOpportunitiesReport(auditResult.opportunities);
+  } else {
+    console.log(`
+Unknown command: "${command}"`);
+    console.log("Available commands: audit, fix [--dry-run], links, opportunities\n");
+    process.exit(1);
+  }
+}
+export {
+  runCli
+};