@rankture/cli 0.1.1 → 0.1.3

package/dist/cli.mjs

@@ -4,8 +4,8 @@
 import { Command } from "commander";
 
 // src/commands/check.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
+import * as fs6 from "fs";
+import * as path7 from "path";
 import fg from "fast-glob";
 import ora from "ora";
 
@@ -49,15 +49,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) => {
@@ -69,14 +69,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 = [];
@@ -110,6 +110,7 @@ function parseHtml(filePath, html) {
   return {
     filePath,
     html,
+    sourceContent: html,
     title,
     metaDescription,
     canonical,
@@ -130,7 +131,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);
@@ -273,7 +274,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=['"]([^'"]*)['"]/);
@@ -281,16 +282,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}>
 `;
       }
     }
@@ -313,7 +314,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);
@@ -438,12 +439,12 @@ function parseHtmlLikeContent(filePath, originalContent, htmlContent) {
   const $ = cheerio.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) {
@@ -453,12 +454,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) => {
@@ -479,7 +480,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;
     }
@@ -487,9 +488,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;
@@ -514,9 +515,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,
@@ -528,7 +541,7 @@ function parseHtmlLikeContent(filePath, originalContent, htmlContent) {
     images,
     internalLinks,
     externalLinks,
-    jsonLd: [],
+    jsonLd,
     ogTags: {},
     twitterTags: {},
     robots: void 0,
@@ -538,7 +551,8 @@ function parseHtmlLikeContent(filePath, originalContent, htmlContent) {
 }
 
 // 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({
@@ -552,26 +566,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(
@@ -591,7 +606,7 @@ function checkMetaTitle(page, allPages) {
   }
   return results;
 }
-function checkMetaDescription(page, allPages) {
+function checkMetaDescription(page, allPages, thresholds) {
   const results = [];
   if (!page.metaDescription) {
     results.push({
@@ -605,26 +620,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(
@@ -848,6 +864,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) {
@@ -886,6 +946,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",
@@ -1370,11 +1433,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");
@@ -1395,12 +1458,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));
     }
@@ -1492,8 +1555,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);
     }
   });
@@ -1566,6 +1629,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
@@ -1574,14 +1692,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",
@@ -1716,13 +1834,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,
@@ -1733,27 +1851,226 @@ 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;
 }
+function getAvailableChecks() {
+  return checks.map((c) => c.id);
+}
+
+// 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",
+  "rankture.config.mjs",
+  ".rankturerc",
+  ".rankturerc.json",
+  ".rankturerc.js"
+];
+var defaultConfig = {
+  checks: {},
+  ignore: [],
+  rules: {},
+  thresholds: {
+    titleLength: { min: 30, max: 60 },
+    descriptionLength: { min: 120, max: 160 }
+  }
+};
+async function loadConfig(basePath, configPath) {
+  if (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) {
+      const configFilePath = path2.join(currentDir, configName);
+      if (fs2.existsSync(configFilePath)) {
+        return parseConfigFile(configFilePath);
+      }
+    }
+    const packageJsonPath = path2.join(currentDir, "package.json");
+    if (fs2.existsSync(packageJsonPath)) {
+      try {
+        const packageJson = JSON.parse(fs2.readFileSync(packageJsonPath, "utf-8"));
+        if (packageJson.rankture) {
+          assertValidConfig(packageJson.rankture, packageJsonPath);
+          return mergeConfig(defaultConfig, packageJson.rankture);
+        }
+      } catch {
+      }
+    }
+    currentDir = path2.dirname(currentDir);
+  }
+  return defaultConfig;
+}
+async function parseConfigFile(filePath) {
+  const ext = path2.extname(filePath).toLowerCase();
+  if (ext === ".js" || ext === ".mjs") {
+    try {
+      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}`, { 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}`, { cause: error });
+    }
+  }
+}
+function mergeConfig(defaults, userConfig) {
+  return {
+    ...defaults,
+    ...userConfig,
+    checks: { ...defaults.checks, ...userConfig.checks },
+    ignore: [...defaults.ignore || [], ...userConfig.ignore || []],
+    rules: { ...defaults.rules, ...userConfig.rules },
+    thresholds: {
+      ...defaults.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 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) {
+    if (config.checks?.[checkId] === false) {
+      continue;
+    }
+    enabled.add(checkId);
+  }
+  return enabled;
+}
 
 // src/version.ts
-var VERSION = "0.1.1";
+var VERSION = "0.1.3";
 
 // src/reporters/terminal.ts
 import chalk from "chalk";
-function formatTerminal(report) {
+function formatTerminal(report, opts = {}) {
   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("");
+  if (!opts.quiet) {
+    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");
+  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));
@@ -1769,8 +2086,10 @@ function formatTerminal(report) {
       lines.push(formatResult(result));
     }
   }
-  lines.push("");
-  lines.push(chalk.gray("  " + "\u2500".repeat(40)));
+  if (!opts.quiet) {
+    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`));
@@ -1783,6 +2102,9 @@ function formatTerminal(report) {
   }
   summaryParts.push(chalk.green(`${report.summary.passed} passed`));
   lines.push(`  Results: ${summaryParts.join(", ")}`);
