@rankture/cli 0.1.1 → 0.1.3

package/dist/index.mjs

@@ -1,5 +1,6 @@
 // src/checks/meta-tags.ts
-function checkMetaTitle(page, allPages) {
+var isDynamic = (value) => /\[dynamic(?::|\])/i.test(value) || /\{[^}]+\}/.test(value);
+function checkMetaTitle(page, allPages, thresholds) {
   const results = [];
   if (!page.title) {
     results.push({
@@ -13,26 +14,27 @@ function checkMetaTitle(page, allPages) {
     });
     return results;
   }
+  const titleRange = thresholds?.titleLength ?? { min: 30, max: 60 };
   const titleLength = page.title.length;
-  if (titleLength < 30) {
+  if (!isDynamic(page.title) && titleLength < titleRange.min) {
     results.push({
       checkId: "meta-title-length",
       name: "Title Too Short",
       severity: "warning",
       passed: false,
       file: page.filePath,
-      message: `Title is too short (${titleLength} chars, recommended 30-60)`,
-      fix: "Expand your title to be more descriptive (30-60 characters)"
+      message: `Title is too short (${titleLength} chars, expected ${titleRange.min}-${titleRange.max})`,
+      fix: `Expand your title to ${titleRange.min}-${titleRange.max} characters`
     });
-  } else if (titleLength > 60) {
+  } else if (!isDynamic(page.title) && titleLength > titleRange.max) {
     results.push({
       checkId: "meta-title-length",
       name: "Title Too Long",
       severity: "warning",
       passed: false,
       file: page.filePath,
-      message: `Title is too long (${titleLength} chars, recommended 30-60)`,
-      fix: "Shorten your title to under 60 characters to prevent truncation in search results"
+      message: `Title is too long (${titleLength} chars, expected ${titleRange.min}-${titleRange.max})`,
+      fix: `Shorten your title to at most ${titleRange.max} characters`
     });
   }
   const duplicates = allPages.filter(
@@ -52,7 +54,7 @@ function checkMetaTitle(page, allPages) {
   }
   return results;
 }
-function checkMetaDescription(page, allPages) {
+function checkMetaDescription(page, allPages, thresholds) {
   const results = [];
   if (!page.metaDescription) {
     results.push({
@@ -66,26 +68,27 @@ function checkMetaDescription(page, allPages) {
     });
     return results;
   }
+  const descriptionRange = thresholds?.descriptionLength ?? { min: 120, max: 160 };
   const descLength = page.metaDescription.length;
-  if (descLength < 120) {
+  if (!isDynamic(page.metaDescription) && descLength < descriptionRange.min) {
     results.push({
       checkId: "meta-description-length",
       name: "Meta Description Too Short",
       severity: "warning",
       passed: false,
       file: page.filePath,
-      message: `Meta description is too short (${descLength} chars, recommended 120-160)`,
-      fix: "Expand your meta description to be more descriptive (120-160 characters)"
+      message: `Meta description is too short (${descLength} chars, expected ${descriptionRange.min}-${descriptionRange.max})`,
+      fix: `Expand your meta description to ${descriptionRange.min}-${descriptionRange.max} characters`
     });
-  } else if (descLength > 160) {
+  } else if (!isDynamic(page.metaDescription) && descLength > descriptionRange.max) {
     results.push({
       checkId: "meta-description-length",
       name: "Meta Description Too Long",
       severity: "warning",
       passed: false,
       file: page.filePath,
-      message: `Meta description is too long (${descLength} chars, recommended 120-160)`,
-      fix: "Shorten your meta description to under 160 characters to prevent truncation"
+      message: `Meta description is too long (${descLength} chars, expected ${descriptionRange.min}-${descriptionRange.max})`,
+      fix: `Shorten your meta description to at most ${descriptionRange.max} characters`
     });
   }
   const duplicates = allPages.filter(
@@ -309,6 +312,50 @@ function checkInternalLinks(page, allPages, basePath) {
   }
   return results;
 }
+async function checkInternalLinksHttp(page, pageUrl, fetcher = fetch) {
+  const brokenLinks = [];
+  const emptyLinks = page.internalLinks.filter((link) => !link.href || link.href === "#");
+  const origin = new URL(pageUrl).origin;
+  for (const link of page.internalLinks) {
+    if (!link.href || link.href === "#" || link.href.startsWith("#") || link.href.startsWith("javascript:")) continue;
+    if (/^\[dynamic/i.test(link.href)) continue;
+    const target = new URL(link.href, pageUrl);
+    if (target.origin !== origin) continue;
+    target.hash = "";
+    try {
+      let response = await fetcher(target, { method: "HEAD", redirect: "manual" });
+      if (response.status === 405) response = await fetcher(target, { method: "GET", redirect: "manual" });
+      if (response.status >= 400) brokenLinks.push(link.href);
+    } catch {
+      brokenLinks.push(link.href);
+    }
+  }
+  const results = [];
+  if (brokenLinks.length > 0) {
+    results.push({
+      checkId: "link-broken-internal",
+      name: "Broken Internal Links",
+      severity: "critical",
+      passed: false,
+      file: page.filePath,
+      message: `${brokenLinks.length} internal link(s) returned an error from the local server`,
+      fix: "Fix or remove links to pages that do not resolve successfully",
+      details: [...new Set(brokenLinks)]
+    });
+  }
+  if (emptyLinks.length > 0) {
+    results.push({
+      checkId: "link-empty-href",
+      name: "Empty Link Href",
+      severity: "warning",
+      passed: false,
+      file: page.filePath,
+      message: `${emptyLinks.length} link(s) have empty or "#" href`,
+      fix: "Add proper href values to all links or use buttons for non-navigation actions"
+    });
+  }
+  return results;
+}
 
 // src/checks/schema.ts
 function checkSchema(page) {
@@ -347,6 +394,9 @@ function checkSchemaJsonValidity(page) {
   while ((match = jsonLdRegex.exec(page.html)) !== null) {
     index++;
     const content = match[1].trim();
+    if (page.isSourceFile && /\{\s*JSON\.stringify\s*\(|\[dynamic(?::|\])/i.test(content)) {
+      continue;
+    }
     if (!content) {
       results.push({
         checkId: "schema-empty",
@@ -831,11 +881,11 @@ function checkAccessibility(page) {
   const buttonsWithoutText = [];
   $("button").each((_, el) => {
     const $btn = $(el);
-    const text = $btn.text().trim();
+    const text2 = $btn.text().trim();
     const ariaLabel = $btn.attr("aria-label");
     const ariaLabelledby = $btn.attr("aria-labelledby");
     const title = $btn.attr("title");
-    if (!text && !ariaLabel && !ariaLabelledby && !title) {
+    if (!text2 && !ariaLabel && !ariaLabelledby && !title) {
       const className = $btn.attr("class") || "";
       const id = $btn.attr("id") || "";
       buttonsWithoutText.push(className || id || "unnamed button");
@@ -856,12 +906,12 @@ function checkAccessibility(page) {
   const linksWithoutText = [];
   $("a[href]").each((_, el) => {
     const $link = $(el);
-    const text = $link.text().trim();
+    const text2 = $link.text().trim();
     const ariaLabel = $link.attr("aria-label");
     const ariaLabelledby = $link.attr("aria-labelledby");
     const title = $link.attr("title");
     const hasImg = $link.find("img[alt]").length > 0;
-    if (!text && !ariaLabel && !ariaLabelledby && !title && !hasImg) {
+    if (!text2 && !ariaLabel && !ariaLabelledby && !title && !hasImg) {
       const href = $link.attr("href") || "";
       linksWithoutText.push(href.substring(0, 50));
     }
@@ -953,8 +1003,8 @@ function checkAccessibility(page) {
   }
   const emptyTableHeaders = [];
   $("th").each((index, el) => {
-    const text = $(el).text().trim();
-    if (!text) {
+    const text2 = $(el).text().trim();
+    if (!text2) {
       emptyTableHeaders.push(index + 1);
     }
   });
@@ -1027,6 +1077,61 @@ function checkFocusIndicators(page) {
   return results;
 }
 
+// src/lib/provenance.ts
+var RULE_PATTERNS = [
+  [/^meta-title-(?:length|duplicate)$/, /<title\b|\btitle\s*:/i],
+  [/^meta-description-(?:length|duplicate)$/, /<meta\b[^>]*(?:name|property)=["'](?:description|og:description)["']|\bdescription\s*:/i],
+  [/^h1-multiple$/, /<h1\b|^#\s+/im],
+  [/^heading-hierarchy$/, /<h[1-6]\b|^#{1,6}\s+/im],
+  [/^image-alt-/, /<(?:img|Image|NuxtImg)\b|^\s*img\(/im],
+  [/^link-(?:empty-href|broken-internal)$/, /<(?:a|Link|NuxtLink)\b|^\s*a\(/im],
+  [/^schema-/, /<script\b[^>]*application\/ld\+json|["']@context["']|["']@type["']/i],
+  [/^og-/, /<meta\b[^>]*property=["']og:/i],
+  [/^twitter-/, /<meta\b[^>]*(?:name|property)=["']twitter:/i],
+  [/^robots-/, /<meta\b[^>]*name=["']robots["']/i],
+  [/^a11y-multiple-main$/, /<(?:main\b|[^>]+role=["']main["'])/i],
+  [/^a11y-button-name$/, /<button\b/i],
+  [/^a11y-link-name$/, /<a\b/i],
+  [/^a11y-input-label$/, /<(?:input|textarea|select)\b/i],
+  [/^a11y-tabindex-positive$/, /\btabindex\s*=\s*["']?[1-9]/i],
+  [/^a11y-autoplay-audio$/, /<video\b[^>]*autoplay/i],
+  [/^a11y-empty-th$/, /<th\b/i],
+  [/^a11y-color-contrast$/, /\bcolor\s*:/i],
+  [/^a11y-focus-outline$/, /\boutline\s*:\s*(?:none|0)/i]
+];
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function detailPattern(result) {
+  const detail = result.details?.find((value) => value && value !== "unnamed" && !/^\d+$/.test(value));
+  if (!detail) return void 0;
+  if (result.checkId.startsWith("image-alt-")) {
+    return new RegExp(`(?:<(?:img|Image|NuxtImg)\\b[^>]*\\bsrc\\s*=\\s*["']${escapeRegExp(detail)}["']|^\\s*img\\([^\\n]*\\bsrc\\s*=\\s*["']${escapeRegExp(detail)}["'])`, "im");
+  }
+  if (result.checkId.startsWith("link-") || result.checkId === "a11y-link-name") {
+    return new RegExp(`<(?:a|Link|NuxtLink)\\b[^>]*\\bhref\\s*=\\s*["']${escapeRegExp(detail)}["']`, "i");
+  }
+  if (result.checkId === "heading-hierarchy") {
+    const quoted = detail.match(/["'](.+?)["']/)?.[1]?.replace(/\.\.\.$/, "");
+    if (quoted) return new RegExp(escapeRegExp(quoted), "i");
+  }
+  return void 0;
+}
+function offsetToLocation(source, offset) {
+  const before = source.slice(0, offset);
+  const lines = before.split("\n");
+  return { line: lines.length, column: lines[lines.length - 1].length + 1 };
+}
+function locateFinding(page, result) {
+  if (result.passed || result.line) return result;
+  const source = page.sourceContent ?? page.html;
+  const pattern = detailPattern(result) ?? RULE_PATTERNS.find(([rule]) => rule.test(result.checkId))?.[1];
+  if (!pattern) return result;
+  const match = pattern.exec(source);
+  if (!match) return result;
+  return { ...result, ...offsetToLocation(source, match.index) };
+}
+
 // src/checks/index.ts
 var checks = [
   // Meta tags
@@ -1035,14 +1140,14 @@ var checks = [
     name: "Title Tag",
     description: "Check for missing, short, long, or duplicate title tags",
     severity: "critical",
-    run: (page, allPages) => checkMetaTitle(page, allPages)
+    run: (page, allPages, _basePath, thresholds) => checkMetaTitle(page, allPages, thresholds)
   },
   {
     id: "meta-description",
     name: "Meta Description",
     description: "Check for missing, short, long, or duplicate meta descriptions",
     severity: "warning",
-    run: (page, allPages) => checkMetaDescription(page, allPages)
+    run: (page, allPages, _basePath, thresholds) => checkMetaDescription(page, allPages, thresholds)
   },
   {
     id: "viewport",
@@ -1177,13 +1282,13 @@ var checks = [
     run: (page) => checkFocusIndicators(page)
   }
 ];
-function runChecks(page, allPages, basePath, enabledChecks) {
+function runChecks(page, allPages, basePath, enabledChecks, thresholds) {
   const results = [];
   for (const check of checks) {
     if (enabledChecks && !enabledChecks.has(check.id)) {
       continue;
     }
-    const checkResults = check.run(page, allPages, basePath);
+    const checkResults = check.run(page, allPages, basePath, thresholds);
     if (checkResults.every((r) => r.passed)) {
       results.push({
         checkId: check.id,
@@ -1194,7 +1299,7 @@ function runChecks(page, allPages, basePath, enabledChecks) {
         message: `${check.name}: no issues found`
       });
     }
-    results.push(...checkResults);
+    results.push(...checkResults.map((result) => locateFinding(page, result)));
   }
   return results;
 }
@@ -1242,15 +1347,15 @@ function parseHtml(filePath, html) {
   const lang = $("html").attr("lang")?.trim() || void 0;
   const h1s = [];
   $("h1").each((_, el) => {
-    const text = $(el).text().trim();
-    if (text) h1s.push(text);
+    const text2 = $(el).text().trim();
+    if (text2) h1s.push(text2);
   });
   const headings = [];
   $("h1, h2, h3, h4, h5, h6").each((_, el) => {
     const tagName = el.tagName.toLowerCase();
     const level = parseInt(tagName.replace("h", ""), 10);
-    const text = $(el).text().trim();
-    if (text) headings.push({ level, text });
+    const text2 = $(el).text().trim();
+    if (text2) headings.push({ level, text: text2 });
   });
   const images = [];
   $("img").each((_, el) => {
@@ -1262,14 +1367,14 @@ function parseHtml(filePath, html) {
   const externalLinks = [];
   $("a[href]").each((_, el) => {
     const href = $(el).attr("href") || "";
-    const text = $(el).text().trim();
+    const text2 = $(el).text().trim();
     if (href.startsWith("javascript:") || href.startsWith("mailto:") || href.startsWith("tel:")) {
       return;
     }
     if (href.startsWith("http://") || href.startsWith("https://") || href.startsWith("//")) {
-      externalLinks.push({ href, text });
+      externalLinks.push({ href, text: text2 });
     } else {
-      internalLinks.push({ href, text });
+      internalLinks.push({ href, text: text2 });
     }
   });
   const jsonLd = [];
@@ -1303,6 +1408,7 @@ function parseHtml(filePath, html) {
   return {
     filePath,
     html,
+    sourceContent: html,
     title,
     metaDescription,
     canonical,
@@ -1323,7 +1429,7 @@ function parseHtml(filePath, html) {
 }
 function parseSourceFile(filePath, content) {
   const ext = filePath.toLowerCase().split(".").pop() || "";
-  let htmlContent = content;
+  let htmlContent;
   switch (ext) {
     case "astro":
       htmlContent = parseAstroFile(content);
@@ -1466,7 +1572,7 @@ function parsePugFile(content) {
     }
     const tagMatch = trimmed.match(/^(h[1-6]|p|a|img|title|meta)([.#(][^\s]*)?\s*(.*)?$/);
     if (tagMatch) {
-      const [, tag, attrs, text] = tagMatch;
+      const [, tag, attrs, text2] = tagMatch;
       if (tag === "img") {
         const srcMatch = (attrs || "").match(/src=['"]([^'"]+)['"]/);
         const altMatch = (attrs || "").match(/alt=['"]([^'"]*)['"]/);
@@ -1474,16 +1580,16 @@ function parsePugFile(content) {
 `;
       } else if (tag === "a") {
         const hrefMatch = (attrs || "").match(/href=['"]([^'"]+)['"]/);
-        htmlContent += `<a href="${hrefMatch?.[1] || ""}">${text || ""}</a>
+        htmlContent += `<a href="${hrefMatch?.[1] || ""}">${text2 || ""}</a>
 `;
       } else if (tag === "title") {
-        htmlContent += `<title>${text || ""}</title>
+        htmlContent += `<title>${text2 || ""}</title>
 `;
       } else if (tag === "meta") {
         htmlContent += `<meta ${attrs?.replace(/[()]/g, "") || ""}>
 `;
       } else {
-        htmlContent += `<${tag}>${text || ""}</${tag}>
+        htmlContent += `<${tag}>${text2 || ""}</${tag}>
 `;
       }
     }
@@ -1506,7 +1612,7 @@ function convertMarkdownLinks(content) {
   return content.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2">$1</a>');
 }
 function extractJsxContent(content) {
-  let jsxContent = "";
+  let jsxContent;
   const withoutImports = content.replace(/^import\s+.*?;?\s*$/gm, "");
   const returnBlocks = [];
   const standardReturns = withoutImports.match(/return\s*\([\s\S]*?\n\s*\);/g);
@@ -1631,12 +1737,12 @@ function parseHtmlLikeContent(filePath, originalContent, htmlContent) {
   const $ = cheerio2.load(htmlContent, { xml: false });
   const h1s = [];
   $("h1").each((_, el) => {
-    let text = $(el).text().trim();
+    let text2 = $(el).text().trim();
     const html = $(el).html() || "";
     if (html.includes("{") && html.includes("}")) {
-      text = `[dynamic: ${html.replace(/<[^>]+>/g, "").trim()}]`;
+      text2 = `[dynamic: ${html.replace(/<[^>]+>/g, "").trim()}]`;
     }
-    if (text) h1s.push(text);
+    if (text2) h1s.push(text2);
   });
   const mdH1Match = originalContent.match(/^#\s+(.+)$/m);
   if (mdH1Match && h1s.length === 0) {
@@ -1646,12 +1752,12 @@ function parseHtmlLikeContent(filePath, originalContent, htmlContent) {
   $("h1, h2, h3, h4, h5, h6").each((_, el) => {
     const tagName = el.tagName.toLowerCase();
     const level = parseInt(tagName.replace("h", ""), 10);
-    let text = $(el).text().trim();
+    let text2 = $(el).text().trim();
     const html = $(el).html() || "";
     if (html.includes("{") && html.includes("}")) {
-      text = `[dynamic: ${html.replace(/<[^>]+>/g, "").trim()}]`;
+      text2 = `[dynamic: ${html.replace(/<[^>]+>/g, "").trim()}]`;
     }
-    if (text) headings.push({ level, text });
+    if (text2) headings.push({ level, text: text2 });
   });
   const images = [];
   $("img").each((_, el) => {
@@ -1672,7 +1778,7 @@ function parseHtmlLikeContent(filePath, originalContent, htmlContent) {
   const externalLinks = [];
   $("a[href], Link[href], Link[to]").each((_, el) => {
     let href = $(el).attr("href") || $(el).attr("to") || "";
-    const text = $(el).text().trim();
+    const text2 = $(el).text().trim();
     if (!href || href === "#" || href.startsWith("javascript:") || href.startsWith("mailto:") || href.startsWith("tel:")) {
       return;
     }
@@ -1680,9 +1786,9 @@ function parseHtmlLikeContent(filePath, originalContent, htmlContent) {
       href = `[dynamic: ${href}]`;
     }
     if (href.startsWith("http://") || href.startsWith("https://") || href.startsWith("//")) {
-      externalLinks.push({ href, text });
+      externalLinks.push({ href, text: text2 });
     } else {
-      internalLinks.push({ href, text });
+      internalLinks.push({ href, text: text2 });
     }
   });
   let title;
@@ -1707,9 +1813,21 @@ function parseHtmlLikeContent(filePath, originalContent, htmlContent) {
       metaDescription = descMatch[1].trim();
     }
   }
+  const jsonLd = [];
+  $('script[type="application/ld+json"]').each((_, el) => {
+    const value = ($(el).html() ?? "").trim();
+    if (!value || /^(?:\{|\[)?\s*JSON\.stringify\s*\(/.test(value.replace(/^\{/, ""))) return;
+    try {
+      const parsed = JSON.parse(value);
+      if (Array.isArray(parsed)) jsonLd.push(...parsed.filter((item) => item && typeof item === "object"));
+      else if (parsed && typeof parsed === "object") jsonLd.push(parsed);
+    } catch {
+    }
+  });
   return {
     filePath,
     html: originalContent,
+    sourceContent: originalContent,
     title,
     metaDescription,
     canonical: void 0,
@@ -1721,7 +1839,7 @@ function parseHtmlLikeContent(filePath, originalContent, htmlContent) {
     images,
     internalLinks,
     externalLinks,
-    jsonLd: [],
+    jsonLd,
     ogTags: {},
     twitterTags: {},
     robots: void 0,
@@ -1733,6 +1851,7 @@ function parseHtmlLikeContent(filePath, originalContent, htmlContent) {
 // src/lib/config.ts
 import * as fs2 from "fs";
 import * as path2 from "path";
+import { pathToFileURL } from "url";
 var CONFIG_FILES = [
   "rankture.config.json",
   "rankture.config.js",
@@ -1752,13 +1871,16 @@ var defaultConfig = {
 };
 async function loadConfig(basePath, configPath) {
   if (configPath) {
-    const absolutePath = path2.resolve(basePath, configPath);
+    const absolutePath = path2.resolve(configPath);
     if (!fs2.existsSync(absolutePath)) {
       throw new Error(`Config file not found: ${absolutePath}`);
     }
     return parseConfigFile(absolutePath);
   }
   let currentDir = path2.resolve(basePath);
+  if (fs2.existsSync(currentDir) && fs2.statSync(currentDir).isFile()) {
+    currentDir = path2.dirname(currentDir);
+  }
   const root = path2.parse(currentDir).root;
   while (currentDir !== root) {
     for (const configName of CONFIG_FILES) {
@@ -1772,6 +1894,7 @@ async function loadConfig(basePath, configPath) {
       try {
         const packageJson = JSON.parse(fs2.readFileSync(packageJsonPath, "utf-8"));
         if (packageJson.rankture) {
+          assertValidConfig(packageJson.rankture, packageJsonPath);
           return mergeConfig(defaultConfig, packageJson.rankture);
         }
       } catch {
@@ -1785,18 +1908,21 @@ async function parseConfigFile(filePath) {
   const ext = path2.extname(filePath).toLowerCase();
   if (ext === ".js" || ext === ".mjs") {
     try {
-      const config = await import(filePath);
-      return mergeConfig(defaultConfig, config.default || config);
+      const imported = await import(`${pathToFileURL(filePath).href}?t=${fs2.statSync(filePath).mtimeMs}`);
+      const config = imported.default || imported;
+      assertValidConfig(config, filePath);
+      return mergeConfig(defaultConfig, config);
     } catch (error) {
-      throw new Error(`Failed to load config from ${filePath}: ${error}`);
+      throw new Error(`Failed to load config from ${filePath}: ${error}`, { cause: error });
     }
   } else {
     try {
       const content = fs2.readFileSync(filePath, "utf-8");
       const config = JSON.parse(content);
+      assertValidConfig(config, filePath);
       return mergeConfig(defaultConfig, config);
     } catch (error) {
-      throw new Error(`Failed to parse config from ${filePath}: ${error}`);
+      throw new Error(`Failed to parse config from ${filePath}: ${error}`, { cause: error });
     }
   }
 }
@@ -1809,10 +1935,105 @@ function mergeConfig(defaults, userConfig) {
     rules: { ...defaults.rules, ...userConfig.rules },
     thresholds: {
       ...defaults.thresholds,
-      ...userConfig.thresholds
+      ...userConfig.thresholds,
+      titleLength: {
+        ...defaults.thresholds?.titleLength ?? { min: 30, max: 60 },
+        ...userConfig.thresholds?.titleLength
+      },
+      descriptionLength: {
+        ...defaults.thresholds?.descriptionLength ?? { min: 120, max: 160 },
+        ...userConfig.thresholds?.descriptionLength
+      }
     }
   };
 }
+function validateConfig(config) {
+  return getConfigErrors(config).length === 0;
+}
+function getConfigErrors(config) {
+  const errors = [];
+  if (typeof config !== "object" || config === null) {
+    return ["configuration must export an object"];
+  }
+  const c = config;
+  if (c.checks !== void 0) {
+    if (typeof c.checks !== "object" || c.checks === null) {
+      errors.push("checks must be an object whose values are booleans");
+    } else {
+      for (const [key, value] of Object.entries(c.checks)) {
+        if (typeof value !== "boolean") errors.push(`checks.${key} must be true or false`);
+      }
+    }
+  }
+  if (c.ignore !== void 0) {
+    if (!Array.isArray(c.ignore)) {
+      errors.push("ignore must be an array of glob strings");
+    }
+    if (Array.isArray(c.ignore) && !c.ignore.every((item) => typeof item === "string")) {
+      errors.push("ignore must contain only strings");
+    }
+  }
+  if (c.rules !== void 0) {
+    if (typeof c.rules !== "object" || c.rules === null) {
+      errors.push("rules must be an object of critical, warning, or info severities");
+    }
+    const validSeverities = ["critical", "warning", "info"];
+    for (const value of Object.values(c.rules)) {
+      if (!validSeverities.includes(value)) {
+        errors.push(`rules contains invalid severity "${String(value)}"`);
+      }
+    }
+  }
+  if (c.thresholds !== void 0) {
+    if (typeof c.thresholds !== "object" || c.thresholds === null || Array.isArray(c.thresholds)) {
+      errors.push("thresholds must be an object");
+    } else {
+      const thresholds = c.thresholds;
+      for (const name of ["titleLength", "descriptionLength"]) {
+        const value = thresholds[name];
+        if (value === void 0) continue;
+        if (typeof value !== "object" || value === null || Array.isArray(value)) {
+          errors.push(`thresholds.${name} must contain numeric min and max values`);
+          continue;
+        }
+        const range = value;
+        if (!Number.isFinite(range.min) || !Number.isFinite(range.max)) {
+          errors.push(`thresholds.${name}.min and .max must be finite numbers`);
+        } else if (range.min < 0 || range.max < range.min) {
+          errors.push(`thresholds.${name} must satisfy 0 <= min <= max`);
+        }
+      }
+      for (const name of ["maxImageSize", "maxPageSize"]) {
+        const value = thresholds[name];
+        if (value !== void 0 && (!Number.isFinite(value) || value <= 0)) {
+          errors.push(`thresholds.${name} must be a positive number`);
+        }
+      }
+    }
+  }
+  if (c.apiKey !== void 0 && typeof c.apiKey !== "string") errors.push("apiKey must be a string");
+  if (c.sync !== void 0 && typeof c.sync !== "boolean") errors.push("sync must be true or false");
+  if (c.websiteId !== void 0 && typeof c.websiteId !== "string") errors.push("websiteId must be a string");
+  if (c.apiUrl !== void 0) {
+    if (typeof c.apiUrl !== "string") errors.push("apiUrl must be a string");
+    else {
+      try {
+        const value = new URL(c.apiUrl);
+        if (!["http:", "https:"].includes(value.protocol)) errors.push("apiUrl must use http or https");
+      } catch {
+        errors.push("apiUrl must be a valid URL");
+      }
+    }
+  }
+  return errors;
+}
+function assertValidConfig(config, source) {
+  const errors = getConfigErrors(config);
+  if (errors.length > 0) {
+    throw new Error(`Invalid Rankture config (${source}):
+- ${errors.join("\n- ")}`);
+  }
+}
 function getEnabledChecks(config, allChecks) {
   const enabled = /* @__PURE__ */ new Set();
   for (const checkId of allChecks) {
@@ -1824,143 +2045,764 @@ function getEnabledChecks(config, allChecks) {
   return enabled;
 }
 
-// src/reporters/terminal.ts
-import chalk from "chalk";
-function formatTerminal(report) {
-  const lines = [];
-  lines.push("");
-  lines.push(chalk.bold.cyan("  Rankture SEO Check"));
-  lines.push(chalk.gray("  " + "\u2500".repeat(40)));
-  lines.push("");
-  lines.push(chalk.gray(`  Checking ${report.path} (${report.summary.totalFiles} files)...`));
-  lines.push("");
-  const critical = report.results.filter((r) => !r.passed && r.severity === "critical");
-  const warnings = report.results.filter((r) => !r.passed && r.severity === "warning");
-  const info = report.results.filter((r) => !r.passed && r.severity === "info");
-  if (critical.length > 0) {
-    for (const result of critical) {
-      lines.push(formatResult(result));
-    }
+// src/lib/baseline.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+function issueKey(result, basePath) {
+  const file = result.file ? path3.relative(basePath, path3.resolve(basePath, result.file)).split(path3.sep).join("/") : "";
+  return `${result.checkId}|${file}`;
+}
+function buildBaseline(failures, basePath, timestamp) {
+  const issues = {};
+  for (const failure of failures) {
+    const key = issueKey(failure, basePath);
+    issues[key] = (issues[key] || 0) + 1;
   }
-  if (warnings.length > 0) {
-    for (const result of warnings) {
-      lines.push(formatResult(result));
-    }
+  return { version: 1, createdAt: timestamp, issues };
+}
+function loadBaseline(filePath) {
+  const absolute = path3.resolve(filePath);
+  if (!fs3.existsSync(absolute)) {
+    throw new Error(`Baseline file not found: ${absolute} (create it with --update-baseline)`);
   }
-  if (info.length > 0) {
-    for (const result of info) {
-      lines.push(formatResult(result));
+  const parsed = JSON.parse(fs3.readFileSync(absolute, "utf-8"));
+  if (parsed.version !== 1 || typeof parsed.issues !== "object" || parsed.issues === null) {
+    throw new Error(`Unrecognized baseline format in ${absolute}`);
+  }
+  return parsed;
+}
+function saveBaseline(filePath, baseline) {
+  fs3.writeFileSync(path3.resolve(filePath), JSON.stringify(baseline, null, 2) + "\n");
+}
+function applyBaseline(failures, baseline, basePath) {
+  const remaining = new Map(Object.entries(baseline.issues));
+  const fresh = [];
+  let suppressed = 0;
+  for (const failure of failures) {
+    const key = issueKey(failure, basePath);
+    const allowance = remaining.get(key) || 0;
+    if (allowance > 0) {
+      remaining.set(key, allowance - 1);
+      suppressed++;
+    } else {
+      fresh.push(failure);
     }
   }
-  lines.push("");
-  lines.push(chalk.gray("  " + "\u2500".repeat(40)));
-  const summaryParts = [];
-  if (report.summary.critical > 0) {
-    summaryParts.push(chalk.red.bold(`${report.summary.critical} critical`));
+  return { fresh, suppressed };
+}
+
+// src/lib/ci-env.ts
+import { execSync } from "child_process";
+function collectCiMetadata(env = process.env, cwd) {
+  if (env.GITHUB_ACTIONS === "true") {
+    const prMatch = env.GITHUB_REF?.match(/^refs\/pull\/(\d+)\//);
+    return withoutEmpty({
+      provider: "github-actions",
+      commit: env.GITHUB_SHA,
+      branch: env.GITHUB_HEAD_REF || env.GITHUB_REF_NAME,
+      pullRequest: prMatch ? Number(prMatch[1]) : void 0,
+      buildUrl: env.GITHUB_SERVER_URL && env.GITHUB_REPOSITORY && env.GITHUB_RUN_ID ? `${env.GITHUB_SERVER_URL}/${env.GITHUB_REPOSITORY}/actions/runs/${env.GITHUB_RUN_ID}` : void 0
+    });
   }
-  if (report.summary.warning > 0) {
-    summaryParts.push(chalk.yellow.bold(`${report.summary.warning} warnings`));
+  if (env.GITLAB_CI === "true") {
+    return withoutEmpty({
+      provider: "gitlab-ci",
+      commit: env.CI_COMMIT_SHA,
+      branch: env.CI_COMMIT_REF_NAME,
+      pullRequest: env.CI_MERGE_REQUEST_IID ? Number(env.CI_MERGE_REQUEST_IID) : void 0,
+      buildUrl: env.CI_JOB_URL
+    });
   }
-  if (report.summary.info > 0) {
-    summaryParts.push(chalk.blue(`${report.summary.info} info`));
+  if (env.VERCEL === "1") {
+    return withoutEmpty({
+      provider: "vercel",
+      commit: env.VERCEL_GIT_COMMIT_SHA,
+      branch: env.VERCEL_GIT_COMMIT_REF
+    });
   }
-  summaryParts.push(chalk.green(`${report.summary.passed} passed`));
-  lines.push(`  Results: ${summaryParts.join(", ")}`);
-  lines.push("");
-  if (report.summary.critical > 0) {
-    lines.push(chalk.red.bold("  \u2717 Check failed (critical issues found)"));
-  } else if (report.summary.warning > 0) {
-    lines.push(chalk.yellow("  \u26A0 Check completed with warnings"));
-  } else {
-    lines.push(chalk.green.bold("  \u2713 All checks passed!"));
+  try {
+    const git = (args) => execSync(`git ${args}`, { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    const commit = git("rev-parse HEAD");
+    const branch = git("rev-parse --abbrev-ref HEAD");
+    if (commit) {
+      return { provider: "git", commit, branch: branch !== "HEAD" ? branch : void 0 };
+    }
+  } catch {
   }
-  lines.push("");
-  return lines.join("\n");
+  return void 0;
 }
-function formatResult(result) {
-  const lines = [];
-  let icon;
-  let color;
-  switch (result.severity) {
-    case "critical":
-      icon = "\u2717";
-      color = chalk.red;
-      break;
-    case "warning":
-      icon = "\u26A0";
-      color = chalk.yellow;
-      break;
-    case "info":
-    default:
-      icon = "\u2139";
-      color = chalk.blue;
-      break;
-  }
-  lines.push(
-    `  ${color(icon)} ${color.bold(result.severity.toUpperCase().padEnd(8))} ${chalk.gray(result.checkId)}`
+function withoutEmpty(meta) {
+  return Object.fromEntries(
+    Object.entries(meta).filter(([, value]) => value !== void 0 && value !== "")
   );
-  if (result.file) {
-    lines.push(`    ${chalk.cyan(result.file)} - ${result.message}`);
-  } else {
-    lines.push(`    ${result.message}`);
-  }
-  if (result.details && result.details.length > 0) {
-    const maxDetails = 5;
-    const showDetails = result.details.slice(0, maxDetails);
-    for (const detail of showDetails) {
-      lines.push(chalk.gray(`      - ${detail}`));
-    }
-    if (result.details.length > maxDetails) {
-      lines.push(chalk.gray(`      ... and ${result.details.length - maxDetails} more`));
+}
+
+// src/lib/static-server.ts
+import * as fs4 from "fs";
+import * as http from "http";
+import * as path4 from "path";
+var CONTENT_TYPES = {
+  ".css": "text/css; charset=utf-8",
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".txt": "text/plain; charset=utf-8",
+  ".xml": "application/xml; charset=utf-8"
+};
+function resolveRequest(root, pathname) {
+  let decoded;
+  try {
+    decoded = decodeURIComponent(pathname);
+  } catch {
+    return void 0;
+  }
+  const relative6 = decoded.replace(/^\/+/, "");
+  const candidates = decoded.endsWith("/") ? [path4.join(relative6, "index.html")] : [relative6, `${relative6}.html`, path4.join(relative6, "index.html")];
+  for (const candidate of candidates) {
+    const resolved = path4.resolve(root, candidate || "index.html");
+    if (resolved !== root && !resolved.startsWith(`${root}${path4.sep}`)) continue;
+    if (fs4.existsSync(resolved) && fs4.statSync(resolved).isFile()) return resolved;
+  }
+  return void 0;
+}
+async function startStaticServer(rootPath, port = 0) {
+  const root = path4.resolve(rootPath);
+  const server = http.createServer((request, response) => {
+    const pathname = new URL(request.url ?? "/", "http://localhost").pathname;
+    const file = resolveRequest(root, pathname);
+    if (!file) {
+      response.writeHead(404, { "Content-Type": "text/plain; charset=utf-8" });
+      response.end("Not found");
+      return;
     }
-  }
-  lines.push("");
-  return lines.join("\n");
+    response.writeHead(200, {
+      "Content-Type": CONTENT_TYPES[path4.extname(file).toLowerCase()] ?? "application/octet-stream",
+      "Content-Length": fs4.statSync(file).size
+    });
+    if (request.method === "HEAD") response.end();
+    else fs4.createReadStream(file).pipe(response);
+  });
+  await new Promise((resolve10, reject) => {
+    server.once("error", reject);
+    server.listen(port, "127.0.0.1", resolve10);
+  });
+  const address = server.address();
+  if (!address || typeof address === "string") throw new Error("Unable to determine local server address");
+  return {
+    origin: `http://127.0.0.1:${address.port}`,
+    close: () => new Promise((resolve10, reject) => server.close((error) => error ? reject(error) : resolve10()))
+  };
+}
+function pageUrlForFile(filePath, rootPath, origin) {
+  let relative6 = path4.relative(rootPath, filePath).split(path4.sep).join("/");
+  if (relative6 === "index.html") relative6 = "";
+  else if (relative6.endsWith("/index.html")) relative6 = relative6.slice(0, -"index.html".length);
+  return new URL(`/${relative6}`, origin).href;
 }
 
-// src/reporters/json.ts
-function formatJson(report) {
-  return JSON.stringify(report, null, 2);
+// src/lib/credentials.ts
+import * as fs5 from "fs";
+import * as os from "os";
+import * as path5 from "path";
+function credentialFile(env = process.env) {
+  const base = env.RANKTURE_CONFIG_DIR || env.XDG_CONFIG_HOME || (process.platform === "win32" ? env.APPDATA : path5.join(os.homedir(), ".config"));
+  return path5.join(base || path5.join(os.homedir(), ".config"), "rankture", "credentials.json");
+}
+function saveCredentials(credentials, env = process.env) {
+  const file = credentialFile(env);
+  fs5.mkdirSync(path5.dirname(file), { recursive: true, mode: 448 });
+  fs5.writeFileSync(file, `${JSON.stringify(credentials, null, 2)}
+`, { mode: 384 });
+  fs5.chmodSync(file, 384);
+  return file;
+}
+function loadCredentials(env = process.env) {
+  if (env.RANKTURE_API_KEY) {
+    return { apiKey: env.RANKTURE_API_KEY, apiUrl: env.RANKTURE_API_URL || "https://rankture.com" };
+  }
+  const file = credentialFile(env);
+  if (!fs5.existsSync(file)) return void 0;
+  const value = JSON.parse(fs5.readFileSync(file, "utf8"));
+  if (!value.apiKey || !value.apiUrl) return void 0;
+  return { apiKey: value.apiKey, apiUrl: value.apiUrl.replace(/\/$/, "") };
+}
+function clearCredentials(env = process.env) {
+  const file = credentialFile(env);
+  if (!fs5.existsSync(file)) return false;
+  fs5.unlinkSync(file);
+  return true;
 }
 
-// src/reporters/html.ts
-function formatHtml(report) {
-  const { summary, results } = report;
-  const byFile = /* @__PURE__ */ new Map();
-  results.forEach((r) => {
-    const file = r.file || "Unknown";
-    if (!byFile.has(file)) {
-      byFile.set(file, []);
+// src/lib/api-client.ts
+import { createHash } from "crypto";
+function credentialsOrThrow(override) {
+  const stored = loadCredentials();
+  const apiKey = override?.apiKey || stored?.apiKey;
+  const apiUrl = (override?.apiUrl || stored?.apiUrl || "https://rankture.com").replace(/\/$/, "");
+  if (!apiKey) throw new Error("Not logged in. Run: rankture login --api-key <key>");
+  return { apiKey, apiUrl };
+}
+async function cliApiRequest(pathname, init = {}, override) {
+  const credentials = credentialsOrThrow(override);
+  const response = await fetch(`${credentials.apiUrl}${pathname}`, {
+    ...init,
+    headers: {
+      Authorization: `Bearer ${credentials.apiKey}`,
+      "Content-Type": "application/json",
+      "User-Agent": "rankture-cli",
+      ...init.headers
     }
-    byFile.get(file).push(r);
   });
-  const totalChecks = summary.passed + summary.critical + summary.warning + summary.info;
-  const score = totalChecks > 0 ? Math.round(summary.passed / totalChecks * 100) : 100;
-  const scoreColor = score >= 90 ? "#22c55e" : score >= 70 ? "#eab308" : score >= 50 ? "#f97316" : "#ef4444";
-  const html = `<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>SEO Audit Report - ${new Date(report.timestamp).toLocaleDateString()}</title>
-  <style>
-    * {
-      margin: 0;
-      padding: 0;
-      box-sizing: border-box;
+  const body = await response.json().catch(() => ({}));
+  if (!response.ok) throw new Error(String(body.error || body.message || `Rankture API returned ${response.status}`));
+  return body;
+}
+var getIdentity = (override) => cliApiRequest("/api/cli/me", {}, override);
+var getWebsites = (override) => cliApiRequest("/api/cli/websites", {}, override);
+var syncCheckReport = (report, websiteId, override) => cliApiRequest("/api/cli/sync", {
+  method: "POST",
+  headers: { "X-Idempotency-Key": createHash("sha256").update(`${websiteId || ""}:${report.timestamp}:${report.ci?.commit || ""}`).digest("hex") },
+  body: JSON.stringify({ schemaVersion: 1, report, websiteId })
+}, override);
+var startRemoteAudit = (url, options = {}, override) => cliApiRequest("/api/cli/audits", {
+  method: "POST",
+  body: JSON.stringify({ url, pages: options.pages })
+}, override);
+var getRemoteAudit = (auditId, override, full = false) => cliApiRequest(`/api/cli/audits/${encodeURIComponent(auditId)}${full ? "?full=true" : ""}`, {}, override);
+
+// src/mcp/server.ts
+import { spawnSync } from "child_process";
+import * as path7 from "path";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import * as z from "zod/v4";
+
+// src/commands/validate.ts
+import * as fs6 from "fs";
+import * as path6 from "path";
+import chalk from "chalk";
+import { XMLParser } from "fast-xml-parser";
+async function validateSchema(filePath) {
+  const result = { valid: true, errors: [], warnings: [], info: [] };
+  const absolutePath = path6.resolve(filePath);
+  if (!fs6.existsSync(absolutePath)) {
+    return { ...result, valid: false, errors: [`File not found: ${absolutePath}`] };
+  }
+  const content = fs6.readFileSync(absolutePath, "utf-8");
+  const ext = path6.extname(absolutePath).toLowerCase();
+  if (ext === ".json" || ext === ".jsonld") {
+    try {
+      const parsed = JSON.parse(content);
+      const nodes = Array.isArray(parsed) ? parsed : [parsed];
+      for (const [index, node] of nodes.entries()) {
+        validateSchemaNode(node, `Schema ${index + 1}`, result);
+      }
+      result.info.push(`${nodes.length} JSON-LD schema object(s) checked`);
+    } catch (error) {
+      result.valid = false;
+      result.errors.push(`Invalid JSON: ${error instanceof Error ? error.message : String(error)}`);
     }
-    
-    body {
-      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
-      background: #f8fafc;
-      color: #1e293b;
-      line-height: 1.6;
+    return result;
+  }
+  const allExtensions = [...SUPPORTED_EXTENSIONS.html, ...SUPPORTED_EXTENSIONS.source];
+  if (!allExtensions.includes(ext)) {
+    result.valid = false;
+    result.errors.push(`Unsupported schema input ${ext || "(no extension)"}. Use JSON, HTML, or a supported source template.`);
+    return result;
+  }
+  const page = SUPPORTED_EXTENSIONS.html.includes(ext) ? parseHtml(absolutePath, content) : parseSourceFile(absolutePath, content);
+  const findings = [...checkSchemaJsonValidity(page), ...checkSchema(page)].filter((finding) => !finding.passed);
+  for (const finding of findings) {
+    const message = `${finding.checkId}: ${finding.message}`;
+    if (finding.severity === "critical") {
+      result.valid = false;
+      result.errors.push(message);
+    } else {
+      result.warnings.push(message);
     }
-    
-    .container {
-      max-width: 1200px;
-      margin: 0 auto;
-      padding: 2rem;
+  }
+  result.info.push(`${page.jsonLd.length} parseable JSON-LD schema object(s) found`);
+  return result;
+}
+function validateSchemaNode(node, label, result) {
+  if (!node || typeof node !== "object" || Array.isArray(node)) {
+    result.valid = false;
+    result.errors.push(`${label} must be a JSON object`);
+    return;
+  }
+  const schema = node;
+  if (!schema["@context"]) result.warnings.push(`${label} is missing @context`);
+  if (!schema["@type"] && !Array.isArray(schema["@graph"])) result.warnings.push(`${label} is missing @type`);
+  if (Array.isArray(schema["@graph"])) {
+    schema["@graph"].forEach((entry, index) => validateSchemaNode(entry, `${label} @graph item ${index + 1}`, result));
+  }
+}
+async function validateRobotsTxt(filePath) {
+  const result = {
+    valid: true,
+    errors: [],
+    warnings: [],
+    info: []
+  };
+  const absolutePath = path6.resolve(filePath);
+  if (!fs6.existsSync(absolutePath)) {
+    result.valid = false;
+    result.errors.push(`File not found: ${absolutePath}`);
+    return result;
+  }
+  const content = fs6.readFileSync(absolutePath, "utf-8");
+  const lines = content.split("\n");
+  let hasUserAgent = false;
+  let hasSitemap = false;
+  let currentUserAgent = "";
+  let lineNum = 0;
+  for (const rawLine of lines) {
+    lineNum++;
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) {
+      continue;
+    }
+    const colonIndex = line.indexOf(":");
+    if (colonIndex === -1) {
+      result.warnings.push(`Line ${lineNum}: Invalid format (missing colon): "${line}"`);
+      continue;
+    }
+    const directive = line.substring(0, colonIndex).trim().toLowerCase();
+    const value = line.substring(colonIndex + 1).trim();
+    switch (directive) {
+      case "user-agent":
+        hasUserAgent = true;
+        currentUserAgent = value;
+        if (!value) {
+          result.errors.push(`Line ${lineNum}: User-agent directive has no value`);
+          result.valid = false;
+        }
+        break;
+      case "disallow":
+        if (!currentUserAgent) {
+          result.errors.push(`Line ${lineNum}: Disallow before User-agent directive`);
+          result.valid = false;
+        }
+        if (value && !value.startsWith("/") && value !== "*") {
+          result.warnings.push(`Line ${lineNum}: Disallow path should start with /`);
+        }
+        break;
+      case "allow":
+        if (!currentUserAgent) {
+          result.errors.push(`Line ${lineNum}: Allow before User-agent directive`);
+          result.valid = false;
+        }
+        if (value && !value.startsWith("/") && value !== "*") {
+          result.warnings.push(`Line ${lineNum}: Allow path should start with /`);
+        }
+        break;
+      case "sitemap":
+        hasSitemap = true;
+        if (!value.startsWith("http://") && !value.startsWith("https://")) {
+          result.errors.push(`Line ${lineNum}: Sitemap URL must be absolute (start with http:// or https://)`);
+          result.valid = false;
+        }
+        break;
+      case "crawl-delay": {
+        const delay = parseFloat(value);
+        if (isNaN(delay) || delay < 0) {
+          result.warnings.push(`Line ${lineNum}: Invalid crawl-delay value: "${value}"`);
+        } else if (delay > 10) {
+          result.warnings.push(
+            `Line ${lineNum}: Crawl-delay of ${delay}s is very high - may slow indexing`
+          );
+        }
+        break;
+      }
+      case "host":
+        result.info.push(`Line ${lineNum}: Host directive (Yandex-specific)`);
+        break;
+      case "clean-param":
+        result.info.push(`Line ${lineNum}: Clean-param directive (Yandex-specific)`);
+        break;
+      default:
+        result.warnings.push(`Line ${lineNum}: Unknown directive: "${directive}"`);
+    }
+  }
+  if (!hasUserAgent) {
+    result.errors.push("Missing User-agent directive (required)");
+    result.valid = false;
+  }
+  if (!hasSitemap) {
+    result.warnings.push("No Sitemap directive found - recommended to include sitemap URL");
+  }
+  if (content.includes("Disallow: /") && !content.includes("Allow:")) {
+    const disallowAll = lines.some((l) => {
+      const trimmed = l.trim().toLowerCase();
+      return trimmed === "disallow: /" || trimmed === "disallow:/";
+    });
+    if (disallowAll) {
+      result.warnings.push('Found "Disallow: /" which blocks all crawling - ensure this is intentional');
+    }
+  }
+  result.info.push(`Total lines: ${lines.length}`);
+  result.info.push(`User-agents defined: ${lines.filter((l) => l.trim().toLowerCase().startsWith("user-agent")).length}`);
+  return result;
+}
+async function validateSitemap(filePath) {
+  const result = {
+    valid: true,
+    errors: [],
+    warnings: [],
+    info: []
+  };
+  const absolutePath = path6.resolve(filePath);
+  if (!fs6.existsSync(absolutePath)) {
+    result.valid = false;
+    result.errors.push(`File not found: ${absolutePath}`);
+    return result;
+  }
+  const content = fs6.readFileSync(absolutePath, "utf-8");
+  if (!content.trim().startsWith("<?xml")) {
+    result.warnings.push('Missing XML declaration (<?xml version="1.0" encoding="UTF-8"?>)');
+  }
+  const parser = new XMLParser({
+    ignoreAttributes: false,
+    attributeNamePrefix: "@_"
+  });
+  let parsed;
+  try {
+    parsed = parser.parse(content);
+  } catch (error) {
+    result.valid = false;
+    result.errors.push(`Invalid XML: ${error}`);
+    return result;
+  }
+  const isSitemapIndex = !!parsed.sitemapindex;
+  const isUrlset = !!parsed.urlset;
+  if (!isSitemapIndex && !isUrlset) {
+    result.valid = false;
+    result.errors.push("Missing root element: expected <urlset> or <sitemapindex>");
+    return result;
+  }
+  if (isSitemapIndex) {
+    const sitemaps = parsed.sitemapindex.sitemap;
+    const sitemapArray = Array.isArray(sitemaps) ? sitemaps : sitemaps ? [sitemaps] : [];
+    result.info.push(`Sitemap index with ${sitemapArray.length} child sitemap(s)`);
+    for (let i = 0; i < sitemapArray.length; i++) {
+      const sitemap = sitemapArray[i];
+      if (!sitemap.loc) {
+        result.errors.push(`Sitemap ${i + 1}: Missing <loc> element (required)`);
+        result.valid = false;
+      } else if (!sitemap.loc.startsWith("http")) {
+        result.errors.push(`Sitemap ${i + 1}: <loc> must be absolute URL`);
+        result.valid = false;
+      }
+    }
+  } else {
+    const urls = parsed.urlset.url;
+    const urlArray = Array.isArray(urls) ? urls : urls ? [urls] : [];
+    result.info.push(`Sitemap with ${urlArray.length} URL(s)`);
+    if (urlArray.length === 0) {
+      result.warnings.push("Sitemap is empty (no URLs)");
+    }
+    if (urlArray.length > 5e4) {
+      result.errors.push(`Sitemap has ${urlArray.length} URLs - maximum allowed is 50,000`);
+      result.valid = false;
+    }
+    const fileSize = Buffer.byteLength(content, "utf-8");
+    const fileSizeMB = fileSize / (1024 * 1024);
+    if (fileSizeMB > 50) {
+      result.errors.push(`Sitemap is ${fileSizeMB.toFixed(1)}MB - maximum allowed is 50MB`);
+      result.valid = false;
+    }
+    const priorities = /* @__PURE__ */ new Set();
+    const changefreqs = /* @__PURE__ */ new Set();
+    let urlsWithoutLoc = 0;
+    let urlsWithRelativeLoc = 0;
+    let urlsWithLastmod = 0;
+    let urlsWithPriority = 0;
+    let urlsWithChangefreq = 0;
+    const validChangefreqs = ["always", "hourly", "daily", "weekly", "monthly", "yearly", "never"];
+    const seenUrls = /* @__PURE__ */ new Set();
+    const duplicateUrls = [];
+    for (let i = 0; i < Math.min(urlArray.length, 1e3); i++) {
+      const url = urlArray[i];
+      if (!url.loc) {
+        urlsWithoutLoc++;
+      } else {
+        if (seenUrls.has(url.loc)) {
+          duplicateUrls.push(url.loc);
+        }
+        seenUrls.add(url.loc);
+        if (!url.loc.startsWith("http")) {
+          urlsWithRelativeLoc++;
+        }
+      }
+      if (url.lastmod) {
+        urlsWithLastmod++;
+        const datePattern = /^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}([+-]\d{2}:\d{2}|Z)?)?$/;
+        if (!datePattern.test(url.lastmod)) {
+          result.warnings.push(`URL ${i + 1}: Invalid lastmod date format: "${url.lastmod}"`);
+        }
+      }
+      if (url.priority !== void 0) {
+        urlsWithPriority++;
+        priorities.add(String(url.priority));
+        const priority = parseFloat(url.priority);
+        if (isNaN(priority) || priority < 0 || priority > 1) {
+          result.warnings.push(`URL ${i + 1}: Invalid priority value: "${url.priority}" (must be 0.0-1.0)`);
+        }
+      }
+      if (url.changefreq) {
+        urlsWithChangefreq++;
+        changefreqs.add(url.changefreq);
+        if (!validChangefreqs.includes(url.changefreq.toLowerCase())) {
+          result.warnings.push(`URL ${i + 1}: Invalid changefreq: "${url.changefreq}"`);
+        }
+      }
+    }
+    if (urlsWithoutLoc > 0) {
+      result.errors.push(`${urlsWithoutLoc} URL(s) missing required <loc> element`);
+      result.valid = false;
+    }
+    if (urlsWithRelativeLoc > 0) {
+      result.errors.push(`${urlsWithRelativeLoc} URL(s) have relative URLs - must be absolute`);
+      result.valid = false;
+    }
+    if (duplicateUrls.length > 0) {
+      result.warnings.push(`${duplicateUrls.length} duplicate URL(s) found`);
+      if (duplicateUrls.length <= 5) {
+        duplicateUrls.forEach((url) => result.warnings.push(`  Duplicate: ${url}`));
+      }
+    }
+    if (urlsWithLastmod === 0) {
+      result.info.push("No lastmod dates - consider adding for better crawling");
+    } else {
+      result.info.push(`${urlsWithLastmod} URL(s) have lastmod dates`);
+    }
+    if (priorities.size === 1) {
+      result.info.push(`All URLs have same priority (${[...priorities][0]}) - consider varying for important pages`);
+    }
+    if (urlsWithPriority > 0 || urlsWithChangefreq > 0) {
+      result.info.push("Note: Google largely ignores priority and changefreq - focus on lastmod instead");
+    }
+  }
+  return result;
+}
+
+// src/version.ts
+var VERSION = "0.1.3";
+
+// src/mcp/server.ts
+function safePath(root, requested) {
+  const resolved = path7.resolve(root, requested);
+  if (resolved !== root && !resolved.startsWith(`${root}${path7.sep}`)) {
+    throw new Error(`Path must stay inside MCP root: ${root}`);
+  }
+  return resolved;
+}
+var text = (value) => ({ content: [{ type: "text", text: typeof value === "string" ? value : JSON.stringify(value, null, 2) }] });
+function createMcpServer(rootPath = process.cwd(), cliEntry = process.argv[1]) {
+  const root = path7.resolve(rootPath);
+  const server = new McpServer({ name: "rankture", version: VERSION });
+  server.registerTool("check_path", {
+    description: "Run Rankture SEO checks against a file or directory inside the configured project root.",
+    inputSchema: {
+      path: z.string().default("."),
+      config: z.string().optional(),
+      serve: z.boolean().default(false)
+    },
+    annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false }
+  }, async (input) => {
+    const target = safePath(root, input.path);
+    const args = [cliEntry, "check", target, "--format", "json"];
+    if (input.config) args.push("--config", safePath(root, input.config));
+    if (input.serve) args.push("--serve");
+    const result = spawnSync(process.execPath, args, { cwd: root, encoding: "utf8", env: { ...process.env, NO_COLOR: "1" } });
+    if (result.error) throw result.error;
+    if (!result.stdout.trim()) throw new Error(result.stderr.trim() || `Rankture exited ${result.status}`);
+    return text(JSON.parse(result.stdout));
+  });
+  server.registerTool("validate_schema", {
+    description: "Validate a local JSON-LD file or HTML document inside the configured project root.",
+    inputSchema: { file: z.string() },
+    annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false }
+  }, async ({ file }) => text(await validateSchema(safePath(root, file))));
+  server.registerTool("list_rules", {
+    description: "List Rankture rule groups with their default severity and purpose.",
+    annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false }
+  }, async () => text(checks.map(({ id, name, description, severity }) => ({ id, name, description, severity }))));
+  server.registerTool("explain_rule", {
+    description: "Explain a Rankture rule group by its stable ID.",
+    inputSchema: { ruleId: z.string() },
+    annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false }
+  }, async ({ ruleId }) => {
+    const rule = checks.find((candidate) => candidate.id === ruleId || ruleId.startsWith(`${candidate.id}-`));
+    if (!rule) throw new Error(`Unknown Rankture rule: ${ruleId}`);
+    return text({ id: rule.id, name: rule.name, severity: rule.severity, description: rule.description });
+  });
+  return server;
+}
+async function startMcpServer(rootPath) {
+  await createMcpServer(rootPath).connect(new StdioServerTransport());
+}
+
+// src/integrations.ts
+import { fileURLToPath } from "url";
+import * as path10 from "path";
+
+// src/commands/check.ts
+import * as fs7 from "fs";
+import * as path9 from "path";
+import fg from "fast-glob";
+import ora from "ora";
+
+// src/reporters/terminal.ts
+import chalk2 from "chalk";
+function formatTerminal(report, opts = {}) {
+  const lines = [];
+  if (!opts.quiet) {
+    lines.push("");
+    lines.push(chalk2.bold.cyan("  Rankture SEO Check"));
+    lines.push(chalk2.gray("  " + "\u2500".repeat(40)));
+    lines.push("");
+    lines.push(chalk2.gray(`  Checking ${report.path} (${report.summary.totalFiles} files)...`));
+    lines.push("");
+  }
+  const critical = report.results.filter((r) => !r.passed && r.severity === "critical");
+  const warnings = report.results.filter((r) => !r.passed && r.severity === "warning");
+  const info = opts.quiet ? [] : report.results.filter((r) => !r.passed && r.severity === "info");
+  if (critical.length > 0) {
+    for (const result of critical) {
+      lines.push(formatResult(result));
+    }
+  }
+  if (warnings.length > 0) {
+    for (const result of warnings) {
+      lines.push(formatResult(result));
+    }
+  }
+  if (info.length > 0) {
+    for (const result of info) {
+      lines.push(formatResult(result));
+    }
+  }
+  if (!opts.quiet) {
+    lines.push("");
+    lines.push(chalk2.gray("  " + "\u2500".repeat(40)));
+  }
+  const summaryParts = [];
+  if (report.summary.critical > 0) {
+    summaryParts.push(chalk2.red.bold(`${report.summary.critical} critical`));
+  }
+  if (report.summary.warning > 0) {
+    summaryParts.push(chalk2.yellow.bold(`${report.summary.warning} warnings`));
+  }
+  if (report.summary.info > 0) {
+    summaryParts.push(chalk2.blue(`${report.summary.info} info`));
+  }
+  summaryParts.push(chalk2.green(`${report.summary.passed} passed`));
+  lines.push(`  Results: ${summaryParts.join(", ")}`);
+  if (report.baseline) {
+    lines.push(chalk2.gray(`  ${report.baseline.suppressed} known issue(s) suppressed by baseline ${report.baseline.file}`));
+  }
+  lines.push("");
+  if (report.summary.critical > 0) {
+    lines.push(chalk2.red.bold("  \u2717 Check failed (critical issues found)"));
+  } else if (report.summary.warning > 0) {
+    lines.push(chalk2.yellow("  \u26A0 Check completed with warnings"));
+  } else {
+    lines.push(chalk2.green.bold("  \u2713 All checks passed!"));
+  }
+  lines.push("");
+  const output = lines.join("\n");
+  const ansiPattern = new RegExp("\\u001B\\[[0-?]*[ -/]*[@-~]", "g");
+  return opts.noColor ? output.replace(ansiPattern, "") : output;
+}
+function formatResult(result) {
+  const lines = [];
+  let icon;
+  let color;
+  switch (result.severity) {
+    case "critical":
+      icon = "\u2717";
+      color = chalk2.red;
+      break;
+    case "warning":
+      icon = "\u26A0";
+      color = chalk2.yellow;
+      break;
+    case "info":
+    default:
+      icon = "\u2139";
+      color = chalk2.blue;
+      break;
+  }
+  lines.push(
+    `  ${color(icon)} ${color.bold(result.severity.toUpperCase().padEnd(8))} ${chalk2.gray(result.checkId)}`
+  );
+  if (result.file) {
+    lines.push(`    ${chalk2.cyan(result.file)} - ${result.message}`);
+  } else {
+    lines.push(`    ${result.message}`);
+  }
+  if (result.details && result.details.length > 0) {
+    const maxDetails = 5;
+    const showDetails = result.details.slice(0, maxDetails);
+    for (const detail of showDetails) {
+      lines.push(chalk2.gray(`      - ${detail}`));
+    }
+    if (result.details.length > maxDetails) {
+      lines.push(chalk2.gray(`      ... and ${result.details.length - maxDetails} more`));
+    }
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function printReport(report, opts = {}) {
+  console.log(formatTerminal(report, opts));
+}
+
+// src/reporters/json.ts
+function formatJson(report) {
+  return JSON.stringify(report, null, 2);
+}
+
+// src/reporters/html.ts
+function formatHtml(report) {
+  const { summary, results } = report;
+  const byFile = /* @__PURE__ */ new Map();
+  results.forEach((r) => {
+    const file = r.file || "Unknown";
+    if (!byFile.has(file)) {
+      byFile.set(file, []);
+    }
+    byFile.get(file).push(r);
+  });
+  const totalChecks = summary.passed + summary.critical + summary.warning + summary.info;
+  const score = totalChecks > 0 ? Math.round(summary.passed / totalChecks * 100) : 100;
+  const scoreColor = score >= 90 ? "#22c55e" : score >= 70 ? "#eab308" : score >= 50 ? "#f97316" : "#ef4444";
+  const html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>SEO Audit Report - ${new Date(report.timestamp).toLocaleDateString()}</title>
+  <style>
+    * {
+      margin: 0;
+      padding: 0;
+      box-sizing: border-box;
+    }
+    
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
+      background: #f8fafc;
+      color: #1e293b;
+      line-height: 1.6;
+    }
+    
+    .container {
+      max-width: 1200px;
+      margin: 0 auto;
+      padding: 2rem;
     }
     
     header {
@@ -2245,348 +3087,531 @@ function formatHtml(report) {
           <div class="stat">
             <div class="stat-value">${summary.totalFiles}</div>
             <div class="stat-label">Files</div>
-          </div>
-          <div class="stat">
-            <div class="stat-value">${totalChecks}</div>
-            <div class="stat-label">Checks</div>
-          </div>
-          <div class="stat">
-            <div class="stat-value">${summary.passed}</div>
-            <div class="stat-label">Passed</div>
-          </div>
-        </div>
-      </div>
-    </header>
-    
-    <div class="summary-cards">
-      <div class="card card-critical">
-        <h3>${summary.critical}</h3>
-        <p>Critical Issues</p>
-      </div>
-      <div class="card card-warning">
-        <h3>${summary.warning}</h3>
-        <p>Warnings</p>
-      </div>
-      <div class="card card-info">
-        <h3>${summary.info}</h3>
-        <p>Info</p>
-      </div>
-      <div class="card card-passed">
-        <h3>${summary.passed}</h3>
-        <p>Passed</p>
-      </div>
-    </div>
-    
-    ${results.length === 0 ? `
-    <div class="section">
-      <div class="no-issues">
-        <svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke="currentColor">
-          <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M9 12l2 2 4-4m6 2a9 9 0 11-18 0 9 9 0 0118 0z" />
-        </svg>
-        <h2>All Checks Passed!</h2>
-        <p>No SEO issues found. Great job!</p>
-      </div>
-    </div>
-    ` : `
-    <div class="section">
-      <h2>Issues Found</h2>
-      ${Array.from(byFile.entries()).map(([file, issues]) => `
-        <div class="file-group">
-          <div class="file-name">${escapeHtml(file)}</div>
-          ${issues.map((issue) => `
-            <div class="issue">
-              <span class="issue-severity severity-${issue.severity}">${issue.severity}</span>
-              <div class="issue-content">
-                <div class="issue-name">${escapeHtml(issue.name)}</div>
-                <div class="issue-message">${escapeHtml(issue.message)}</div>
-                ${issue.fix ? `
-                  <div class="issue-fix">
-                    <strong>How to fix:</strong>
-                    ${escapeHtml(issue.fix)}
-                  </div>
-                ` : ""}
-                ${issue.details && issue.details.length > 0 ? `
-                  <div class="issue-details">
-                    <strong>Affected:</strong>
-                    <ul>
-                      ${issue.details.slice(0, 5).map((d) => `<li>${escapeHtml(d)}</li>`).join("")}
-                      ${issue.details.length > 5 ? `<li>...and ${issue.details.length - 5} more</li>` : ""}
-                    </ul>
-                  </div>
-                ` : ""}
-              </div>
-            </div>
-          `).join("")}
-        </div>
-      `).join("")}
-    </div>
-    `}
-    
-    <footer>
-      <p>Generated by <a href="https://rankture.com">Rankture CLI</a> v${report.version}</p>
-      <p>For full audit with Core Web Vitals and AI suggestions, visit <a href="https://rankture.com/free-seo-audit/">rankture.com</a></p>
-    </footer>
-  </div>
-</body>
-</html>`;
-  return html;
-}
-function escapeHtml(text) {
-  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
-}
-
-// src/commands/validate.ts
-import * as fs3 from "fs";
-import * as path3 from "path";
-import chalk2 from "chalk";
-import { XMLParser } from "fast-xml-parser";
-async function validateRobotsTxt(filePath) {
-  const result = {
-    valid: true,
-    errors: [],
-    warnings: [],
-    info: []
-  };
-  const absolutePath = path3.resolve(filePath);
-  if (!fs3.existsSync(absolutePath)) {
-    result.valid = false;
-    result.errors.push(`File not found: ${absolutePath}`);
-    return result;
-  }
-  const content = fs3.readFileSync(absolutePath, "utf-8");
-  const lines = content.split("\n");
-  let hasUserAgent = false;
-  let hasSitemap = false;
-  let currentUserAgent = "";
-  let lineNum = 0;
-  for (const rawLine of lines) {
-    lineNum++;
-    const line = rawLine.trim();
-    if (!line || line.startsWith("#")) {
-      continue;
-    }
-    const colonIndex = line.indexOf(":");
-    if (colonIndex === -1) {
-      result.warnings.push(`Line ${lineNum}: Invalid format (missing colon): "${line}"`);
-      continue;
-    }
-    const directive = line.substring(0, colonIndex).trim().toLowerCase();
-    const value = line.substring(colonIndex + 1).trim();
-    switch (directive) {
-      case "user-agent":
-        hasUserAgent = true;
-        currentUserAgent = value;
-        if (!value) {
-          result.errors.push(`Line ${lineNum}: User-agent directive has no value`);
-          result.valid = false;
-        }
-        break;
-      case "disallow":
-        if (!currentUserAgent) {
-          result.errors.push(`Line ${lineNum}: Disallow before User-agent directive`);
-          result.valid = false;
-        }
-        if (value && !value.startsWith("/") && value !== "*") {
-          result.warnings.push(`Line ${lineNum}: Disallow path should start with /`);
-        }
-        break;
-      case "allow":
-        if (!currentUserAgent) {
-          result.errors.push(`Line ${lineNum}: Allow before User-agent directive`);
-          result.valid = false;
-        }
-        if (value && !value.startsWith("/") && value !== "*") {
-          result.warnings.push(`Line ${lineNum}: Allow path should start with /`);
-        }
-        break;
-      case "sitemap":
-        hasSitemap = true;
-        if (!value.startsWith("http://") && !value.startsWith("https://")) {
-          result.errors.push(`Line ${lineNum}: Sitemap URL must be absolute (start with http:// or https://)`);
-          result.valid = false;
-        }
-        break;
-      case "crawl-delay": {
-        const delay = parseFloat(value);
-        if (isNaN(delay) || delay < 0) {
-          result.warnings.push(`Line ${lineNum}: Invalid crawl-delay value: "${value}"`);
-        } else if (delay > 10) {
-          result.warnings.push(
-            `Line ${lineNum}: Crawl-delay of ${delay}s is very high - may slow indexing`
-          );
-        }
-        break;
-      }
-      case "host":
-        result.info.push(`Line ${lineNum}: Host directive (Yandex-specific)`);
-        break;
-      case "clean-param":
-        result.info.push(`Line ${lineNum}: Clean-param directive (Yandex-specific)`);
-        break;
-      default:
-        result.warnings.push(`Line ${lineNum}: Unknown directive: "${directive}"`);
-    }
-  }
-  if (!hasUserAgent) {
-    result.errors.push("Missing User-agent directive (required)");
-    result.valid = false;
-  }
-  if (!hasSitemap) {
-    result.warnings.push("No Sitemap directive found - recommended to include sitemap URL");
-  }
-  if (content.includes("Disallow: /") && !content.includes("Allow:")) {
-    const disallowAll = lines.some((l) => {
-      const trimmed = l.trim().toLowerCase();
-      return trimmed === "disallow: /" || trimmed === "disallow:/";
-    });
-    if (disallowAll) {
-      result.warnings.push('Found "Disallow: /" which blocks all crawling - ensure this is intentional');
-    }
-  }
-  result.info.push(`Total lines: ${lines.length}`);
-  result.info.push(`User-agents defined: ${lines.filter((l) => l.trim().toLowerCase().startsWith("user-agent")).length}`);
-  return result;
+          </div>
+          <div class="stat">
+            <div class="stat-value">${totalChecks}</div>
+            <div class="stat-label">Checks</div>
+          </div>
+          <div class="stat">
+            <div class="stat-value">${summary.passed}</div>
+            <div class="stat-label">Passed</div>
+          </div>
+        </div>
+      </div>
+    </header>
+    
+    <div class="summary-cards">
+      <div class="card card-critical">
+        <h3>${summary.critical}</h3>
+        <p>Critical Issues</p>
+      </div>
+      <div class="card card-warning">
+        <h3>${summary.warning}</h3>
+        <p>Warnings</p>
+      </div>
+      <div class="card card-info">
+        <h3>${summary.info}</h3>
+        <p>Info</p>
+      </div>
+      <div class="card card-passed">
+        <h3>${summary.passed}</h3>
+        <p>Passed</p>
+      </div>
+    </div>
+    
+    ${results.length === 0 ? `
+    <div class="section">
+      <div class="no-issues">
+        <svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+          <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M9 12l2 2 4-4m6 2a9 9 0 11-18 0 9 9 0 0118 0z" />
+        </svg>
+        <h2>All Checks Passed!</h2>
+        <p>No SEO issues found. Great job!</p>
+      </div>
+    </div>
+    ` : `
+    <div class="section">
+      <h2>Issues Found</h2>
+      ${Array.from(byFile.entries()).map(([file, issues]) => `
+        <div class="file-group">
+          <div class="file-name">${escapeHtml(file)}</div>
+          ${issues.map((issue) => `
+            <div class="issue">
+              <span class="issue-severity severity-${issue.severity}">${issue.severity}</span>
+              <div class="issue-content">
+                <div class="issue-name">${escapeHtml(issue.name)}</div>
+                <div class="issue-message">${escapeHtml(issue.message)}</div>
+                ${issue.fix ? `
+                  <div class="issue-fix">
+                    <strong>How to fix:</strong>
+                    ${escapeHtml(issue.fix)}
+                  </div>
+                ` : ""}
+                ${issue.details && issue.details.length > 0 ? `
+                  <div class="issue-details">
+                    <strong>Affected:</strong>
+                    <ul>
+                      ${issue.details.slice(0, 5).map((d) => `<li>${escapeHtml(d)}</li>`).join("")}
+                      ${issue.details.length > 5 ? `<li>...and ${issue.details.length - 5} more</li>` : ""}
+                    </ul>
+                  </div>
+                ` : ""}
+              </div>
+            </div>
+          `).join("")}
+        </div>
+      `).join("")}
+    </div>
+    `}
+    
+    <footer>
+      <p>Generated by <a href="https://rankture.com">Rankture CLI</a> v${report.version}</p>
+      <p>For full audit with Core Web Vitals and AI suggestions, visit <a href="https://rankture.com/free-seo-audit/">rankture.com</a></p>
+    </footer>
+  </div>
+</body>
+</html>`;
+  return html;
 }
-async function validateSitemap(filePath) {
-  const result = {
-    valid: true,
-    errors: [],
-    warnings: [],
-    info: []
-  };
-  const absolutePath = path3.resolve(filePath);
-  if (!fs3.existsSync(absolutePath)) {
-    result.valid = false;
-    result.errors.push(`File not found: ${absolutePath}`);
-    return result;
-  }
-  const content = fs3.readFileSync(absolutePath, "utf-8");
-  if (!content.trim().startsWith("<?xml")) {
-    result.warnings.push('Missing XML declaration (<?xml version="1.0" encoding="UTF-8"?>)');
+function escapeHtml(text2) {
+  return text2.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+}
+
+// src/reporters/markdown.ts
+function formatMarkdown(report) {
+  const lines = [
+    "# Rankture SEO Check",
+    "",
+    `- Files: ${report.summary.totalFiles}`,
+    `- Score: ${report.summary.score ?? 100}`,
+    `- Critical: ${report.summary.critical}`,
+    `- Warnings: ${report.summary.warning}`,
+    `- Info: ${report.summary.info}`
+  ];
+  if (report.baseline) lines.push(`- New issues: ${report.baseline.fresh}`);
+  lines.push("", "## Actionable findings", "");
+  if (report.results.length === 0) return [...lines, "No issues found.", ""].join("\n");
+  for (const finding of report.results) {
+    const location = `${finding.file ?? report.path}${finding.line ? `:${finding.line}${finding.column ? `:${finding.column}` : ""}` : ""}`;
+    lines.push(`- **${finding.severity.toUpperCase()} ${finding.checkId}** \u2014 ${location}`);
+    lines.push(`  - ${finding.message}`);
+    if (finding.fix) lines.push(`  - Fix: ${finding.fix.replace(/\s+/g, " ").trim()}`);
   }
-  const parser = new XMLParser({
-    ignoreAttributes: false,
-    attributeNamePrefix: "@_"
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/reporters/sarif.ts
+import * as path8 from "path";
+import { pathToFileURL as pathToFileURL2 } from "url";
+var SARIF_SCHEMA = "https://raw.githubusercontent.com/oasis-tcs/sarif-spec/master/Schemata/sarif-schema-2.1.0.json";
+var LEVEL_BY_SEVERITY = {
+  critical: "error",
+  warning: "warning",
+  info: "note"
+};
+function formatSarif(report, basePath) {
+  const failures = report.results.filter((r) => !r.passed);
+  const absoluteBase = path8.resolve(basePath);
+  const rules = [...new Map(failures.map((r) => [r.checkId, r])).values()].map((r) => ({
+    id: r.checkId,
+    name: r.name,
+    shortDescription: { text: r.name },
+    helpUri: `https://rankture.com/docs/cli#${r.checkId}`,
+    defaultConfiguration: { level: LEVEL_BY_SEVERITY[r.severity] }
+  }));
+  const results = failures.map((r) => {
+    const uri = r.file ? path8.relative(absoluteBase, path8.resolve(absoluteBase, r.file)).split(path8.sep).join("/") : void 0;
+    return {
+      ruleId: r.checkId,
+      level: LEVEL_BY_SEVERITY[r.severity],
+      message: { text: r.fix ? `${r.message} Fix: ${r.fix}` : r.message },
+      ...uri ? {
+        locations: [
+          {
+            physicalLocation: {
+              artifactLocation: { uri, uriBaseId: "ROOTPATH" },
+              ...r.line ? { region: { startLine: r.line, ...r.column ? { startColumn: r.column } : {} } } : {}
+            }
+          }
+        ]
+      } : {}
+    };
   });
-  let parsed;
+  const sarif = {
+    $schema: SARIF_SCHEMA,
+    version: "2.1.0",
+    runs: [
+      {
+        tool: {
+          driver: {
+            name: "rankture",
+            informationUri: "https://rankture.com",
+            version: report.version,
+            rules
+          }
+        },
+        originalUriBaseIds: {
+          ROOTPATH: { uri: ensureTrailingSlash(pathToFileURL2(absoluteBase).href) }
+        },
+        results
+      }
+    ]
+  };
+  return JSON.stringify(sarif, null, 2);
+}
+function ensureTrailingSlash(value) {
+  return value.endsWith("/") ? value : `${value}/`;
+}
+
+// src/commands/check.ts
+import { execSync as execSync2, spawn } from "child_process";
+function getGitChangedFiles(basePath, stagedOnly) {
   try {
-    parsed = parser.parse(content);
-  } catch (error) {
-    result.valid = false;
-    result.errors.push(`Invalid XML: ${error}`);
-    return result;
-  }
-  const isSitemapIndex = !!parsed.sitemapindex;
-  const isUrlset = !!parsed.urlset;
-  if (!isSitemapIndex && !isUrlset) {
-    result.valid = false;
-    result.errors.push("Missing root element: expected <urlset> or <sitemapindex>");
-    return result;
+    const cwd = path9.resolve(basePath);
+    const stagedOutput = execSync2("git diff --cached --name-only --diff-filter=ACMR", {
+      cwd,
+      encoding: "utf-8"
+    }).trim();
+    const stagedFiles = stagedOutput ? stagedOutput.split("\n") : [];
+    if (stagedOnly) {
+      return stagedFiles.map((f) => path9.join(cwd, f));
+    }
+    const unstagedOutput = execSync2("git diff --name-only --diff-filter=ACMR", {
+      cwd,
+      encoding: "utf-8"
+    }).trim();
+    const unstagedFiles = unstagedOutput ? unstagedOutput.split("\n") : [];
+    const allFiles = [.../* @__PURE__ */ new Set([...stagedFiles, ...unstagedFiles])];
+    return allFiles.map((f) => path9.join(cwd, f));
+  } catch {
+    return [];
   }
-  if (isSitemapIndex) {
-    const sitemaps = parsed.sitemapindex.sitemap;
-    const sitemapArray = Array.isArray(sitemaps) ? sitemaps : sitemaps ? [sitemaps] : [];
-    result.info.push(`Sitemap index with ${sitemapArray.length} child sitemap(s)`);
-    for (let i = 0; i < sitemapArray.length; i++) {
-      const sitemap = sitemapArray[i];
-      if (!sitemap.loc) {
-        result.errors.push(`Sitemap ${i + 1}: Missing <loc> element (required)`);
-        result.valid = false;
-      } else if (!sitemap.loc.startsWith("http")) {
-        result.errors.push(`Sitemap ${i + 1}: <loc> must be absolute URL`);
-        result.valid = false;
+}
+async function checkCommand(options) {
+  const spinner = ora({
+    text: "Scanning files...",
+    isEnabled: Boolean(process.stdout.isTTY && !options.quiet)
+  }).start();
+  try {
+    const basePath = path9.resolve(options.path);
+    const formats = ["terminal", "json", "html", "sarif", "markdown"];
+    const failLevels = ["none", "critical", "warning", "any", "new"];
+    if (!formats.includes(options.format)) {
+      spinner.fail(`Invalid format: ${options.format}. Use ${formats.join(", ")}`);
+      return 1;
+    }
+    if (!failLevels.includes(options.failOn)) {
+      spinner.fail(`Invalid fail-on level: ${options.failOn}. Use ${failLevels.join(", ")}`);
+      return 1;
+    }
+    for (const [name, value, min, max] of [
+      ["max-warnings", options.maxWarnings, 0, Number.MAX_SAFE_INTEGER],
+      ["max-critical", options.maxCritical, 0, Number.MAX_SAFE_INTEGER],
+      ["min-score", options.minScore, 0, 100],
+      ["serve-port", options.servePort, 0, 65535]
+    ]) {
+      if (value !== void 0 && (!Number.isFinite(value) || value < min || value > max)) {
+        spinner.fail(`--${name} must be between ${min} and ${max}`);
+        return 1;
       }
     }
-  } else {
-    const urls = parsed.urlset.url;
-    const urlArray = Array.isArray(urls) ? urls : urls ? [urls] : [];
-    result.info.push(`Sitemap with ${urlArray.length} URL(s)`);
-    if (urlArray.length === 0) {
-      result.warnings.push("Sitemap is empty (no URLs)");
-    }
-    if (urlArray.length > 5e4) {
-      result.errors.push(`Sitemap has ${urlArray.length} URLs - maximum allowed is 50,000`);
-      result.valid = false;
-    }
-    const fileSize = Buffer.byteLength(content, "utf-8");
-    const fileSizeMB = fileSize / (1024 * 1024);
-    if (fileSizeMB > 50) {
-      result.errors.push(`Sitemap is ${fileSizeMB.toFixed(1)}MB - maximum allowed is 50MB`);
-      result.valid = false;
+    if ((options.failOn === "new" || options.updateBaseline) && !options.baseline) {
+      spinner.fail(`${options.failOn === "new" ? "--fail-on new" : "--update-baseline"} requires --baseline <file>`);
+      return 1;
+    }
+    if (!fs7.existsSync(basePath)) {
+      spinner.fail(`Path not found: ${basePath}`);
+      return 1;
+    }
+    const stats = fs7.statSync(basePath);
+    const config = await loadConfig(basePath, options.config);
+    const availableChecks = getAvailableChecks();
+    const unknownChecks = Object.keys(config.checks ?? {}).filter((id) => !availableChecks.includes(id));
+    if (unknownChecks.length > 0) {
+      spinner.fail(`Unknown check ID${unknownChecks.length > 1 ? "s" : ""}: ${unknownChecks.join(", ")}`);
+      console.error(`Available checks: ${availableChecks.join(", ")}`);
+      return 1;
+    }
+    const enabledChecks = getEnabledChecks(config, availableChecks);
+    const effectiveIgnore = [.../* @__PURE__ */ new Set([...config.ignore ?? [], ...options.ignore])];
+    let targetFiles;
+    const allExtensions = [...SUPPORTED_EXTENSIONS.html, ...SUPPORTED_EXTENSIONS.source];
+    if (options.changed || options.staged) {
+      spinner.text = options.staged ? "Getting staged files..." : "Getting changed files...";
+      const gitFiles = getGitChangedFiles(basePath, !!options.staged);
+      targetFiles = gitFiles.filter((f) => {
+        const ext = path9.extname(f).toLowerCase();
+        return allExtensions.includes(ext);
+      });
+      if (targetFiles.length === 0) {
+        spinner.succeed(options.staged ? "No staged files to check" : "No changed files to check");
+        return 0;
+      }
+      spinner.text = `Found ${targetFiles.length} ${options.staged ? "staged" : "changed"} file(s)`;
+    } else if (stats.isFile()) {
+      const ext = path9.extname(basePath).toLowerCase();
+      if (!allExtensions.includes(ext)) {
+        spinner.fail(`Unsupported file type: ${ext}. Supported: ${allExtensions.join(", ")}`);
+        return 1;
+      }
+      targetFiles = [basePath];
+    } else {
+      const ignorePatterns = [
+        "**/node_modules/**",
+        "**/.git/**",
+        "**/.astro/**",
+        "**/.next/**",
+        "**/.nuxt/**",
+        "**/.svelte-kit/**",
+        "**/dist/**/*.js",
+        "**/dist/**/*.css",
+        ...effectiveIgnore
+      ];
+      const extensionPattern = allExtensions.map((e) => e.slice(1)).join(",");
+      const globPattern = `**/*.{${extensionPattern}}`;
+      targetFiles = await fg(globPattern, {
+        cwd: basePath,
+        ignore: ignorePatterns,
+        absolute: true
+      });
+      if (targetFiles.length === 0) {
+        spinner.fail(`No supported files found in ${basePath}. Looking for: ${allExtensions.join(", ")}`);
+        return 1;
+      }
     }
-    const priorities = /* @__PURE__ */ new Set();
-    const changefreqs = /* @__PURE__ */ new Set();
-    let urlsWithoutLoc = 0;
-    let urlsWithRelativeLoc = 0;
-    let urlsWithLastmod = 0;
-    let urlsWithPriority = 0;
-    let urlsWithChangefreq = 0;
-    const validChangefreqs = ["always", "hourly", "daily", "weekly", "monthly", "yearly", "never"];
-    const seenUrls = /* @__PURE__ */ new Set();
-    const duplicateUrls = [];
-    for (let i = 0; i < Math.min(urlArray.length, 1e3); i++) {
-      const url = urlArray[i];
-      if (!url.loc) {
-        urlsWithoutLoc++;
+    targetFiles.sort((a, b) => a.localeCompare(b));
+    spinner.text = `Parsing ${targetFiles.length} file${targetFiles.length > 1 ? "s" : ""}...`;
+    const pages = [];
+    for (const filePath of targetFiles) {
+      const content = fs7.readFileSync(filePath, "utf-8");
+      const ext = path9.extname(filePath).toLowerCase();
+      let page;
+      if (SUPPORTED_EXTENSIONS.html.includes(ext)) {
+        page = parseHtml(filePath, content);
       } else {
-        if (seenUrls.has(url.loc)) {
-          duplicateUrls.push(url.loc);
-        }
-        seenUrls.add(url.loc);
-        if (!url.loc.startsWith("http")) {
-          urlsWithRelativeLoc++;
-        }
+        page = parseSourceFile(filePath, content);
       }
-      if (url.lastmod) {
-        urlsWithLastmod++;
-        const datePattern = /^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}([+-]\d{2}:\d{2}|Z)?)?$/;
-        if (!datePattern.test(url.lastmod)) {
-          result.warnings.push(`URL ${i + 1}: Invalid lastmod date format: "${url.lastmod}"`);
-        }
+      pages.push(page);
+    }
+    spinner.text = "Running checks...";
+    const effectiveBasePath = stats.isFile() ? path9.dirname(basePath) : basePath;
+    const useHttpLinks = Boolean(options.serve && enabledChecks.has("internal-links"));
+    const registryChecks = new Set(enabledChecks);
+    if (useHttpLinks) registryChecks.delete("internal-links");
+    const allResults = [];
+    for (const page of pages) {
+      const results = runChecks(page, pages, effectiveBasePath, registryChecks, config.thresholds);
+      for (const result of results) {
+        const override = config.rules?.[result.checkId] ?? Object.entries(config.rules ?? {}).find(([id]) => result.checkId.startsWith(`${id}-`))?.[1];
+        if (override) result.severity = override;
       }
-      if (url.priority !== void 0) {
-        urlsWithPriority++;
-        priorities.add(String(url.priority));
-        const priority = parseFloat(url.priority);
-        if (isNaN(priority) || priority < 0 || priority > 1) {
-          result.warnings.push(`URL ${i + 1}: Invalid priority value: "${url.priority}" (must be 0.0-1.0)`);
-        }
+      allResults.push(...results);
+    }
+    if (useHttpLinks) {
+      const htmlPages = pages.filter((page) => !page.isSourceFile);
+      if (htmlPages.length === 0) {
+        spinner.fail("--serve requires at least one built .html file");
+        return 1;
       }
-      if (url.changefreq) {
-        urlsWithChangefreq++;
-        changefreqs.add(url.changefreq);
-        if (!validChangefreqs.includes(url.changefreq.toLowerCase())) {
-          result.warnings.push(`URL ${i + 1}: Invalid changefreq: "${url.changefreq}"`);
+      spinner.text = "Validating links through a local HTTP server...";
+      const server = await startStaticServer(effectiveBasePath, options.servePort ?? 0);
+      try {
+        for (const page of htmlPages) {
+          const findings = await checkInternalLinksHttp(
+            page,
+            pageUrlForFile(page.filePath, effectiveBasePath, server.origin)
+          );
+          if (findings.length === 0) {
+            allResults.push({
+              checkId: "internal-links",
+              name: "Internal Links",
+              severity: "critical",
+              passed: true,
+              file: page.filePath,
+              message: "Internal Links: no issues found"
+            });
+          } else {
+            allResults.push(...findings.map((result) => locateFinding(page, result)));
+          }
         }
+      } finally {
+        await server.close();
       }
     }
-    if (urlsWithoutLoc > 0) {
-      result.errors.push(`${urlsWithoutLoc} URL(s) missing required <loc> element`);
-      result.valid = false;
-    }
-    if (urlsWithRelativeLoc > 0) {
-      result.errors.push(`${urlsWithRelativeLoc} URL(s) have relative URLs - must be absolute`);
-      result.valid = false;
-    }
-    if (duplicateUrls.length > 0) {
-      result.warnings.push(`${duplicateUrls.length} duplicate URL(s) found`);
-      if (duplicateUrls.length <= 5) {
-        duplicateUrls.forEach((url) => result.warnings.push(`  Duplicate: ${url}`));
+    const severityOrder = { critical: 0, warning: 1, info: 2 };
+    allResults.sort(
+      (a, b) => (a.file ?? "").localeCompare(b.file ?? "") || (a.line ?? Number.MAX_SAFE_INTEGER) - (b.line ?? Number.MAX_SAFE_INTEGER) || severityOrder[a.severity] - severityOrder[b.severity] || a.checkId.localeCompare(b.checkId) || a.message.localeCompare(b.message)
+    );
+    spinner.stop();
+    const failures = allResults.filter((result) => !result.passed);
+    let reportResults = failures;
+    let baselineMeta;
+    if (options.baseline && options.updateBaseline) {
+      saveBaseline(options.baseline, buildBaseline(failures, effectiveBasePath, (/* @__PURE__ */ new Date()).toISOString()));
+      baselineMeta = { file: options.baseline, suppressed: failures.length, fresh: 0 };
+      reportResults = [];
+    } else if (options.baseline) {
+      const comparison = applyBaseline(failures, loadBaseline(options.baseline), effectiveBasePath);
+      reportResults = comparison.fresh;
+      baselineMeta = { file: options.baseline, suppressed: comparison.suppressed, fresh: comparison.fresh.length };
+    }
+    const passedCount = allResults.filter((result) => result.passed).length;
+    const score = allResults.length > 0 ? Math.round(passedCount / allResults.length * 100) : 100;
+    const report = {
+      version: VERSION,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      path: options.path,
+      summary: {
+        totalFiles: pages.length,
+        passed: passedCount,
+        critical: reportResults.filter((r) => r.severity === "critical").length,
+        warning: reportResults.filter((r) => r.severity === "warning").length,
+        info: reportResults.filter((r) => r.severity === "info").length,
+        score
+      },
+      results: reportResults,
+      ci: collectCiMetadata(process.env, effectiveBasePath),
+      baseline: baselineMeta
+    };
+    const shouldSync = options.sync ?? config.sync ?? false;
+    if (shouldSync) {
+      const websiteId = options.websiteId || config.websiteId;
+      const remote = await syncCheckReport(reportForSync(report, effectiveBasePath), websiteId, {
+        apiKey: options.apiKey || config.apiKey,
+        apiUrl: options.apiUrl || config.apiUrl
+      });
+      report.sync = { runId: remote.runId, websiteId };
+      if (!options.quiet && options.format === "terminal") console.log(`Synced Rankture run ${remote.runId}`);
+    }
+    if (options.format === "json" || options.format === "sarif" || options.format === "markdown") {
+      const output = options.format === "json" ? formatJson(report) : options.format === "sarif" ? formatSarif(report, effectiveBasePath) : formatMarkdown(report);
+      if (options.output) {
+        fs7.writeFileSync(options.output, output);
+        if (!options.quiet) console.log(`Report written to ${options.output}`);
+      } else {
+        console.log(output);
       }
-    }
-    if (urlsWithLastmod === 0) {
-      result.info.push("No lastmod dates - consider adding for better crawling");
+    } else if (options.format === "html") {
+      const html = formatHtml(report);
+      let reportPath;
+      if (options.output) {
+        fs7.writeFileSync(options.output, html);
+        reportPath = path9.resolve(options.output);
+        console.log(`
+  \u2705 HTML report written to ${options.output}`);
+        console.log(`  Open in browser: file://${reportPath}
+`);
+      } else {
+        const outputFile = `seo-report-${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.html`;
+        fs7.writeFileSync(outputFile, html);
+        reportPath = path9.resolve(outputFile);
+        console.log(`
+  \u2705 HTML report written to ${outputFile}`);
+        console.log(`  Open in browser: file://${reportPath}
+`);
+      }
+      if (options.open) openGeneratedFile(reportPath);
     } else {
-      result.info.push(`${urlsWithLastmod} URL(s) have lastmod dates`);
+      printReport(report, { quiet: options.quiet, noColor: options.noColor });
+    }
+    if (options.annotations) printGitHubAnnotations(report.results, effectiveBasePath);
+    let exitCode = 0;
+    if (options.updateBaseline) return 0;
+    switch (options.failOn) {
+      case "critical":
+        if (report.summary.critical > 0) exitCode = 1;
+        break;
+      case "warning":
+        if (report.summary.critical > 0 || report.summary.warning > 0) exitCode = 1;
+        break;
+      case "any":
+        if (report.summary.critical > 0 || report.summary.warning > 0 || report.summary.info > 0) {
+          exitCode = 1;
+        }
+        break;
+      case "new":
+        if ((report.baseline?.fresh ?? 0) > 0) exitCode = 1;
+        break;
+      case "none":
+      default:
+        exitCode = 0;
     }
-    if (priorities.size === 1) {
-      result.info.push(`All URLs have same priority (${[...priorities][0]}) - consider varying for important pages`);
+    if (options.maxWarnings !== void 0 && report.summary.warning > options.maxWarnings) exitCode = 1;
+    if (options.maxCritical !== void 0 && report.summary.critical > options.maxCritical) exitCode = 1;
+    if (options.minScore !== void 0 && score < options.minScore) exitCode = 1;
+    return exitCode;
+  } catch (error) {
+    spinner.fail("Error running checks");
+    console.error(error);
+    return error instanceof Error && /Invalid Rankture config|Unknown check ID|Baseline file not found|Unrecognized baseline format/.test(error.message) ? 1 : 2;
+  }
+}
+function openGeneratedFile(filePath) {
+  const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
+  const args = process.platform === "win32" ? ["/c", "start", "", filePath] : [filePath];
+  spawn(command, args, { detached: true, stdio: "ignore" }).unref();
+}
+function reportForSync(report, basePath) {
+  return {
+    ...report,
+    results: report.results.map((result) => ({
+      ...result,
+      file: result.file ? path9.relative(basePath, result.file).split(path9.sep).join("/") : void 0
+    }))
+  };
+}
+function printGitHubAnnotations(results, basePath) {
+  const escape = (value) => value.replace(/%/g, "%25").replace(/\r/g, "%0D").replace(/\n/g, "%0A");
+  for (const result of results) {
+    const command = result.severity === "critical" ? "error" : result.severity === "warning" ? "warning" : "notice";
+    const file = result.file ? path9.relative(basePath, result.file).split(path9.sep).join("/") : "";
+    const properties = [file && `file=${escape(file)}`, result.line && `line=${result.line}`, result.column && `col=${result.column}`, `title=${escape(result.checkId)}`].filter(Boolean).join(",");
+    console.log(`::${command} ${properties}::${escape(result.message)}`);
+  }
+}
+
+// src/integrations.ts
+function commandOptions(target, options) {
+  return {
+    path: target,
+    config: options.config,
+    failOn: options.failOn ?? "critical",
+    format: options.format ?? "terminal",
+    serve: options.serve,
+    quiet: options.quiet,
+    ignore: []
+  };
+}
+async function runIntegration(target, options) {
+  const code = await (options.runner ?? checkCommand)(commandOptions(target, options));
+  if (code !== 0) throw new Error(`Rankture SEO checks failed with exit code ${code}`);
+}
+function ranktureAstro(options = {}) {
+  return {
+    name: "@rankture/cli/astro",
+    hooks: {
+      "astro:build:done": async ({ dir }) => {
+        await runIntegration(options.path ? path10.resolve(options.path) : fileURLToPath(dir), options);
+      }
     }
-    if (urlsWithPriority > 0 || urlsWithChangefreq > 0) {
-      result.info.push("Note: Google largely ignores priority and changefreq - focus on lastmod instead");
+  };
+}
+function ranktureVite(options = {}) {
+  let root = process.cwd();
+  let outDir = "dist";
+  return {
+    name: "@rankture/cli/vite",
+    apply: "build",
+    enforce: "post",
+    configResolved(config) {
+      root = config.root || root;
+      outDir = config.build?.outDir || outDir;
+    },
+    async closeBundle() {
+      await runIntegration(options.path ? path10.resolve(root, options.path) : path10.resolve(root, outDir), options);
     }
-  }
-  return result;
+  };
 }
 
 // src/index.ts
@@ -2613,6 +3638,8 @@ function checkPage(html, url = "file://local", basePath = ".") {
 }
 export {
   SUPPORTED_EXTENSIONS,
+  applyBaseline,
+  buildBaseline,
   checkAccessibility,
   checkCanonical,
   checkColorContrast,
@@ -2632,16 +3659,41 @@ export {
   checkTwitterCards,
   checkViewport,
   checks,
+  clearCredentials,
+  cliApiRequest,
+  collectCiMetadata,
+  createMcpServer,
+  credentialFile,
   defaultConfig,
   formatHtml,
   formatJson,
+  formatMarkdown,
+  formatSarif,
   formatTerminal,
   getAvailableChecks,
+  getConfigErrors,
   getEnabledChecks,
+  getIdentity,
+  getRemoteAudit,
+  getWebsites,
+  loadBaseline,
   loadConfig,
+  loadCredentials,
+  locateFinding,
+  pageUrlForFile,
   parseHtml,
   parseSourceFile,
+  ranktureAstro,
+  ranktureVite,
   runChecks,
+  saveBaseline,
+  saveCredentials,
+  startMcpServer,
+  startRemoteAudit,
+  startStaticServer,
+  syncCheckReport,
+  validateConfig,
   validateRobotsTxt,
+  validateSchema,
   validateSitemap
 };