pagesight 0.17.0 → 0.19.0

package/src/tools/page/analyze.ts

@@ -0,0 +1,194 @@
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { parseHead, getMeta, formatMetatags } from "./metadata.js";
+import { validateJsonLd, formatValidation } from "./structured-data.js";
+import {
+  followRedirects,
+  checkImage,
+  checkLink,
+  extractInternalLinks,
+  formatLinkResults,
+  type LinkResult,
+} from "./links.js";
+import { parseHex, relativeLuminance, contrastRatio, wcagLevel, toHex, findNearestPassing } from "./contrast.js";
+
+export async function analyzePage(
+  url: string,
+  options: {
+    check_links?: boolean;
+    user_agent?: string;
+    foreground?: string;
+    background?: string;
+    large_text?: boolean;
+  },
+): Promise<CallToolResult> {
+  const { check_links, user_agent, foreground, background, large_text } = options;
+  try {
+    const ua = user_agent ?? "Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)";
+    const { chain, response: res } = await followRedirects(url, ua);
+
+    if (!res.ok) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error fetching ${url}: HTTP ${res.status} ${res.statusText}`,
+          },
+        ],
+      };
+    }
+
+    const html = await res.text();
+    const parsed = parseHead(html);
+    const output: string[] = [];
+
+    // Redirect chain (only if there were redirects)
+    if (chain.length > 1) {
+      output.push("--- Redirect Chain ---", "");
+      const parts: string[] = [];
+      for (const hop of chain) {
+        parts.push(hop.url);
+        parts.push(String(hop.status));
+      }
+      // Format: URL → status → URL → status (drop trailing status)
+      parts.pop();
+      output.push(parts.join(" → "));
+      output.push(`Hops: ${chain.length - 1}`);
+      output.push("");
+    }
+
+    // Main meta tag report
+    const finalUrl = chain.length > 1 ? chain[chain.length - 1].url : url;
+    output.push(formatMetatags(finalUrl, parsed));
+
+    // OG/Twitter image validation
+    const ogImage = getMeta(parsed.meta, "og:image");
+    const twitterImage = getMeta(parsed.meta, "twitter:image");
+    const imagesToCheck: Array<{ url: string; tag: string }> = [];
+    if (ogImage) imagesToCheck.push({ url: ogImage, tag: "og:image" });
+    if (twitterImage && twitterImage !== ogImage) imagesToCheck.push({ url: twitterImage, tag: "twitter:image" });
+
+    if (imagesToCheck.length > 0) {
+      const checks = await Promise.all(imagesToCheck.map((img) => checkImage(img.url, img.tag)));
+      output.push("", "--- Image Validation ---", "");
+      for (const check of checks) {
+        if (check.error) {
+          output.push(`${check.tag}: FAILED — ${check.error}`);
+          output.push(`  URL: ${check.url}`);
+        } else if (check.status && check.status >= 400) {
+          output.push(`${check.tag}: BROKEN — HTTP ${check.status}`);
+          output.push(`  URL: ${check.url}`);
+        } else {
+          const sizeKB = check.contentLength ? Math.round(check.contentLength / 1024) : null;
+          const size = sizeKB ? ` (${sizeKB} KB)` : "";
+          const type = check.contentType ? ` ${check.contentType}` : "";
+          output.push(`${check.tag}: OK —${type}${size}`);
+          if (sizeKB && sizeKB > 1024) {
+            output.push(`  Warning: ${sizeKB} KB is large for social previews — consider compressing below 1 MB`);
+          }
+        }
+
+        // Check declared dimensions from meta tags
+        if (check.tag === "og:image") {
+          const w = getMeta(parsed.meta, "og:image:width");
+          const h = getMeta(parsed.meta, "og:image:height");
+          if (w && h) {
+            output.push(`  Declared dimensions: ${w}x${h}`);
+            const wn = Number(w);
+            const hn = Number(h);
+            if (wn && hn && (wn < 1200 || hn < 630)) {
+              output.push("  Note: recommended minimum for og:image is 1200x630");
+            }
+          }
+        }
+      }
+    }
+
+    // Structured data validation
+    if (parsed.jsonLd.length > 0) {
+      const { issues, imageUrls, validatedTypes } = validateJsonLd(parsed.jsonLd);
+      if (validatedTypes.size > 0 || imageUrls.length > 0) {
+        output.push("", "--- Structured Data Validation ---", "");
+        output.push(...formatValidation(issues, validatedTypes));
+
+        // HEAD-check image URLs from structured data
+        if (imageUrls.length > 0) {
+          const deduped = [...new Set(imageUrls)];
+          const imgChecks = await Promise.all(deduped.map((u) => checkImage(u, "schema")));
+          for (const check of imgChecks) {
+            if (check.error) {
+              output.push(`BROKEN   Image: ${check.url} — ${check.error}`);
+            } else if (check.status && check.status >= 400) {
+              output.push(`BROKEN   Image: ${check.url} — HTTP ${check.status}`);
+            } else {
+              const sizeKB = check.contentLength ? Math.round(check.contentLength / 1024) : null;
+              output.push(`OK       Image: ${check.url}${sizeKB ? ` (${sizeKB} KB)` : ""}`);
+            }
+          }
+        }
+      }
+    }
+
+    if (foreground && background) {
+      const fg = parseHex(foreground);
+      const bg = parseHex(background);
+      if (fg && bg) {
+        const fgLum = relativeLuminance(...fg);
+        const bgLum = relativeLuminance(...bg);
+        const ratio = contrastRatio(fgLum, bgLum);
+        const isLarge = large_text ?? false;
+        const level = wcagLevel(ratio, isLarge);
+        const aaThreshold = isLarge ? 3 : 4.5;
+        const aaaThreshold = isLarge ? 4.5 : 7;
+        output.push(
+          "",
+          "--- Contrast Check ---",
+          "",
+          `Foreground: ${toHex(...fg)}  Background: ${toHex(...bg)}`,
+          `Ratio: ${ratio.toFixed(2)}:1  AA: ${ratio >= aaThreshold ? "PASS" : "FAIL"}  AAA: ${ratio >= aaaThreshold ? "PASS" : "FAIL"}  Result: ${level}`,
+        );
+        if (ratio < aaThreshold) {
+          const suggested = findNearestPassing(fg, bg, aaThreshold);
+          output.push(`Nearest AA-passing foreground: ${suggested}`);
+        }
+      }
+    }
+
+    // --- Link check (last section) ---
+    if (check_links !== false) {
+      const origin = new URL(url).origin;
+      const links = extractInternalLinks(html, origin);
+
+      if (links.length === 0) {
+        output.push(
+          "",
+          "--- Internal Links ---",
+          "",
+          "No internal links found.",
+          "Note: this page may use client-side rendering (SPA). Only static <a href> links in the HTML are detected.",
+        );
+      } else {
+        const concurrency = 5;
+        const results: LinkResult[] = [];
+        let i = 0;
+
+        while (i < links.length) {
+          const batch = links.slice(i, i + concurrency);
+          const settled = await Promise.all(batch.map((href) => checkLink(href)));
+          results.push(...settled);
+          i += concurrency;
+        }
+
+        output.push("", formatLinkResults(url, results));
+      }
+    }
+
+    return {
+      content: [{ type: "text", text: output.join("\n") }],
+    };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return {
+      content: [{ type: "text", text: `Error analyzing page: ${msg}` }],
+    };
+  }
+}

package/src/tools/page/batch.ts

@@ -0,0 +1,163 @@
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { parseHead, getMeta } from "./metadata.js";
+import { formatJsonLdType, validateJsonLd } from "./structured-data.js";
+import { followRedirects, checkLink, extractInternalLinks } from "./links.js";
+
+export async function analyzeBatch(
+  urls: string[],
+  options: { check_links?: boolean; user_agent?: string },
+): Promise<CallToolResult> {
+  const { check_links, user_agent } = options;
+  const ua = user_agent ?? "Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)";
+  const results: Array<{
+    url: string;
+    title: string;
+    description: string;
+    canonical: string;
+    jsonLd: string;
+    links: string;
+    issues: string[];
+    error?: string;
+  }> = [];
+
+  for (const pageUrl of urls) {
+    try {
+      const { chain, response: res } = await followRedirects(pageUrl, ua);
+      if (!res.ok) {
+        results.push({
+          url: pageUrl,
+          title: "-",
+          description: "-",
+          canonical: "-",
+          jsonLd: "-",
+          links: "-",
+          issues: [`HTTP ${res.status}`],
+        });
+        continue;
+      }
+      const html = await res.text();
+      const parsed = parseHead(html);
+      const finalUrl = chain.length > 1 ? chain[chain.length - 1].url : pageUrl;
+
+      const issues: string[] = [];
+      if (!parsed.title) issues.push("no title");
+      if (!getMeta(parsed.meta, "description")) issues.push("no description");
+      else if ((getMeta(parsed.meta, "description") ?? "").length > 155) issues.push("description >155 chars");
+      if (!parsed.canonical) issues.push("no canonical");
+      if (parsed.jsonLd.length === 0) issues.push("no JSON-LD");
+      if (chain.length > 2) issues.push(`${chain.length - 1} redirects`);
+
+      // Quick link check
+      let linkSummary = "-";
+      if (check_links !== false) {
+        const origin = new URL(finalUrl).origin;
+        const links = extractInternalLinks(html, origin);
+        if (links.length > 0) {
+          const checked = await Promise.all(links.slice(0, 20).map((href) => checkLink(href)));
+          const broken = checked.filter((r) => r.error || (r.status && r.status >= 400)).length;
+          const redirected = checked.filter(
+            (r) => !r.error && r.redirectChain.length > 1 && r.status && r.status < 400,
+          ).length;
+          const parts: string[] = [`${links.length} found`];
+          if (broken > 0) parts.push(`${broken} broken`);
+          if (redirected > 0) parts.push(`${redirected} redirected`);
+          if (broken === 0 && redirected === 0) parts.push("all OK");
+          linkSummary = parts.join(", ");
+          if (broken > 0) issues.push(`${broken} broken links`);
+          if (redirected > 0) issues.push(`${redirected} redirect chains`);
+        } else {
+          linkSummary = "0 (SPA?)";
+        }
+      }
+
+      const jsonLdTypes = parsed.jsonLd
+        .map((block) => {
+          if (block && typeof block === "object" && "@type" in block)
+            return formatJsonLdType((block as Record<string, unknown>)["@type"], ",");
+          return null;
+        })
+        .filter(Boolean);
+
+      // Run structured data validation for batch summary
+      let jsonLdSummary = "none";
+      if (parsed.jsonLd.length > 0) {
+        const { issues: valIssues } = validateJsonLd(parsed.jsonLd);
+        const requiredMissing = valIssues.filter((i) => i.level === "required").length;
+        if (jsonLdTypes.length > 0) {
+          jsonLdSummary = `${jsonLdTypes.join(", ")} (selected fields only)`;
+          if (requiredMissing > 0) {
+            jsonLdSummary += ` (${requiredMissing} required missing)`;
+            issues.push(`${requiredMissing} missing required fields in checked JSON-LD subset`);
+          }
+        }
+      }
+
+      // Description with length
+      const descVal = getMeta(parsed.meta, "description");
+      let descSummary: string;
+      if (descVal) {
+        descSummary = descVal.length > 155 ? `yes (${descVal.length} chars ⚠)` : `yes (${descVal.length})`;
+      } else {
+        descSummary = "no";
+      }
+
+      results.push({
+        url: finalUrl,
+        title: parsed.title
+          ? parsed.title.length > 60
+            ? `${parsed.title.slice(0, parsed.title.lastIndexOf(" ", 60) > 20 ? parsed.title.lastIndexOf(" ", 60) : 60)}...`
+            : parsed.title
+          : "(missing)",
+        description: descSummary,
+        canonical: parsed.canonical ? "yes" : "no",
+        jsonLd: jsonLdSummary,
+        links: linkSummary,
+        issues,
+      });
+    } catch (err) {
+      results.push({
+        url: pageUrl,
+        title: "-",
+        description: "-",
+        canonical: "-",
+        jsonLd: "-",
+        links: "-",
+        issues: [err instanceof Error ? err.message : String(err)],
+      });
+    }
+  }
+
+  const lines: string[] = [`=== Batch Page Analysis (${results.length} URLs) ===`, ""];
+
+  for (const r of results) {
+    let label: string;
+    try {
+      const u = new URL(r.url);
+      const allSameHost = results.every((x) => {
+        try {
+          return new URL(x.url).hostname === u.hostname;
+        } catch {
+          return false;
+        }
+      });
+      label = allSameHost ? u.pathname : `${u.hostname}${u.pathname}`;
+    } catch {
+      label = r.url;
+    }
+    lines.push(label);
+    lines.push(`  Title: ${r.title}`);
+    lines.push(`  Description: ${r.description}  Canonical: ${r.canonical}  JSON-LD: ${r.jsonLd}`);
+    if (check_links !== false) lines.push(`  Links: ${r.links}`);
+    if (r.issues.length > 0) {
+      lines.push(`  Issues: ${r.issues.join(", ")}`);
+    } else {
+      lines.push("  Issues: none");
+    }
+    lines.push("");
+  }
+
+  const issueCount = results.reduce((sum, r) => sum + r.issues.length, 0);
+  lines.push(`Total: ${results.length} pages, ${issueCount} issues`);
+
+  return { content: [{ type: "text", text: lines.join("\n") }] };
+}

package/src/tools/page/contrast.ts

@@ -0,0 +1,128 @@
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+export function parseHex(hex: string): [number, number, number] | null {
+  const clean = hex.replace(/^#/, "");
+  if (clean.length === 3) {
+    const r = Number.parseInt(clean[0] + clean[0], 16);
+    const g = Number.parseInt(clean[1] + clean[1], 16);
+    const b = Number.parseInt(clean[2] + clean[2], 16);
+    return [r, g, b];
+  }
+  if (clean.length === 6) {
+    const r = Number.parseInt(clean.slice(0, 2), 16);
+    const g = Number.parseInt(clean.slice(2, 4), 16);
+    const b = Number.parseInt(clean.slice(4, 6), 16);
+    return [r, g, b];
+  }
+  return null;
+}
+
+export function toHex(r: number, g: number, b: number): string {
+  return `#${[r, g, b].map((c) => Math.round(c).toString(16).padStart(2, "0")).join("")}`;
+}
+
+export function relativeLuminance(r: number, g: number, b: number): number {
+  const [rs, gs, bs] = [r, g, b].map((c) => {
+    const s = c / 255;
+    return s <= 0.04045 ? s / 12.92 : ((s + 0.055) / 1.055) ** 2.4;
+  });
+  return 0.2126 * rs + 0.7152 * gs + 0.0722 * bs;
+}
+
+export function contrastRatio(l1: number, l2: number): number {
+  const lighter = Math.max(l1, l2);
+  const darker = Math.min(l1, l2);
+  return (lighter + 0.05) / (darker + 0.05);
+}
+
+export function wcagLevel(ratio: number, isLargeText: boolean): string {
+  if (isLargeText) {
+    if (ratio >= 4.5) return "AAA";
+    if (ratio >= 3) return "AA";
+    return "FAIL";
+  }
+  if (ratio >= 7) return "AAA";
+  if (ratio >= 4.5) return "AA";
+  return "FAIL";
+}
+
+export function findNearestPassing(
+  fg: [number, number, number],
+  bg: [number, number, number],
+  targetRatio: number,
+): string {
+  const bgLum = relativeLuminance(...bg);
+
+  // Try both directions: darken and lighten, pick the one closest to original
+  let bestDarken: [number, number, number] | null = null;
+  let bestLighten: [number, number, number] | null = null;
+
+  for (let step = 0; step <= 100; step++) {
+    const t = step / 100;
+    const dark: [number, number, number] = [fg[0] * (1 - t), fg[1] * (1 - t), fg[2] * (1 - t)];
+    if (!bestDarken && contrastRatio(relativeLuminance(...dark), bgLum) >= targetRatio) {
+      bestDarken = dark;
+    }
+    const light: [number, number, number] = [
+      fg[0] + (255 - fg[0]) * t,
+      fg[1] + (255 - fg[1]) * t,
+      fg[2] + (255 - fg[2]) * t,
+    ];
+    if (!bestLighten && contrastRatio(relativeLuminance(...light), bgLum) >= targetRatio) {
+      bestLighten = light;
+    }
+    if (bestDarken && bestLighten) break;
+  }
+
+  // Pick the direction that changes the color least
+  if (bestDarken && bestLighten) {
+    const darkDist =
+      Math.abs(fg[0] - bestDarken[0]) + Math.abs(fg[1] - bestDarken[1]) + Math.abs(fg[2] - bestDarken[2]);
+    const lightDist =
+      Math.abs(fg[0] - bestLighten[0]) + Math.abs(fg[1] - bestLighten[1]) + Math.abs(fg[2] - bestLighten[2]);
+    return toHex(...(darkDist <= lightDist ? bestDarken : bestLighten));
+  }
+  return toHex(...(bestDarken ?? bestLighten ?? fg));
+}
+
+export function analyzeContrast(foreground: string, background: string, large_text?: boolean): CallToolResult {
+  const fg = parseHex(foreground);
+  const bg = parseHex(background);
+
+  if (!fg) return { content: [{ type: "text", text: `Invalid foreground color: ${foreground}` }] };
+  if (!bg) return { content: [{ type: "text", text: `Invalid background color: ${background}` }] };
+
+  const fgLum = relativeLuminance(...fg);
+  const bgLum = relativeLuminance(...bg);
+  const ratio = contrastRatio(fgLum, bgLum);
+  const isLarge = large_text ?? false;
+  const level = wcagLevel(ratio, isLarge);
+
+  const aaThreshold = isLarge ? 3 : 4.5;
+  const aaaThreshold = isLarge ? 4.5 : 7;
+
+  const lines: string[] = [
+    "=== Contrast Check ===",
+    "",
+    `Foreground: ${toHex(...fg)}`,
+    `Background: ${toHex(...bg)}`,
+    `Text size: ${isLarge ? "large (≥18pt)" : "normal"}`,
+    "",
+    `Contrast ratio: ${ratio.toFixed(2)}:1`,
+    `WCAG AA (${aaThreshold}:1): ${ratio >= aaThreshold ? "PASS" : "FAIL"}`,
+    `WCAG AAA (${aaaThreshold}:1): ${ratio >= aaaThreshold ? "PASS" : "FAIL"}`,
+    `Result: ${level}`,
+  ];
+
+  if (ratio < aaThreshold) {
+    const suggested = findNearestPassing(fg, bg, aaThreshold);
+    lines.push("", `Nearest AA-passing foreground: ${suggested}`);
+
+    const sugParsed = parseHex(suggested);
+    if (sugParsed) {
+      const sugRatio = contrastRatio(relativeLuminance(...sugParsed), bgLum);
+      lines.push(`New ratio: ${sugRatio.toFixed(2)}:1`);
+    }
+  }
+
+  return { content: [{ type: "text", text: lines.join("\n") }] };
+}

package/src/tools/page/links.ts

@@ -0,0 +1,200 @@
+interface RedirectHop {
+  url: string;
+  status: number;
+}
+
+interface ImageCheck {
+  url: string;
+  tag: string;
+  status: number | null;
+  contentType: string | null;
+  contentLength: number | null;
+  error: string | null;
+}
+
+export interface LinkResult {
+  href: string;
+  status: number | null;
+  redirectChain: Array<{ url: string; status: number }>;
+  finalUrl: string | null;
+  error: string | null;
+}
+
+export async function followRedirects(
+  url: string,
+  ua: string,
+  maxHops = 10,
+): Promise<{ chain: RedirectHop[]; response: Response }> {
+  const chain: RedirectHop[] = [];
+  let current = url;
+
+  for (let i = 0; i < maxHops; i++) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 15_000);
+    const res = await fetch(current, {
+      headers: { "User-Agent": ua, Accept: "text/html" },
+      redirect: "manual",
+      signal: controller.signal,
+    });
+    clearTimeout(timeout);
+
+    chain.push({ url: current, status: res.status });
+
+    if (res.status >= 300 && res.status < 400) {
+      const location = res.headers.get("location");
+      if (!location) break;
+      current = new URL(location, current).href;
+      continue;
+    }
+
+    return { chain, response: res };
+  }
+
+  // Retry with automatic redirects after the hop limit or a missing Location header.
+  const res = await fetch(current, {
+    headers: { "User-Agent": ua, Accept: "text/html" },
+    redirect: "follow",
+  });
+  return { chain, response: res };
+}
+
+export async function checkImage(imageUrl: string, tag: string): Promise<ImageCheck> {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 10_000);
+    const res = await fetch(imageUrl, { method: "HEAD", redirect: "follow", signal: controller.signal });
+    clearTimeout(timeout);
+    return {
+      url: imageUrl,
+      tag,
+      status: res.status,
+      contentType: res.headers.get("content-type"),
+      contentLength: res.headers.has("content-length") ? Number(res.headers.get("content-length")) : null,
+      error: null,
+    };
+  } catch (err) {
+    return {
+      url: imageUrl,
+      tag,
+      status: null,
+      contentType: null,
+      contentLength: null,
+      error: err instanceof Error ? err.message : String(err),
+    };
+  }
+}
+
+export async function checkLink(href: string): Promise<LinkResult> {
+  const chain: Array<{ url: string; status: number }> = [];
+  let current = href;
+
+  try {
+    for (let i = 0; i < 10; i++) {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), 10_000);
+      const res = await fetch(current, {
+        method: "HEAD",
+        headers: { "User-Agent": "Mozilla/5.0 (compatible; Googlebot/2.1)", Accept: "text/html" },
+        redirect: "manual",
+        signal: controller.signal,
+      });
+      clearTimeout(timeout);
+
+      chain.push({ url: current, status: res.status });
+
+      if (res.status >= 300 && res.status < 400) {
+        const location = res.headers.get("location");
+        if (!location) break;
+        current = new URL(location, current).href;
+        continue;
+      }
+
+      return {
+        href,
+        status: res.status,
+        redirectChain: chain,
+        finalUrl: chain.length > 1 ? current : null,
+        error: null,
+      };
+    }
+
+    return {
+      href,
+      status: chain[chain.length - 1]?.status ?? null,
+      redirectChain: chain,
+      finalUrl: current,
+      error: "Too many redirects",
+    };
+  } catch (err) {
+    return {
+      href,
+      status: null,
+      redirectChain: chain,
+      finalUrl: null,
+      error: err instanceof Error ? err.message : String(err),
+    };
+  }
+}
+
+export function extractInternalLinks(html: string, origin: string): string[] {
+  const links = new Set<string>();
+
+  for (const match of html.matchAll(/<a\s[^>]*href=["']([^"'#]+)/gi)) {
+    const raw = match[1].trim();
+    if (!raw || raw.startsWith("javascript:") || raw.startsWith("mailto:") || raw.startsWith("tel:")) continue;
+
+    try {
+      const resolved = new URL(raw, origin).href;
+      if (resolved.startsWith(origin) && !resolved.includes("/cdn-cgi/")) {
+        links.add(resolved);
+      }
+    } catch {
+      // Invalid URL, skip
+    }
+  }
+
+  return [...links];
+}
+
+export function formatLinkResults(url: string, results: LinkResult[]): string {
+  const lines: string[] = [`=== Internal Links: ${url} ===`, `Found ${results.length} internal links`, ""];
+
+  const broken = results.filter((r) => r.error || (r.status && r.status >= 400));
+  const redirected = results.filter((r) => !r.error && r.redirectChain.length > 1 && r.status && r.status < 400);
+  const ok = results.filter((r) => !r.error && r.redirectChain.length === 1 && r.status && r.status < 400);
+
+  // Summary
+  lines.push("--- Summary ---", "");
+  lines.push(`OK: ${ok.length}`);
+  if (redirected.length > 0) lines.push(`Redirected: ${redirected.length}`);
+  if (broken.length > 0) lines.push(`Broken: ${broken.length}`);
+  lines.push("");
+
+  // Broken links
+  if (broken.length > 0) {
+    lines.push("--- Broken Links ---", "");
+    for (const r of broken) {
+      if (r.error) {
+        lines.push(`FAIL  ${r.href}`);
+        lines.push(`      Error: ${r.error}`);
+      } else {
+        lines.push(`FAIL  ${r.href} → ${r.status}`);
+      }
+    }
+    lines.push("");
+  }
+
+  // Redirect chains
+  if (redirected.length > 0) {
+    lines.push("--- Redirect Chains ---", "");
+    for (const r of redirected) {
+      const hops = r.redirectChain.length - 1;
+      const chainStr = r.redirectChain.map((h) => `${h.status}`).join(" → ");
+      lines.push(`REDIRECT  ${r.href}`);
+      lines.push(`          ${chainStr} → ${r.finalUrl} (${hops} hop${hops > 1 ? "s" : ""})`);
+    }
+    lines.push("");
+  }
+
+  return lines.join("\n");
+}