+  if (report.baseline) {
+    lines.push(chalk.gray(`  ${report.baseline.suppressed} known issue(s) suppressed by baseline ${report.baseline.file}`));
+  }
   lines.push("");
   if (report.summary.critical > 0) {
     lines.push(chalk.red.bold("  \u2717 Check failed (critical issues found)"));
@@ -1792,7 +2114,9 @@ function formatTerminal(report) {
     lines.push(chalk.green.bold("  \u2713 All checks passed!"));
   }
   lines.push("");
-  return lines.join("\n");
+  const output = lines.join("\n");
+  const ansiPattern = new RegExp("\\u001B\\[[0-?]*[ -/]*[@-~]", "g");
+  return opts.noColor ? output.replace(ansiPattern, "") : output;
 }
 function formatResult(result) {
   const lines = [];
@@ -1834,8 +2158,8 @@ function formatResult(result) {
   lines.push("");
   return lines.join("\n");
 }
-function printReport(report) {
-  console.log(formatTerminal(report));
+function printReport(report, opts = {}) {
+  console.log(formatTerminal(report, opts));
 }
 
 // src/reporters/json.ts
@@ -2251,50 +2575,405 @@ function formatHtml(report) {
 </html>`;
   return html;
 }
-function escapeHtml(text) {
-  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+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()}`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/reporters/sarif.ts
+import * as path3 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 = path3.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 ? path3.relative(absoluteBase, path3.resolve(absoluteBase, r.file)).split(path3.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 } : {} } } : {}
+            }
+          }
+        ]
+      } : {}
+    };
+  });
+  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";
+
+// src/lib/baseline.ts
+import * as fs3 from "fs";
+import * as path4 from "path";
+function issueKey(result, basePath) {
+  const file = result.file ? path4.relative(basePath, path4.resolve(basePath, result.file)).split(path4.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;
+  }
+  return { version: 1, createdAt: timestamp, issues };
+}
+function loadBaseline(filePath) {
+  const absolute = path4.resolve(filePath);
+  if (!fs3.existsSync(absolute)) {
+    throw new Error(`Baseline file not found: ${absolute} (create it with --update-baseline)`);
+  }
+  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(path4.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);
+    }
+  }
+  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 (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 (env.VERCEL === "1") {
+    return withoutEmpty({
+      provider: "vercel",
+      commit: env.VERCEL_GIT_COMMIT_SHA,
+      branch: env.VERCEL_GIT_COMMIT_REF
+    });
+  }
+  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 {
+  }
+  return void 0;
+}
+function withoutEmpty(meta) {
+  return Object.fromEntries(
+    Object.entries(meta).filter(([, value]) => value !== void 0 && value !== "")
+  );
+}
+
+// src/lib/static-server.ts
+import * as fs4 from "fs";
+import * as http from "http";
+import * as path5 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("/") ? [path5.join(relative6, "index.html")] : [relative6, `${relative6}.html`, path5.join(relative6, "index.html")];
+  for (const candidate of candidates) {
+    const resolved = path5.resolve(root, candidate || "index.html");
+    if (resolved !== root && !resolved.startsWith(`${root}${path5.sep}`)) continue;
+    if (fs4.existsSync(resolved) && fs4.statSync(resolved).isFile()) return resolved;
+  }
+  return void 0;
+}
+async function startStaticServer(rootPath, port = 0) {
+  const root = path5.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;
+    }
+    response.writeHead(200, {
+      "Content-Type": CONTENT_TYPES[path5.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((resolve9, reject) => {
+    server.once("error", reject);
+    server.listen(port, "127.0.0.1", resolve9);
+  });
+  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((resolve9, reject) => server.close((error) => error ? reject(error) : resolve9()))
+  };
+}
+function pageUrlForFile(filePath, rootPath, origin) {
+  let relative6 = path5.relative(rootPath, filePath).split(path5.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/lib/api-client.ts
+import { createHash } from "crypto";
+
+// src/lib/credentials.ts
+import * as fs5 from "fs";
+import * as os from "os";
+import * as path6 from "path";
+function credentialFile(env = process.env) {
+  const base = env.RANKTURE_CONFIG_DIR || env.XDG_CONFIG_HOME || (process.platform === "win32" ? env.APPDATA : path6.join(os.homedir(), ".config"));
+  return path6.join(base || path6.join(os.homedir(), ".config"), "rankture", "credentials.json");
+}
+function saveCredentials(credentials, env = process.env) {
+  const file = credentialFile(env);
+  fs5.mkdirSync(path6.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/lib/api-client.ts
+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
+    }
+  });
+  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/commands/check.ts
 function getGitChangedFiles(basePath, stagedOnly) {
   try {
-    const cwd = path2.resolve(basePath);
-    const stagedOutput = execSync("git diff --cached --name-only --diff-filter=ACMR", {
+    const cwd = path7.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) => path2.join(cwd, f));
+      return stagedFiles.map((f) => path7.join(cwd, f));
     }
-    const unstagedOutput = execSync("git diff --name-only --diff-filter=ACMR", {
+    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) => path2.join(cwd, f));
+    return allFiles.map((f) => path7.join(cwd, f));
   } catch {
     return [];
   }
 }
 async function checkCommand(options) {
-  const spinner = ora("Scanning files...").start();
+  const spinner = ora({
+    text: "Scanning files...",
+    isEnabled: Boolean(process.stdout.isTTY && !options.quiet)
+  }).start();
   try {
-    const basePath = path2.resolve(options.path);
-    if (!fs2.existsSync(basePath)) {
+    const basePath = path7.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;
+      }
+    }
+    if ((options.failOn === "new" || options.updateBaseline) && !options.baseline) {
+      spinner.fail(`${options.failOn === "new" ? "--fail-on new" : "--update-baseline"} requires --baseline <file>`);
+      return 1;
+    }
+    if (!fs6.existsSync(basePath)) {
       spinner.fail(`Path not found: ${basePath}`);
       return 1;
     }
-    const stats = fs2.statSync(basePath);
+    const stats = fs6.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 = path2.extname(f).toLowerCase();
+        const ext = path7.extname(f).toLowerCase();
         return allExtensions.includes(ext);
       });
       if (targetFiles.length === 0) {
@@ -2303,7 +2982,7 @@ async function checkCommand(options) {
       }
       spinner.text = `Found ${targetFiles.length} ${options.staged ? "staged" : "changed"} file(s)`;
     } else if (stats.isFile()) {
-      const ext = path2.extname(basePath).toLowerCase();
+      const ext = path7.extname(basePath).toLowerCase();
       if (!allExtensions.includes(ext)) {
         spinner.fail(`Unsupported file type: ${ext}. Supported: ${allExtensions.join(", ")}`);
         return 1;
@@ -2319,7 +2998,7 @@ async function checkCommand(options) {
         "**/.svelte-kit/**",
         "**/dist/**/*.js",
         "**/dist/**/*.css",
-        ...options.ignore
+        ...effectiveIgnore
       ];
       const extensionPattern = allExtensions.map((e) => e.slice(1)).join(",");
       const globPattern = `**/*.{${extensionPattern}}`;
@@ -2333,11 +3012,12 @@ async function checkCommand(options) {
         return 1;
       }
     }
+    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 = fs2.readFileSync(filePath, "utf-8");
-      const ext = path2.extname(filePath).toLowerCase();
+      const content = fs6.readFileSync(filePath, "utf-8");
+      const ext = path7.extname(filePath).toLowerCase();
       let page;
       if (SUPPORTED_EXTENSIONS.html.includes(ext)) {
         page = parseHtml(filePath, content);
@@ -2347,55 +3027,129 @@ async function checkCommand(options) {
       pages.push(page);
     }
     spinner.text = "Running checks...";
-    const effectiveBasePath = stats.isFile() ? path2.dirname(basePath) : basePath;
+    const effectiveBasePath = stats.isFile() ? path7.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);
+      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;
+      }
       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;
