@writechoice/mint-cli 0.0.4 → 0.0.6

package/README.md

@@ -47,7 +47,7 @@ Check the installed version:
 ```bash
 writechoice --version
 # or
-writechoice -V
+writechoice -v
 ```
 
 ### Update to Latest Version
@@ -74,6 +74,23 @@ You can also omit the `https://` prefix:
 writechoice check links docs.example.com
 ```
 
+**Using a Validation Base URL**
+
+When validating anchor links online, the tool can use a different base URL (e.g., a local development server or staging environment) to click on headings and extract the generated anchors:
+
+```bash
+# Use localhost:3000 for validation (default)
+writechoice check links docs.example.com
+
+# Use a custom validation URL
+writechoice check links docs.example.com http://localhost:3000
+
+# Use a staging environment
+writechoice check links docs.example.com https://staging.example.com
+```
+
+The validation base URL is only used for online checks. Local file validation remains unchanged for optimal performance.
+
 ### Common Options
 
 ```bash
@@ -83,16 +100,10 @@ writechoice check links docs.example.com -f path/to/file.mdx
 # Validate links in a specific directory
 writechoice check links docs.example.com -d path/to/docs
 
-# Use short aliases for common flags
-writechoice check links docs.example.com -v -o my_report.json
-
 # Dry run (extract links without validating)
 writechoice check links docs.example.com --dry-run
 
-# Verbose output
-writechoice check links docs.example.com -v
-
-# Quiet mode (only generate report)
+# Quiet mode (suppress terminal output, only generate report)
 writechoice check links docs.example.com --quiet
 
 # Custom output path for report
@@ -116,20 +127,22 @@ writechoice check links docs.example.com --fix-from-report custom_report.json
 
 ### Complete Options
 