+      }
+      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();
+      }
+    }
+    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: allResults.filter((r) => r.passed).length,
-        critical: allResults.filter((r) => !r.passed && r.severity === "critical").length,
-        warning: allResults.filter((r) => !r.passed && r.severity === "warning").length,
-        info: allResults.filter((r) => !r.passed && r.severity === "info").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: allResults.filter((r) => !r.passed)
-      // Only include failures
+      results: reportResults,
+      ci: collectCiMetadata(process.env, effectiveBasePath),
+      baseline: baselineMeta
     };
-    if (options.format === "json") {
-      const json = formatJson(report);
+    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) {
-        fs2.writeFileSync(options.output, json);
-        console.log(`Report written to ${options.output}`);
+        fs6.writeFileSync(options.output, output);
+        if (!options.quiet) console.log(`Report written to ${options.output}`);
       } else {
-        console.log(json);
+        console.log(output);
       }
     } else if (options.format === "html") {
       const html = formatHtml(report);
+      let reportPath;
       if (options.output) {
-        fs2.writeFileSync(options.output, html);
+        fs6.writeFileSync(options.output, html);
+        reportPath = path7.resolve(options.output);
         console.log(`
   \u2705 HTML report written to ${options.output}`);
-        console.log(`  Open in browser: file://${path2.resolve(options.output)}
+        console.log(`  Open in browser: file://${reportPath}
 `);
       } else {
         const outputFile = `seo-report-${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.html`;
-        fs2.writeFileSync(outputFile, html);
+        fs6.writeFileSync(outputFile, html);
+        reportPath = path7.resolve(outputFile);
         console.log(`
   \u2705 HTML report written to ${outputFile}`);
-        console.log(`  Open in browser: file://${path2.resolve(outputFile)}
+        console.log(`  Open in browser: file://${reportPath}
 `);
       }
+      if (options.open) openGeneratedFile(reportPath);
     } else {
-      printReport(report);
+      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;
@@ -2408,23 +3162,54 @@ async function checkCommand(options) {
           exitCode = 1;
         }
         break;
+      case "new":
+        if ((report.baseline?.fresh ?? 0) > 0) exitCode = 1;
+        break;
       case "none":
       default:
         exitCode = 0;
     }
+    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 1;
+    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 ? path7.relative(basePath, result.file).split(path7.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 ? path7.relative(basePath, result.file).split(path7.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)}`);
   }
 }
 async function watchCommand(options) {
-  const basePath = path2.resolve(options.path);
-  if (!fs2.existsSync(basePath)) {
+  const basePath = path7.resolve(options.path);
+  if (!fs6.existsSync(basePath)) {
     console.error(`Path not found: ${basePath}`);
     process.exit(1);
   }
+  const config = await loadConfig(basePath, options.config);
+  const watchIgnore = [.../* @__PURE__ */ new Set([...config.ignore ?? [], ...options.ignore])];
   console.log("");
   console.log("  \u{1F440} Watch mode enabled");
   console.log(`  Watching: ${basePath}`);
@@ -2433,7 +3218,7 @@ async function watchCommand(options) {
   await checkCommand(options);
   const allExtensions = [...SUPPORTED_EXTENSIONS.html, ...SUPPORTED_EXTENSIONS.source];
   const extensionPattern = allExtensions.map((e) => e.slice(1)).join(",");
-  const watchPattern = path2.join(basePath, `**/*.{${extensionPattern}}`);
+  const watchPattern = path7.join(basePath, `**/*.{${extensionPattern}}`);
   const chokidar = await import("chokidar");
   let debounceTimer = null;
   let isRunning = false;
@@ -2463,7 +3248,7 @@ async function watchCommand(options) {
       "**/.next/**",
       "**/.nuxt/**",
       "**/.svelte-kit/**",
-      ...options.ignore.map((p) => `**/${p}`)
+      ...watchIgnore
     ],
     persistent: true,
     ignoreInitial: true
@@ -2478,10 +3263,65 @@ async function watchCommand(options) {
 }
 
 // src/commands/validate.ts
-import * as fs3 from "fs";
-import * as path3 from "path";
+import * as fs7 from "fs";
+import * as path8 from "path";
 import chalk2 from "chalk";
 import { XMLParser } from "fast-xml-parser";
+async function validateSchema(filePath) {
+  const result = { valid: true, errors: [], warnings: [], info: [] };
+  const absolutePath = path8.resolve(filePath);
+  if (!fs7.existsSync(absolutePath)) {
+    return { ...result, valid: false, errors: [`File not found: ${absolutePath}`] };
+  }
+  const content = fs7.readFileSync(absolutePath, "utf-8");
+  const ext = path8.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)}`);
+    }
+    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);
+    }
+  }
+  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,
@@ -2489,13 +3329,13 @@ async function validateRobotsTxt(filePath) {
     warnings: [],
     info: []
   };