-| Option                     | Alias | Description                                                              | Default             |
-| -------------------------- | ----- | ------------------------------------------------------------------------ | ------------------- |
-| `<baseUrl>`                | -     | Base URL for the documentation site (required, with or without https://) | -                   |
-| `--file <path>`            | `-f`  | Validate links in a single MDX file                                      | -                   |
-| `--dir <path>`             | `-d`  | Validate links in a specific directory                                   | -                   |
-| `--output <path>`          | `-o`  | Output path for JSON report                                              | `links_report.json` |
-| `--dry-run`                | -     | Extract and show links without validating                                | `false`             |
-| `--verbose`                | `-v`  | Print detailed progress information                                      | `false`             |
-| `--quiet`                  | -     | Suppress stdout output (only generate report)                            | `false`             |
-| `--concurrency <number>`   | `-c`  | Number of concurrent browser tabs                                        | `25`                |
-| `--headless`               | -     | Run browser in headless mode                                             | `true`              |
-| `--no-headless`            | -     | Show browser window (for debugging)                                      | -                   |
-| `--fix`                    | -     | Automatically fix anchor links in MDX files                              | `false`             |
-| `--fix-from-report [path]` | -     | Fix anchor links from report file (optional path)                        | `links_report.json` |
+| Option                     | Alias | Description                                                               | Default                 |
+| -------------------------- | ----- | ------------------------------------------------------------------------- | ----------------------- |
+| `<baseUrl>`                | -     | Base URL for the documentation site (required, with or without https://)  | -                       |
+| `[validationBaseUrl]`      | -     | Base URL for online validation (optional, clicks headings to get anchors) | `http://localhost:3000` |
+| `--file <path>`            | `-f`  | Validate links in a single MDX file                                       | -                       |
+| `--dir <path>`             | `-d`  | Validate links in a specific directory                                    | -                       |
+| `--output <path>`          | `-o`  | Output path for JSON report                                               | `links_report.json`     |
+| `--dry-run`                | -     | Extract and show links without validating                                 | `false`                 |
+| `--quiet`                  | -     | Suppress terminal output (only generate report)                           | `false`                 |
+| `--concurrency <number>`   | `-c`  | Number of concurrent browser tabs                                         | `25`                    |
+| `--headless`               | -     | Run browser in headless mode                                              | `true`                  |
+| `--no-headless`            | -     | Show browser window (for debugging)                                       | -                       |
+| `--fix`                    | -     | Automatically fix anchor links in MDX files                               | `false`                 |
+| `--fix-from-report [path]` | -     | Fix anchor links from report file (optional path)                         | `links_report.json`     |
+
+**Note:** Detailed progress output is shown by default. Use `--quiet` to suppress terminal output.
 
 ## How It Works
 
@@ -143,15 +156,24 @@ The tool extracts internal links from MDX files in the following formats:
 4. **JSX Button components**: `<Button href="/path/to/page#anchor">Button Text</Button>`
 
 **Images are automatically ignored:**
+
 - Markdown images: `![Alt Text](./image.png)`
 - HTML images: `<img src="./image.png" />`
 
 ### Validation Process
 
 1. **Local Validation**: First checks if the target MDX file exists locally
-2. **Online Validation**: If local check fails, uses Playwright to navigate to the live URL
-3. **Anchor Validation**: For anchor links, verifies the heading exists and matches the anchor format
-4. **Kebab-case Checking**: Ensures anchors follow the correct kebab-case format
+   - For normal links: Verifies the file exists in the repository
+   - For anchor links: Checks if the heading exists in the MDX file with matching kebab-case format
+2. **Online Validation**: If local check fails, uses Playwright to navigate to the validation base URL
+   - For normal links: Verifies the page loads successfully
+   - For anchor links:
+     - Finds the heading on the page by text matching
+     - Clicks on the heading to trigger anchor generation
+     - Extracts the generated anchor from the URL or href attribute
+     - Compares the generated anchor with the expected anchor
+3. **Validation Base URL**: By default uses `http://localhost:3000` for online validation, or you can specify a custom URL (e.g., staging environment)
+4. **Auto-Fix**: When issues are found, can automatically update MDX files with the correct anchors
 
 ### Report Format
 
@@ -273,16 +295,22 @@ The default concurrency is set to 25 concurrent browser tabs. Adjust this based
 
 ## Examples
 
-### Validate all links with verbose output
+### Validate all links (with progress output)
 
 ```bash
-writechoice check links docs.example.com -v
+writechoice check links docs.example.com
+```
+
+### Validate quietly (suppress terminal output)
+
+```bash
+writechoice check links docs.example.com --quiet
 ```
 
 ### Validate and fix issues in one command
 
 ```bash
-writechoice check links docs.example.com --fix -v
+writechoice check links docs.example.com --fix
 ```
 
 ### Two-step fix workflow
@@ -301,7 +329,7 @@ writechoice check links docs.example.com --fix-from-report
 ### Validate specific directory
 
 ```bash
-writechoice check links docs.example.com -d docs/api -v
+writechoice check links docs.example.com -d docs/api
 ```
 
 ## Troubleshooting

package/bin/cli.js

@@ -24,21 +24,24 @@ const check = program.command("check").description("Validation commands for docu
 
 // Validate links subcommand
 check
-  .command("links <baseUrl>")
+  .command("links <baseUrl> [validationBaseUrl]")
   .description("Validate internal links and anchors in MDX documentation files")
   .option("-f, --file <path>", "Validate links in a single MDX file")
   .option("-d, --dir <path>", "Validate links in a specific directory")
   .option("-o, --output <path>", "Output path for JSON report", "links_report.json")
   .option("--dry-run", "Extract and show links without validating")
-  .option("-v, --verbose", "Print detailed progress information")
-  .option("--quiet", "Suppress stdout output (only generate report)")
+  .option("--quiet", "Suppress terminal output (only generate report)")
   .option("-c, --concurrency <number>", "Number of concurrent browser tabs", "25")
   .option("--headless", "Run browser in headless mode (default)", true)
   .option("--no-headless", "Show browser window (for debugging)")
   .option("--fix", "Automatically fix anchor links in MDX files")
   .option("--fix-from-report [path]", "Fix anchor links from report file (default: links_report.json)")
-  .action(async (baseUrl, options) => {
+  .action(async (baseUrl, validationBaseUrl, options) => {
     const { validateLinks } = await import("../src/commands/validate/links.js");
+    // Verbose is now default (true unless --quiet is specified)
+    options.verbose = !options.quiet;
+    // Set validation base URL to localhost:3000 if not provided
+    options.validationBaseUrl = validationBaseUrl || "http://localhost:3000";
     await validateLinks(baseUrl, options);
   });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@writechoice/mint-cli",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "CLI tool for Mintlify documentation validation and utilities",
   "main": "src/index.js",
   "type": "module",

package/src/commands/validate/links.js

@@ -6,11 +6,11 @@
  * JavaScript-rendered Mintlify pages.
  */
 
-import { readFileSync, writeFileSync, existsSync, readdirSync, statSync } from 'fs';
-import { join, relative, resolve, dirname } from 'path';
-import { fileURLToPath } from 'url';
-import { chromium } from 'playwright';
-import chalk from 'chalk';
+import { readFileSync, writeFileSync, existsSync, readdirSync, statSync } from "fs";
+import { join, relative, resolve, dirname } from "path";
+import { fileURLToPath } from "url";
+import { chromium } from "playwright";
+import chalk from "chalk";
 import {
   cleanHeadingText,
   toKebabCase,
@@ -20,15 +20,15 @@ import {
   findLineNumber,
   removeCodeBlocksAndFrontmatter,
   resolvePath as resolvePathUtil,
-} from '../../utils/helpers.js';
+} from "../../utils/helpers.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
 // Configuration
-const DEFAULT_BASE_URL = 'https://docs.nebius.com';
-const EXCLUDED_DIRS = ['snippets'];
-const MDX_DIRS = ['.'];
+const DEFAULT_BASE_URL = "https://docs.nebius.com";
+const EXCLUDED_DIRS = ["snippets"];
+const MDX_DIRS = ["."];
 const DEFAULT_TIMEOUT = 30000; // 30 seconds
 const DEFAULT_CONCURRENCY = 25;
 
@@ -75,7 +75,7 @@ class ValidationResult {
     actualHeading = null,
     actualHeadingKebab = null,
     errorMessage = null,
-    validationTimeMs = 0
+    validationTimeMs = 0,
   ) {
     this.source = source;
     this.targetUrl = targetUrl;
@@ -106,10 +106,10 @@ function urlToFilePath(url, baseUrl, repoRoot) {
     }
   }
 
-  path = path.replace(/^\/+/, '');
+  path = path.replace(/^\/+/, "");
 
-  if (!path || path === '/') {
-    const indexPath = join(repoRoot, 'index.mdx');
+  if (!path || path === "/") {
+    const indexPath = join(repoRoot, "index.mdx");
     return existsSync(indexPath) ? indexPath : null;
   }
 
@@ -118,7 +118,7 @@ function urlToFilePath(url, baseUrl, repoRoot) {
     return mdxPath;
   }
 
-  const indexPath = join(repoRoot, path, 'index.mdx');
+  const indexPath = join(repoRoot, path, "index.mdx");
   if (existsSync(indexPath)) {
     return indexPath;
   }
@@ -132,44 +132,44 @@ function resolvePath(mdxFilePath, href, baseUrl, repoRoot) {
   }
 
   let path, anchor;
-  if (href.includes('#')) {
-    [path, anchor] = href.split('#', 2);
+  if (href.includes("#")) {
+    [path, anchor] = href.split("#", 2);
   } else {
     path = href;
-    anchor = '';
+    anchor = "";
   }
 
   if (!path && anchor) {
     const relPath = relative(repoRoot, mdxFilePath);
-    const urlPath = relPath.replace(/\.mdx$/, '');
+    const urlPath = relPath.replace(/\.mdx$/, "");
     const fullUrl = normalizeUrl(`${baseUrl}/${urlPath}`);
     return `${fullUrl}#${anchor}`;
   }
 
   let fullUrl;
 
-  if (path.startsWith('/')) {
+  if (path.startsWith("/")) {
     fullUrl = normalizeUrl(baseUrl + path);
   } else {
     const mdxDir = dirname(mdxFilePath);
 
-    if (path.startsWith('./')) {
+    if (path.startsWith("./")) {
       path = path.slice(2);
     }
 
     const resolved = resolve(mdxDir, path);
 
     const relToRoot = relative(repoRoot, resolved);
-    if (relToRoot.startsWith('..')) {
+    if (relToRoot.startsWith("..")) {
       return null;
     }
 
-    const urlPath = relToRoot.replace(/\.mdx$/, '');
+    const urlPath = relToRoot.replace(/\.mdx$/, "");
     fullUrl = normalizeUrl(`${baseUrl}/${urlPath}`);
   }
 
   if (anchor) {
-    fullUrl += '#' + anchor;
+    fullUrl += "#" + anchor;
   }
 
   return fullUrl;
@@ -179,7 +179,7 @@ function resolvePath(mdxFilePath, href, baseUrl, repoRoot) {
 
 function extractMdxHeadings(filePath) {
   try {
-    const content = readFileSync(filePath, 'utf-8');
+    const content = readFileSync(filePath, "utf-8");
     const { cleanedContent } = removeCodeBlocksAndFrontmatter(content);
 
     const headingPattern = /^#{1,6}\s+(.+)$/gm;
@@ -189,7 +189,7 @@ function extractMdxHeadings(filePath) {
     while ((match = headingPattern.exec(cleanedContent)) !== null) {
       let headingText = match[1].trim();
       // Remove any trailing {#custom-id} syntax if present
-      headingText = headingText.replace(/\s*\{#[^}]+\}\s*$/, '');
+      headingText = headingText.replace(/\s*\{#[^}]+\}\s*$/, "");
       headings.push(headingText);
     }
 
@@ -206,7 +206,7 @@ function extractLinksFromFile(filePath, baseUrl, repoRoot, verbose = false) {
 
   let content;
   try {
-    content = readFileSync(filePath, 'utf-8');
+    content = readFileSync(filePath, "utf-8");
   } catch (error) {
     console.error(`Error reading ${filePath}: ${error.message}`);
     return [];
@@ -234,8 +234,8 @@ function extractLinksFromFile(filePath, baseUrl, repoRoot, verbose = false) {
   const markdownMatches = [...cleanedContent.matchAll(LINK_PATTERNS.markdown)];
   for (const match of markdownMatches) {
     // Check if this is actually an image by looking at the character before '['
-    const charBefore = match.index > 0 ? cleanedContent[match.index - 1] : '';
-    if (charBefore === '!') {
+    const charBefore = match.index > 0 ? cleanedContent[match.index - 1] : "";
+    if (charBefore === "!") {
       // This is a markdown image ![alt](url), skip it
       continue;
     }
@@ -252,21 +252,13 @@ function extractLinksFromFile(filePath, baseUrl, repoRoot, verbose = false) {
         findLineNumber(content, match.index),
         linkText.trim(),
         href,
-        'markdown'
+        "markdown",
       );
 
-      const [basePath, anchor = ''] = targetUrl.split('#');
+      const [basePath, anchor = ""] = targetUrl.split("#");
       const expectedSlug = new URL(targetUrl).pathname;
 
-      links.push(
-        new Link(
-          location,
-          targetUrl,
-          basePath,
-          anchor || null,
-          expectedSlug
-        )
-      );
+      links.push(new Link(location, targetUrl, basePath, anchor || null, expectedSlug));
     }
   }
 
@@ -285,21 +277,13 @@ function extractLinksFromFile(filePath, baseUrl, repoRoot, verbose = false) {
         findLineNumber(content, match.index),
         linkText.trim(),
         href,
-        'html'
+        "html",
       );
 
-      const [basePath, anchor = ''] = targetUrl.split('#');
+      const [basePath, anchor = ""] = targetUrl.split("#");
       const expectedSlug = new URL(targetUrl).pathname;
 
-      links.push(
-        new Link(
-          location,
-          targetUrl,
-          basePath,
-          anchor || null,
-          expectedSlug
-        )
-      );
+      links.push(new Link(location, targetUrl, basePath, anchor || null, expectedSlug));
     }
   }
 
@@ -318,21 +302,13 @@ function extractLinksFromFile(filePath, baseUrl, repoRoot, verbose = false) {
         findLineNumber(content, match.index),
         linkText.trim(),
         href,
-        'jsx'
+        "jsx",
       );
 
-      const [basePath, anchor = ''] = targetUrl.split('#');
+      const [basePath, anchor = ""] = targetUrl.split("#");
       const expectedSlug = new URL(targetUrl).pathname;
 
-      links.push(
-        new Link(
-          location,
-          targetUrl,
-          basePath,
-          anchor || null,
-          expectedSlug
-        )
-      );
+      links.push(new Link(location, targetUrl, basePath, anchor || null, expectedSlug));
     }
   }
 
@@ -351,21 +327,13 @@ function extractLinksFromFile(filePath, baseUrl, repoRoot, verbose = false) {
         findLineNumber(content, match.index),
         linkText.trim(),
         href,
-        'jsx'
+        "jsx",
       );
 
-      const [basePath, anchor = ''] = targetUrl.split('#');
+      const [basePath, anchor = ""] = targetUrl.split("#");
       const expectedSlug = new URL(targetUrl).pathname;
 
-      links.push(
-        new Link(
-          location,
-          targetUrl,
-          basePath,
-          anchor || null,
-          expectedSlug
-        )
-      );
+      links.push(new Link(location, targetUrl, basePath, anchor || null, expectedSlug));
     }
   }
 
@@ -378,9 +346,7 @@ function findMdxFiles(repoRoot, directory = null, file = null) {
     return existsSync(fullPath) ? [fullPath] : [];
   }
 
-  const searchDirs = directory
-    ? [resolve(repoRoot, directory)]
-    : MDX_DIRS.map(d => join(repoRoot, d));
+  const searchDirs = directory ? [resolve(repoRoot, directory)] : MDX_DIRS.map((d) => join(repoRoot, d));
 
   const files = [];
 
@@ -393,10 +359,10 @@ function findMdxFiles(repoRoot, directory = null, file = null) {
       const stat = statSync(fullPath);
 
       if (stat.isDirectory()) {
-        if (!EXCLUDED_DIRS.some(excluded => fullPath.includes(excluded))) {
+        if (!EXCLUDED_DIRS.some((excluded) => fullPath.includes(excluded))) {
           walkDir(fullPath);
         }
-      } else if (entry.endsWith('.mdx')) {
+      } else if (entry.endsWith(".mdx")) {
         files.push(fullPath);
       }
     }
@@ -411,7 +377,7 @@ function findMdxFiles(repoRoot, directory = null, file = null) {
 
 // Playwright Validation Functions
 
-async function validateAnchor(page, link, baseUrl, repoRoot, verbose = false, progress = '') {
+async function validateAnchor(page, link, baseUrl, validationBaseUrl, repoRoot, verbose = false, progress = "") {
   const startTime = Date.now();
 
   try {
@@ -419,14 +385,14 @@ async function validateAnchor(page, link, baseUrl, repoRoot, verbose = false, pr
       console.log(`${progress}    Validating anchor: ${link.anchor}`);
     }
 
-    // OPTIMIZATION: Check if anchor exists in local MDX file first
+    // OPTIMIZATION: Check if anchor exists in local MDX file first (local validation)
     const mdxFilePath = urlToFilePath(link.basePath, baseUrl, repoRoot);
     if (mdxFilePath && existsSync(mdxFilePath)) {
       const mdxHeadings = extractMdxHeadings(mdxFilePath);
-      const mdxHeadingsKebab = mdxHeadings.map(h => toKebabCase(h));
+      const mdxHeadingsKebab = mdxHeadings.map((h) => toKebabCase(h));
 
       if (mdxHeadingsKebab.includes(link.anchor)) {
-        const heading = mdxHeadings.find(h => toKebabCase(h) === link.anchor);
+        const heading = mdxHeadings.find((h) => toKebabCase(h) === link.anchor);
         if (verbose) {
           console.log(`${progress}      ✓ Anchor validated locally in MDX file`);
         }
@@ -436,117 +402,206 @@ async function validateAnchor(page, link, baseUrl, repoRoot, verbose = false, pr
           link.basePath,
           link.anchor,
           link.expectedSlug,
-          'success',
+          "success",
           link.basePath,
           heading,
           link.anchor,
           null,
-          Date.now() - startTime
+          Date.now() - startTime,
         );
       } else if (verbose) {
         console.log(`${progress}      Anchor not found in local MDX, checking online...`);
       }
     }
 
-    // Navigate to base page
-    await page.goto(link.basePath, { waitUntil: 'networkidle', timeout: DEFAULT_TIMEOUT });
+    // ONLINE VALIDATION: Use validation base URL to navigate and click on headings
+    // Convert the base path to use the validation base URL
+    const validationUrl = link.basePath.replace(baseUrl, validationBaseUrl);
 
-    // Try to find heading by anchor
-    let heading = await page.$(`#${link.anchor}`);
+    if (verbose) {
+      console.log(`${progress}      Navigating to: ${validationUrl}`);
+    }
+
+    // Navigate to validation page
+    await page.goto(validationUrl, { waitUntil: "networkidle", timeout: DEFAULT_TIMEOUT });
 
-    if (!heading) {
-      heading = await page.$(`[id="${link.anchor}"]`);
+    // Extract headings from the MDX file to find the matching heading text
+    let targetHeadingText = null;
+
+    if (mdxFilePath && existsSync(mdxFilePath)) {
+      const mdxHeadings = extractMdxHeadings(mdxFilePath);
+      const mdxHeadingsKebab = mdxHeadings.map((h) => toKebabCase(h));
+
+      // Find the heading that matches our anchor
+      const headingIndex = mdxHeadingsKebab.indexOf(link.anchor);
+      if (headingIndex !== -1) {
+        targetHeadingText = mdxHeadings[headingIndex];
+        if (verbose) {
+          console.log(`${progress}      Looking for heading: "${targetHeadingText}"`);
+        }
+      }
     }
 
-    if (!heading) {
+    // If we couldn't find the heading text from MDX, try to find it by the link text
+    if (!targetHeadingText && link.source.linkText) {
+      targetHeadingText = link.source.linkText;
+      if (verbose) {
+        console.log(`${progress}      Using link text as heading: "${targetHeadingText}"`);
+      }
+    }
+
+    if (!targetHeadingText) {
       return new ValidationResult(
         link.source,
         link.targetUrl,
         link.basePath,
         link.anchor,
         link.expectedSlug,
-        'failure',
+        "failure",
         null,
         null,
         null,
-        `Anchor #${link.anchor} not found on page`,
-        Date.now() - startTime
+        `Could not determine heading text to search for anchor #${link.anchor}`,
+        Date.now() - startTime,
       );
     }
 
-    // Get heading text and clean it
-    const actualText = await heading.innerText();
-    const actualTextClean = cleanHeadingText(actualText);
-    const actualKebab = toKebabCase(actualTextClean);
+    // Find all headings on the page
+    const headings = await page.$$("h1, h2, h3, h4, h5, h6");
+    let matchedHeading = null;
+    let matchedHeadingText = null;
 
-    // Extract headings from the TARGET MDX file to verify
-    const mdxFilePath2 = urlToFilePath(link.basePath, baseUrl, repoRoot);
-    const mdxHeadings = mdxFilePath2 ? extractMdxHeadings(mdxFilePath2) : [];
-    const mdxHeadingsKebab = mdxHeadings.map(h => toKebabCase(h));
+    // Try to find the heading by text matching
+    for (const heading of headings) {
+      const headingText = await heading.innerText();
+      const headingTextClean = cleanHeadingText(headingText);
 
-    const matchesMdx = mdxHeadingsKebab.includes(actualKebab);
+      // Try exact match first
+      if (headingTextClean.toLowerCase() === targetHeadingText.toLowerCase()) {
+        matchedHeading = heading;
+        matchedHeadingText = headingTextClean;
+        if (verbose) {
+          console.log(`${progress}      Found exact match: "${headingTextClean}"`);
+        }
+        break;
+      }
 
-    if (actualKebab === link.anchor) {
-      if (matchesMdx) {
-        return new ValidationResult(
-          link.source,
-          link.targetUrl,
-          link.basePath,
-          link.anchor,
-          link.expectedSlug,
-          'success',
-          link.basePath,
-          actualTextClean,
-          actualKebab,
-          null,
-          Date.now() - startTime
-        );
-      } else {
-        return new ValidationResult(
-          link.source,
-          link.targetUrl,
-          link.basePath,
-          link.anchor,
-          link.expectedSlug,
-          'failure',
-          null,
-          actualTextClean,
-          actualKebab,
-          `Anchor "#${link.anchor}" matches page heading "${actualTextClean}" but this heading is not found in the MDX file`,
-          Date.now() - startTime
-        );
+      // Try partial match
+      if (
+        headingTextClean.toLowerCase().includes(targetHeadingText.toLowerCase()) ||
+        targetHeadingText.toLowerCase().includes(headingTextClean.toLowerCase())
+      ) {
+        if (!matchedHeading) {
+          matchedHeading = heading;
+          matchedHeadingText = headingTextClean;
+          if (verbose) {
+            console.log(`${progress}      Found partial match: "${headingTextClean}"`);
+          }
+        }
       }
-    } else {
-      if (matchesMdx) {
-        return new ValidationResult(
-          link.source,
-          link.targetUrl,
-          link.basePath,
-          link.anchor,
-          link.expectedSlug,
-          'failure',
-          null,
-          actualTextClean,
-          actualKebab,
-          `Expected anchor "#${link.anchor}" but page heading "${actualTextClean}" should use "#${actualKebab}"`,
-          Date.now() - startTime
-        );
-      } else {
-        return new ValidationResult(
-          link.source,
-          link.targetUrl,
-          link.basePath,
-          link.anchor,
-          link.expectedSlug,
-          'failure',
-          null,
-          actualTextClean,
-          actualKebab,
-          `Expected anchor "#${link.anchor}" but found heading "${actualTextClean}" (#${actualKebab}) which is not in the MDX file`,
-          Date.now() - startTime
-        );
+    }
+
+    if (!matchedHeading) {
+      return new ValidationResult(
+        link.source,
+        link.targetUrl,
+        link.basePath,
+        link.anchor,
+        link.expectedSlug,
+        "failure",
+        null,
+        null,
+        null,
+        `Heading "${targetHeadingText}" not found on page`,
+        Date.now() - startTime,
+      );
+    }
+
+    // Click the heading to trigger anchor generation
+    if (verbose) {
+      console.log(`${progress}      Clicking heading to get generated anchor...`);
+    }
+
+    // Try to click on the heading element or a link inside it
+    let clickTarget = matchedHeading;
+    const linkInHeading = await matchedHeading.$("a");
+    if (linkInHeading) {
+      clickTarget = linkInHeading;
+    }
+
+    await clickTarget.click();
+
+    // Wait a bit for any JavaScript to update the URL
+    await page.waitForTimeout(500);
+
+    // Get the current URL to extract the anchor
+    const currentUrl = page.url();
+    let generatedAnchor = null;
+
+    if (currentUrl.includes("#")) {
+      generatedAnchor = currentUrl.split("#")[1];
+      if (verbose) {
+        console.log(`${progress}      Generated anchor from URL: #${generatedAnchor}`);
       }
     }
+
+    // If no anchor in URL, try to get it from the href attribute of the link
+    if (!generatedAnchor && linkInHeading) {
+      const href = await linkInHeading.getAttribute("href");
+      if (href && href.includes("#")) {
+        generatedAnchor = href.split("#")[1];
+        if (verbose) {
+          console.log(`${progress}      Generated anchor from href: #${generatedAnchor}`);
+        }
+      }
+    }
+
+    if (!generatedAnchor) {
+      return new ValidationResult(
+        link.source,
+        link.targetUrl,
+        link.basePath,
+        link.anchor,
+        link.expectedSlug,
+        "failure",
+        null,
+        matchedHeadingText,
+        null,
+        `Could not extract generated anchor after clicking heading "${matchedHeadingText}"`,
+        Date.now() - startTime,
+      );
+    }
+
+    // Compare the generated anchor with the expected anchor
+    if (generatedAnchor === link.anchor) {
+      return new ValidationResult(
+        link.source,
+        link.targetUrl,
+        link.basePath,
+        link.anchor,
+        link.expectedSlug,
+        "success",
+        link.basePath,
+        matchedHeadingText,
+        generatedAnchor,
+        null,
+        Date.now() - startTime,
+      );
+    } else {
+      return new ValidationResult(
+        link.source,
+        link.targetUrl,
+        link.basePath,
+        link.anchor,
+        link.expectedSlug,
+        "failure",
+        null,
+        matchedHeadingText,
+        generatedAnchor,
+        `Expected anchor "#${link.anchor}" but page generates "#${generatedAnchor}" for heading "${matchedHeadingText}"`,
+        Date.now() - startTime,
+      );
+    }
   } catch (error) {
     return new ValidationResult(
       link.source,
@@ -554,17 +609,17 @@ async function validateAnchor(page, link, baseUrl, repoRoot, verbose = false, pr
       link.basePath,
       link.anchor,
       link.expectedSlug,
-      'error',
+      "error",
       null,
       null,
       null,
       `Error validating anchor: ${error.message}`,
-      Date.now() - startTime
+      Date.now() - startTime,
     );
   }
 }
 
-async function validateNormalLink(page, link, baseUrl, repoRoot, verbose = false, progress = '') {
+async function validateNormalLink(page, link, baseUrl, validationBaseUrl, repoRoot, verbose = false, progress = "") {
   const startTime = Date.now();
 
   try {
@@ -576,7 +631,7 @@ async function validateNormalLink(page, link, baseUrl, repoRoot, verbose = false
     const mdxFilePath = urlToFilePath(link.targetUrl, baseUrl, repoRoot);
     if (mdxFilePath && existsSync(mdxFilePath)) {
       if (verbose) {
-        console.log(`${progress}      ✓ Link validated locally (file exists)`);
+        console.log(`                   ✓ Link validated locally (file exists)`);
       }
       return new ValidationResult(
         link.source,
@@ -584,19 +639,26 @@ async function validateNormalLink(page, link, baseUrl, repoRoot, verbose = false
         link.basePath,
         link.anchor,
         link.expectedSlug,
-        'success',
+        "success",
         link.targetUrl,
         null,
         null,
         null,
-        Date.now() - startTime
+        Date.now() - startTime,
       );
     } else if (verbose) {
-      console.log(`${progress}      File not found locally, checking online...`);
+      console.log(`                   File not found locally, checking online...`);
+    }
+
+    // Convert the target URL to use the validation base URL
+    const validationUrl = link.targetUrl.replace(baseUrl, validationBaseUrl);
+
+    if (verbose) {
+      console.log(`${progress}      Navigating to: ${validationUrl}`);
     }
 
-    // Navigate to the target URL
-    const response = await page.goto(link.targetUrl, { waitUntil: 'networkidle', timeout: DEFAULT_TIMEOUT });
+    // Navigate to the validation URL
+    const response = await page.goto(validationUrl, { waitUntil: "networkidle", timeout: DEFAULT_TIMEOUT });
 
     if (!response) {
       return new ValidationResult(
@@ -605,12 +667,12 @@ async function validateNormalLink(page, link, baseUrl, repoRoot, verbose = false
         link.basePath,
         link.anchor,
         link.expectedSlug,
-        'error',
+        "error",
         null,
         null,
         null,
-        'No response received',
-        Date.now() - startTime
+        "No response received",
+        Date.now() - startTime,
       );
     }
 
@@ -623,12 +685,12 @@ async function validateNormalLink(page, link, baseUrl, repoRoot, verbose = false
         link.basePath,
         link.anchor,
         link.expectedSlug,
-        'failure',
+        "failure",
         actualUrl,
         null,
         null,
         `HTTP ${response.status()}: ${response.statusText()}`,
-        Date.now() - startTime
+        Date.now() - startTime,
       );
     }
 
@@ -638,12 +700,12 @@ async function validateNormalLink(page, link, baseUrl, repoRoot, verbose = false
       link.basePath,
       link.anchor,
       link.expectedSlug,
-      'success',
+      "success",
       actualUrl,
       null,
       null,
       null,
-      Date.now() - startTime
+      Date.now() - startTime,
     );
   } catch (error) {
     return new ValidationResult(
@@ -652,39 +714,41 @@ async function validateNormalLink(page, link, baseUrl, repoRoot, verbose = false
       link.basePath,
       link.anchor,
       link.expectedSlug,
-      'error',
+      "error",
       null,
       null,
       null,
       `Error validating link: ${error.message}`,
-      Date.now() - startTime
+      Date.now() - startTime,
     );
   }
 }
 
-async function validateLink(page, link, baseUrl, repoRoot, verbose = false, progress = '') {
+async function validateLink(page, link, baseUrl, validationBaseUrl, repoRoot, verbose = false, progress = "") {
   if (link.anchor) {
-    return await validateAnchor(page, link, baseUrl, repoRoot, verbose, progress);
+    return await validateAnchor(page, link, baseUrl, validationBaseUrl, repoRoot, verbose, progress);
   } else {
-    return await validateNormalLink(page, link, baseUrl, repoRoot, verbose, progress);
+    return await validateNormalLink(page, link, baseUrl, validationBaseUrl, repoRoot, verbose, progress);
   }
 }
 
-async function validateLinksAsync(links, baseUrl, repoRoot, concurrency, headless, verbose) {
+async function validateLinksAsync(links, baseUrl, validationBaseUrl, repoRoot, concurrency, headless, verbose) {
   const results = [];
 
   let browser;
   try {
     browser = await chromium.launch({ headless });
   } catch (error) {
-    if (error.message.includes('Executable doesn\'t exist') ||
-        error.message.includes('Browser was not installed') ||
-        error.message.includes('browserType.launch')) {
-      console.error(chalk.red('\n✗ Playwright browsers are not installed!'));
-      console.error(chalk.yellow('\nTo install Playwright browsers, run:'));
-      console.error(chalk.cyan('  npx playwright install chromium\n'));
-      console.error('Or install all browsers with:');
-      console.error(chalk.cyan('  npx playwright install\n'));
+    if (
+      error.message.includes("Executable doesn't exist") ||
+      error.message.includes("Browser was not installed") ||
+      error.message.includes("browserType.launch")
+    ) {
+      console.error(chalk.red("\n✗ Playwright browsers are not installed!"));
+      console.error(chalk.yellow("\nTo install Playwright browsers, run:"));
+      console.error(chalk.cyan("  npx playwright install chromium\n"));
+      console.error("Or install all browsers with:");
+      console.error(chalk.cyan("  npx playwright install\n"));
       process.exit(1);
     }
     throw error;
@@ -696,13 +760,13 @@ async function validateLinksAsync(links, baseUrl, repoRoot, concurrency, headles
   async function validateWithSemaphore(link) {
     counter++;
     const current = counter;
-    const progress = verbose ? `[${current}/${links.length}] ` : '';
+    const progress = verbose ? `[${current}/${links.length}] ` : "";
 
     const context = await browser.newContext();
     const page = await context.newPage();
 
     try {
-      const result = await validateLink(page, link, baseUrl, repoRoot, verbose, progress);
+      const result = await validateLink(page, link, baseUrl, validationBaseUrl, repoRoot, verbose, progress);
       return result;
     } finally {
       await context.close();
@@ -716,7 +780,7 @@ async function validateLinksAsync(links, baseUrl, repoRoot, concurrency, headles
   // Process links with concurrency control
   for (let i = 0; i < links.length; i += concurrency) {
     const batch = links.slice(i, i + concurrency);
-    const batchResults = await Promise.all(batch.map(link => validateWithSemaphore(link)));
+    const batchResults = await Promise.all(batch.map((link) => validateWithSemaphore(link)));
     results.push(...batchResults);
   }
 
@@ -735,7 +799,7 @@ function fixLinksFromReport(reportPath, repoRoot, verbose = false) {
 
   let reportData;
   try {
-    reportData = JSON.parse(readFileSync(reportPath, 'utf-8'));
+    reportData = JSON.parse(readFileSync(reportPath, "utf-8"));
   } catch (error) {
     console.error(`Error reading report file: ${error.message}`);
     return {};
@@ -745,7 +809,7 @@ function fixLinksFromReport(reportPath, repoRoot, verbose = false) {
 
   if (Object.keys(resultsByFile).length === 0) {
     if (verbose) {
-      console.log('No failures found in report.');
+      console.log("No failures found in report.");
     }
     return {};
   }
@@ -762,15 +826,13 @@ function fixLinksFromReport(reportPath, repoRoot, verbose = false) {
       continue;
     }
 
-    const fixableFailures = failures.filter(
-      f => f.status === 'failure' && f.actual_heading_kebab && f.anchor
-    );
+    const fixableFailures = failures.filter((f) => f.status === "failure" && f.actual_heading_kebab && f.anchor);
 
     if (fixableFailures.length === 0) continue;
 
     try {
-      const content = readFileSync(fullPath, 'utf-8');
-      let lines = content.split('\n');
+      const content = readFileSync(fullPath, "utf-8");
+      let lines = content.split("\n");
       let modified = false;
       let fixesCount = 0;
 
@@ -791,7 +853,7 @@ function fixLinksFromReport(reportPath, repoRoot, verbose = false) {
         const newAnchor = failure.actual_heading_kebab;
         const linkType = failure.source.link_type;
 
-        const pathPart = oldHref.includes('#') ? oldHref.split('#')[0] : oldHref;
+        const pathPart = oldHref.includes("#") ? oldHref.split("#")[0] : oldHref;
         const newHref = pathPart ? `${pathPart}#${newAnchor}` : `#${newAnchor}`;
 
         if (oldHref === newHref) {
@@ -803,14 +865,14 @@ function fixLinksFromReport(reportPath, repoRoot, verbose = false) {
 
         let replaced = false;
 
-        if (linkType === 'markdown') {
+        if (linkType === "markdown") {
           const oldPattern = `(${oldHref})`;
           const newPattern = `(${newHref})`;
           if (line.includes(oldPattern)) {
             line = line.replace(oldPattern, newPattern);
             replaced = true;
           }
-        } else if (linkType === 'html' || linkType === 'jsx') {
+        } else if (linkType === "html" || linkType === "jsx") {
           for (const quote of ['"', "'"]) {
             const oldPattern = `href=${quote}${oldHref}${quote}`;
             const newPattern = `href=${quote}${newHref}${quote}`;
@@ -838,8 +900,8 @@ function fixLinksFromReport(reportPath, repoRoot, verbose = false) {
       }
 
       if (modified) {
-        const newContent = lines.join('\n');
-        writeFileSync(fullPath, newContent, 'utf-8');
+        const newContent = lines.join("\n");
+        writeFileSync(fullPath, newContent, "utf-8");
         fixesApplied[filePath] = fixesCount;
 
         if (verbose) {
@@ -860,7 +922,7 @@ function fixLinks(results, repoRoot, verbose = false) {
   const failuresByFile = {};
 
   for (const result of results) {
-    if (result.status !== 'failure' || !result.actualHeadingKebab || !result.anchor) {
+    if (result.status !== "failure" || !result.actualHeadingKebab || !result.anchor) {
       continue;
     }
 
@@ -885,8 +947,8 @@ function fixLinks(results, repoRoot, verbose = false) {
     }
 
     try {
-      const content = readFileSync(fullPath, 'utf-8');
-      let lines = content.split('\n');
+      const content = readFileSync(fullPath, "utf-8");
+      let lines = content.split("\n");
       let modified = false;
       let fixesCount = 0;
 
@@ -906,7 +968,7 @@ function fixLinks(results, repoRoot, verbose = false) {
         const oldHref = failure.source.rawHref;
         const linkType = failure.source.linkType;
 
-        const pathPart = oldHref.includes('#') ? oldHref.split('#')[0] : oldHref;
+        const pathPart = oldHref.includes("#") ? oldHref.split("#")[0] : oldHref;
         const newHref = pathPart ? `${pathPart}#${failure.actualHeadingKebab}` : `#${failure.actualHeadingKebab}`;
 
         if (oldHref === newHref) {
@@ -918,14 +980,14 @@ function fixLinks(results, repoRoot, verbose = false) {
 
         let replaced = false;
 
-        if (linkType === 'markdown') {
+        if (linkType === "markdown") {
           const oldPattern = `(${oldHref})`;
           const newPattern = `(${newHref})`;
           if (line.includes(oldPattern)) {
             line = line.replace(oldPattern, newPattern);
             replaced = true;
           }
-        } else if (linkType === 'html' || linkType === 'jsx') {
+        } else if (linkType === "html" || linkType === "jsx") {
           for (const quote of ['"', "'"]) {
             const oldPattern = `href=${quote}${oldHref}${quote}`;
             const newPattern = `href=${quote}${newHref}${quote}`;
@@ -953,8 +1015,8 @@ function fixLinks(results, repoRoot, verbose = false) {
       }
 
       if (modified) {
-        const newContent = lines.join('\n');
-        writeFileSync(fullPath, newContent, 'utf-8');
+        const newContent = lines.join("\n");
+        writeFileSync(fullPath, newContent, "utf-8");
         fixesApplied[filePath] = fixesCount;
 
         if (verbose) {
@@ -975,9 +1037,9 @@ function fixLinks(results, repoRoot, verbose = false) {
 
 function generateReport(results, config, outputPath) {
   const total = results.length;
-  const success = results.filter(r => r.status === 'success').length;
-  const failure = results.filter(r => r.status === 'failure').length;
-  const error = results.filter(r => r.status === 'error').length;
+  const success = results.filter((r) => r.status === "success").length;
+  const failure = results.filter((r) => r.status === "failure").length;
+  const error = results.filter((r) => r.status === "error").length;
 
   const summaryByFile = {};
   for (const result of results) {
@@ -992,7 +1054,7 @@ function generateReport(results, config, outputPath) {
 
   const resultsByFile = {};
   for (const result of results) {
-    if (result.status === 'success') continue;
+    if (result.status === "success") continue;
 
     const filePath = result.source.filePath;
     if (!resultsByFile[filePath]) {
@@ -1015,7 +1077,7 @@ function generateReport(results, config, outputPath) {
     results_by_file: resultsByFile,
   };
 
-  writeFileSync(outputPath, JSON.stringify(report, null, 2), 'utf-8');
+  writeFileSync(outputPath, JSON.stringify(report, null, 2), "utf-8");
 
   return report;
 }
@@ -1028,19 +1090,14 @@ export async function validateLinks(baseUrl, options) {
   // Handle --fix-from-report mode
   if (options.fixFromReport !== undefined) {
     // If flag is passed with a path, use that path; otherwise use default
-    const reportPath = typeof options.fixFromReport === 'string' && options.fixFromReport
-      ? options.fixFromReport
-      : 'links_report.json';
+    const reportPath =
+      typeof options.fixFromReport === "string" && options.fixFromReport ? options.fixFromReport : "links_report.json";
 
     if (!options.quiet) {
       console.log(`Applying fixes from report: ${reportPath}`);
     }
 
-    const fixesApplied = fixLinksFromReport(
-      reportPath,
-      repoRoot,
-      options.verbose && !options.quiet
-    );
+    const fixesApplied = fixLinksFromReport(reportPath, repoRoot, options.verbose && !options.quiet);
 
     if (!options.quiet) {
       if (Object.keys(fixesApplied).length > 0) {
@@ -1049,9 +1106,9 @@ export async function validateLinks(baseUrl, options) {
         for (const [filePath, count] of Object.entries(fixesApplied)) {
           console.log(`  ${filePath}: ${count} fix(es)`);
         }
-        console.log('\nRun validation again to verify the fixes.');
+        console.log("\nRun validation again to verify the fixes.");
       } else {
-        console.log('\nNo fixable issues found in report.');
+        console.log("\nNo fixable issues found in report.");
       }
     }
 
@@ -1060,20 +1117,20 @@ export async function validateLinks(baseUrl, options) {
 
   // Normalize base URL - add https:// if not present
   let normalizedBaseUrl = baseUrl;
-  if (!normalizedBaseUrl.startsWith('http://') && !normalizedBaseUrl.startsWith('https://')) {
-    normalizedBaseUrl = 'https://' + normalizedBaseUrl;
+  if (!normalizedBaseUrl.startsWith("http://") && !normalizedBaseUrl.startsWith("https://")) {
+    normalizedBaseUrl = "https://" + normalizedBaseUrl;
   }
   // Remove trailing slash
-  normalizedBaseUrl = normalizedBaseUrl.replace(/\/+$/, '');
+  normalizedBaseUrl = normalizedBaseUrl.replace(/\/+$/, "");
 
   if (options.verbose && !options.quiet) {
-    console.log('Finding MDX files...');
+    console.log("Finding MDX files...");
   }
 
   const mdxFiles = findMdxFiles(repoRoot, options.dir, options.file);
 
   if (mdxFiles.length === 0) {
-    console.error('No MDX files found.');
+    console.error("No MDX files found.");
     process.exit(1);
   }
 
@@ -1082,7 +1139,7 @@ export async function validateLinks(baseUrl, options) {
   }
 
   if (options.verbose && !options.quiet) {
-    console.log('Extracting links...');
+    console.log("Extracting links...");
   }
 
   const allLinks = [];
@@ -1092,7 +1149,7 @@ export async function validateLinks(baseUrl, options) {
   }
 
   if (allLinks.length === 0) {
-    console.log('No internal links found.');
+    console.log("No internal links found.");
     return;
   }
 
@@ -1101,7 +1158,7 @@ export async function validateLinks(baseUrl, options) {
   }
 
   if (options.dryRun) {
-    console.log('\nExtracted links:');
+    console.log("\nExtracted links:");
     allLinks.forEach((link, i) => {
       console.log(`\n${i + 1}. ${link.source.filePath}:${link.source.lineNumber}`);
       console.log(`   Text: ${link.source.linkText}`);
@@ -1117,23 +1174,36 @@ export async function validateLinks(baseUrl, options) {
   const startTime = Date.now();
 
   if (!options.quiet) {
-    console.log('\nValidating links...');
+    console.log("\nValidating links...");
+  }
+
+  // Normalize validation base URL
+  let normalizedValidationBaseUrl = options.validationBaseUrl || "http://localhost:3000";
+  if (!normalizedValidationBaseUrl.startsWith("http://") && !normalizedValidationBaseUrl.startsWith("https://")) {
+    normalizedValidationBaseUrl = "https://" + normalizedValidationBaseUrl;
+  }
+  // Remove trailing slash
+  normalizedValidationBaseUrl = normalizedValidationBaseUrl.replace(/\/+$/, "");
+
+  if (!options.quiet) {
+    console.log(`\nUsing validation base URL: ${normalizedValidationBaseUrl}`);
   }
 
   const results = await validateLinksAsync(
     allLinks,
     normalizedBaseUrl,
+    normalizedValidationBaseUrl,
     repoRoot,
     parseInt(options.concurrency) || DEFAULT_CONCURRENCY,
     options.headless !== false,
-    options.verbose && !options.quiet
+    options.verbose && !options.quiet,
   );
 
   const executionTime = (Date.now() - startTime) / 1000;
 
   if (options.fix) {
     if (!options.quiet) {
-      console.log('\nApplying fixes...');
+      console.log("\nApplying fixes...");
     }
 
     const fixesApplied = fixLinks(results, repoRoot, options.verbose && !options.quiet);
@@ -1145,9 +1215,9 @@ export async function validateLinks(baseUrl, options) {
         for (const [filePath, count] of Object.entries(fixesApplied)) {
           console.log(`  ${filePath}: ${count} fix(es)`);
         }
-        console.log('\nRun validation again to verify the fixes.');
+        console.log("\nRun validation again to verify the fixes.");
       } else {
-        console.log('\nNo fixable issues found.');
+        console.log("\nNo fixable issues found.");
       }
     }
   }
@@ -1160,23 +1230,23 @@ export async function validateLinks(baseUrl, options) {
     execution_time_seconds: Math.round(executionTime * 100) / 100,
   };
 
-  const report = generateReport(results, config, options.output || 'links_report.json');
+  const report = generateReport(results, config, options.output || "links_report.json");
 
   if (!options.quiet) {
-    console.log(`\n${'='.repeat(60)}`);
-    console.log('VALIDATION SUMMARY');
-    console.log('='.repeat(60));
+    console.log(`\n${"=".repeat(60)}`);
+    console.log("VALIDATION SUMMARY");
+    console.log("=".repeat(60));
     console.log(`Total links:    ${report.summary.total_links}`);
-    console.log(`Success:        ${chalk.green(report.summary.success + ' ✓')}`);
-    console.log(`Failure:        ${chalk.red(report.summary.failure + ' ✗')}`);
-    console.log(`Error:          ${chalk.yellow(report.summary.error + ' ⚠')}`);
+    console.log(`Success:        ${chalk.green(report.summary.success + " ✓")}`);
+    console.log(`Failure:        ${chalk.red(report.summary.failure + " ✗")}`);
+    console.log(`Error:          ${chalk.yellow(report.summary.error + " ⚠")}`);
     console.log(`Execution time: ${executionTime.toFixed(2)}s`);
-    console.log(`\nReport saved to: ${options.output || 'links_report.json'}`);
+    console.log(`\nReport saved to: ${options.output || "links_report.json"}`);
 
     if (report.summary.failure > 0 || report.summary.error > 0) {
-      console.log(`\n${'='.repeat(60)}`);
-      console.log('ISSUES FOUND');
-      console.log('='.repeat(60));
+      console.log(`\n${"=".repeat(60)}`);
+      console.log("ISSUES FOUND");
+      console.log("=".repeat(60));
       let shown = 0;
 
       for (const [filePath, fileResults] of Object.entries(report.results_by_file)) {
@@ -1196,7 +1266,9 @@ export async function validateLinks(baseUrl, options) {
 
       if (shown < report.summary.failure + report.summary.error) {
         const remaining = report.summary.failure + report.summary.error - shown;
-        console.log(`\n... and ${remaining} more issues. See ${options.output || 'links_report.json'} for full details.`);
+        console.log(
+          `\n... and ${remaining} more issues. See ${options.output || "links_report.json"} for full details.`,
+        );
       }
     }
   }