-  const absolutePath = path3.resolve(filePath);
-  if (!fs3.existsSync(absolutePath)) {
+  const absolutePath = path8.resolve(filePath);
+  if (!fs7.existsSync(absolutePath)) {
     result.valid = false;
     result.errors.push(`File not found: ${absolutePath}`);
     return result;
   }
-  const content = fs3.readFileSync(absolutePath, "utf-8");
+  const content = fs7.readFileSync(absolutePath, "utf-8");
   const lines = content.split("\n");
   let hasUserAgent = false;
   let hasSitemap = false;
@@ -2596,13 +3436,13 @@ async function validateSitemap(filePath) {
     warnings: [],
     info: []
   };
-  const absolutePath = path3.resolve(filePath);
-  if (!fs3.existsSync(absolutePath)) {
+  const absolutePath = path8.resolve(filePath);
+  if (!fs7.existsSync(absolutePath)) {
     result.valid = false;
     result.errors.push(`File not found: ${absolutePath}`);
     return result;
   }
-  const content = fs3.readFileSync(absolutePath, "utf-8");
+  const content = fs7.readFileSync(absolutePath, "utf-8");
   if (!content.trim().startsWith("<?xml")) {
     result.warnings.push('Missing XML declaration (<?xml version="1.0" encoding="UTF-8"?>)');
   }
@@ -2757,10 +3597,155 @@ function printValidationResult(type, filePath, result) {
   console.log("");
 }
 
+// src/commands/audit.ts
+async function auditCommand(target, options) {
+  try {
+    const parsed = new URL(target);
+    if (!["http:", "https:"].includes(parsed.protocol)) throw new Error("Audit URL must use http or https");
+    if (options.pages !== void 0 && (!Number.isInteger(options.pages) || options.pages < 1)) {
+      throw new Error("--pages must be a positive integer");
+    }
+    if (options.timeout !== void 0 && (!Number.isFinite(options.timeout) || options.timeout < 1)) {
+      throw new Error("--timeout must be a positive number of seconds");
+    }
+    if (options.format && !["terminal", "json"].includes(options.format)) {
+      throw new Error("--format must be terminal or json");
+    }
+    const credentials = { apiKey: options.apiKey, apiUrl: options.apiUrl };
+    const started = await startRemoteAudit(parsed.href, { pages: options.pages }, credentials);
+    if (!options.wait) {
+      print({ auditId: started.auditId, status: "queued" }, options.format);
+      return 0;
+    }
+    const timeoutMs = Math.max(1, options.timeout ?? 900) * 1e3;
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      const audit = await getRemoteAudit(started.auditId, credentials);
+      const status = String(audit.status || "unknown");
+      if (status === "completed") {
+        const full = await getRemoteAudit(started.auditId, credentials, true);
+        print(full, options.format);
+        return 0;
+      }
+      if (["failed", "cancelled"].includes(status)) {
+        print(audit, options.format);
+        return 1;
+      }
+      await new Promise((resolve9) => setTimeout(resolve9, 3e3));
+    }
+    console.error(`Audit ${started.auditId} is still running after ${options.timeout ?? 900} seconds`);
+    return 2;
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : "Unable to run audit");
+    return 2;
+  }
+}
+function print(value, format) {
+  if (format === "json") console.log(JSON.stringify(value, null, 2));
+  else {
+    console.log(`Audit: ${String(value.auditId || value.id || "")}`);
+    console.log(`Status: ${String(value.status || "unknown")}`);
+    if (value.score !== void 0 && value.score !== null) console.log(`Score: ${String(value.score)}`);
+    if (value.failureReason) console.log(`Failure: ${String(value.failureReason)}`);
+  }
+}
+
+// src/commands/auth.ts
+async function loginCommand(apiKey, apiUrl = "https://rankture.com") {
+  const key = apiKey || process.env.RANKTURE_API_KEY;
+  if (!key) {
+    console.error("An API key is required. Create one in Rankture and run: rankture login --api-key <key>");
+    return 1;
+  }
+  try {
+    const identity = await getIdentity({ apiKey: key, apiUrl });
+    saveCredentials({ apiKey: key, apiUrl: apiUrl.replace(/\/$/, "") });
+    console.log(`Logged in as ${identity.user.email}`);
+    return 0;
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : "Unable to validate API key");
+    return 1;
+  }
+}
+function logoutCommand() {
+  console.log(clearCredentials() ? "Logged out of Rankture" : "No stored Rankture login found");
+  return 0;
+}
+async function whoamiCommand() {
+  try {
+    const identity = await getIdentity();
+    console.log(`${identity.user.email}
+Scopes: ${identity.scopes.join(", ")}`);
+    return 0;
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : "Unable to load Rankture identity");
+    return 1;
+  }
+}
+
+// src/mcp/server.ts
+import { spawnSync } from "child_process";
+import * as path9 from "path";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import * as z from "zod/v4";
+function safePath(root, requested) {
+  const resolved = path9.resolve(root, requested);
+  if (resolved !== root && !resolved.startsWith(`${root}${path9.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 = path9.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/cli.ts
 var program = new Command();
 program.name("rankture").description("SEO audit tool for developers - check your sites before deploy").version(VERSION);
-program.command("check <path>").description("Run SEO checks on local HTML files").option("-f, --format <format>", "Output format: terminal, json, html", "terminal").option("-o, --output <file>", "Write output to file").option("--fail-on <level>", "Exit with code 1 on: none, critical, warning, any", "none").option("--ignore <patterns...>", "Glob patterns to ignore", []).option("--config <file>", "Config file path").option("-w, --watch", "Watch for file changes and re-run checks").option("--changed", "Only check files changed in git (staged + unstaged)").option("--staged", "Only check git staged files").action(async (pathArg, opts) => {
+program.command("check <path>").description("Run SEO checks on local HTML files").option("-f, --format <format>", "Output format: terminal, json, html, sarif, markdown", "terminal").option("-o, --output <file>", "Write output to file").option("--fail-on <level>", "Exit with code 1 on: none, critical, warning, any, new", "none").option("--ignore <patterns...>", "Glob patterns to ignore", []).option("--config <file>", "Config file path").option("-w, --watch", "Watch for file changes and re-run checks").option("--changed", "Only check files changed in git (staged + unstaged)").option("--staged", "Only check git staged files").option("--quiet", "Suppress progress and informational findings").option("--no-color", "Disable ANSI colors").option("--baseline <file>", "Compare against a committed Rankture baseline").option("--update-baseline", "Write current failures to --baseline and exit successfully").option("--max-warnings <number>", "Fail when warnings exceed this count").option("--max-critical <number>", "Fail when critical issues exceed this count").option("--min-score <number>", "Fail when score is below this percentage").option("--annotations", "Emit GitHub Actions workflow annotations").option("--serve", "Validate built-site links through an ephemeral local HTTP server").option("--serve-port <number>", "Preferred local server port (0 selects an available port)").option("--open", "Open a generated HTML report in the system browser").option("--sync", "Upload the report to Rankture").option("--website-id <id>", "Associate a synced report with a Rankture website").option("--api-key <key>", "One-run API key override (prefer login or RANKTURE_API_KEY)").option("--api-url <url>", "Rankture API origin override").action(async (pathArg, opts) => {
   const options = {
     path: pathArg,
     format: opts.format,
@@ -2770,7 +3755,22 @@ program.command("check <path>").description("Run SEO checks on local HTML files"
     config: opts.config,
     watch: opts.watch,
     changed: opts.changed,
-    staged: opts.staged
+    staged: opts.staged,
+    quiet: opts.quiet,
+    noColor: opts.color === false,
+    baseline: opts.baseline,
+    updateBaseline: opts.updateBaseline,
+    maxWarnings: opts.maxWarnings === void 0 ? void 0 : Number(opts.maxWarnings),
+    maxCritical: opts.maxCritical === void 0 ? void 0 : Number(opts.maxCritical),
+    minScore: opts.minScore === void 0 ? void 0 : Number(opts.minScore),
+    annotations: opts.annotations,
+    serve: opts.serve,
+    servePort: opts.servePort === void 0 ? void 0 : Number(opts.servePort),
+    open: opts.open,
+    sync: opts.sync,
+    websiteId: opts.websiteId,
+    apiKey: opts.apiKey,
+    apiUrl: opts.apiUrl
   };
   if (opts.watch) {
     await watchCommand(options);
@@ -2779,22 +3779,37 @@ program.command("check <path>").description("Run SEO checks on local HTML files"
     process.exit(exitCode);
   }
 });
-program.command("audit <url>").description("Audit a live URL (requires API key for full features)").option("--api-key <key>", "Rankture API key for Pro features").option("--sync", "Sync results to Rankture dashboard").option("--mobile", "Run mobile audit", true).option("--desktop", "Run desktop audit", false).option("--pages <number>", "Max pages to audit (Pro only)", "1").option("-f, --format <format>", "Output format: terminal, json, html", "terminal").option("--fail-on <level>", "Exit with code 1 on: none, critical, warning, any", "none").action(async (_url, _opts) => {
-  console.error("");
-  console.error("  The audit command is not implemented yet.");
-  console.error("");
-  console.error("  For now, use the check command on your built files:");
-  console.error("    rankture check ./dist");
-  console.error("");
-  console.error("  Or run a free audit at:");
-  console.error("    https://rankture.com/free-seo-audit/");
-  console.error("");
-  process.exit(2);
+program.command("audit <url>").description("Audit a live URL (requires API key for full features)").option("--api-key <key>", "Rankture API key for Pro features").option("--pages <number>", "Max pages to audit (Pro only)", "1").option("-f, --format <format>", "Output format: terminal, json", "terminal").option("--wait", "Wait for the audit to finish").option("--timeout <seconds>", "Maximum wait time", "900").option("--api-url <url>", "Rankture API origin override").action(async (url, opts) => {
+  process.exit(await auditCommand(url, {
+    apiKey: opts.apiKey,
+    apiUrl: opts.apiUrl,
+    pages: Number(opts.pages),
+    wait: opts.wait,
+    timeout: Number(opts.timeout),
+    format: opts.format
+  }));
+});
+program.command("login").description("Validate and securely store a Rankture API key").option("--api-key <key>", "Rankture CLI API key").option("--api-url <url>", "Rankture API origin", "https://rankture.com").action(async (opts) => process.exit(await loginCommand(opts.apiKey, opts.apiUrl)));
+program.command("logout").description("Remove the locally stored Rankture API key").action(() => process.exit(logoutCommand()));
+program.command("whoami").description("Show the authenticated Rankture account and scopes").action(async () => process.exit(await whoamiCommand()));
+program.command("websites").description("List websites available to the authenticated CLI account").option("--json", "Output machine-readable JSON").action(async (opts) => {
+  try {
+    const result = await getWebsites();
+    if (opts.json) console.log(JSON.stringify(result.websites, null, 2));
+    else for (const website of result.websites) console.log(`${website.id}	${website.url}`);
+    process.exit(0);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : "Unable to list websites");
+    process.exit(1);
+  }
+});
+program.command("mcp").description("Start the local Rankture MCP server over stdio").option("--root <path>", "Restrict file access to this project root", process.cwd()).action(async (opts) => {
+  await startMcpServer(opts.root);
 });
 program.command("init").description("Create a rankture.config.json file").option("--force", "Overwrite existing config file").action(async (opts) => {
-  const fs4 = await import("fs");
+  const fs8 = await import("fs");
   const configPath = "./rankture.config.json";
-  if (fs4.existsSync(configPath) && !opts.force) {
+  if (fs8.existsSync(configPath) && !opts.force) {
     console.log("");
     console.log("  \u26A0\uFE0F  rankture.config.json already exists");
     console.log("  Use --force to overwrite");
@@ -2836,7 +3851,7 @@ program.command("init").description("Create a rankture.config.json file").option
       descriptionLength: { min: 120, max: 160 }
     }
   };
-  fs4.writeFileSync(configPath, JSON.stringify(config, null, 2));
+  fs8.writeFileSync(configPath, JSON.stringify(config, null, 2));
   console.log("");
   console.log("  \u2705 Created rankture.config.json");
   console.log("");
@@ -2866,9 +3881,9 @@ program.command("validate <type> <file>").description("Validate sitemap.xml, rob
       printValidationResult("sitemap.xml", file, result);
       process.exit(result.valid ? 0 : 1);
     } else if (normalizedType === "schema") {
-      console.error("\n  Schema validation is not implemented yet.");
-      console.error("  JSON-LD syntax and structure checks run as part of: rankture check <path>\n");
-      process.exit(2);
+      const result = await validateSchema(file);
+      printValidationResult("schema", file, result);
+      process.exit(result.valid ? 0 : 1);
     }
   } catch (error) {
     console.error(`