@pseolint/core 0.4.3 → 0.5.3

package/dist/ai/tools/check-indexability.js

@@ -0,0 +1,64 @@
+import { z } from "zod";
+import { parseHtmlPage } from "../../parser.js";
+import { resolvePage } from "../orchestrator/page-cache.js";
+import { defineTool } from "./types.js";
+const inputSchema = z.object({
+    pageId: z.string().describe("Page reference returned by fetch_page."),
+    xRobotsTagHeader: z
+        .string()
+        .optional()
+        .describe("Value of the X-Robots-Tag HTTP response header (if present). The orchestrator should pull this from the fetch_page result's `headers['x-robots-tag']`."),
+});
+const outputSchema = z.object({
+    url: z.string(),
+    indexable: z.boolean().describe("Final indexability verdict combining meta robots, X-Robots-Tag, and canonical."),
+    reasons: z.array(z.string()).describe("Reasons the page is non-indexable, when applicable."),
+    metaRobots: z.string(),
+    metaNoindex: z.boolean(),
+    xRobotsNoindex: z.boolean(),
+    canonicalUrl: z.string(),
+    canonicalSelfReferencing: z.boolean(),
+});
+function parseRobotsDirectives(value) {
+    const lower = value.toLowerCase();
+    return {
+        noindex: /\bnoindex\b|\bnone\b/.test(lower),
+        nofollow: /\bnofollow\b|\bnone\b/.test(lower),
+    };
+}
+export const checkIndexabilityTool = defineTool({
+    name: "check_indexability",
+    description: "Determine whether a previously-fetched page is indexable by search engines. Combines <meta name=robots>, X-Robots-Tag (pass from fetch_page response headers), and canonical signals. Returns `indexable: false` with reasons when noindex or non-self-referencing canonical is present. Call this near the top of any per-page audit — non-indexable pages don't need rule checks.",
+    inputSchema,
+    outputSchema,
+    async execute({ pageId, xRobotsTagHeader }) {
+        const entry = resolvePage(pageId);
+        const parsed = parseHtmlPage(entry.html, entry.url);
+        // If the caller didn't pass X-Robots-Tag, pull it from the cached fetch
+        // headers — saves the LLM a round-trip just to surface a header it
+        // already saw in fetch_page's output.
+        const xRobots = xRobotsTagHeader ?? entry.headers["x-robots-tag"] ?? "";
+        const reasons = [];
+        const meta = parseRobotsDirectives(parsed.robotsMeta);
+        if (meta.noindex)
+            reasons.push(`<meta name="robots"> contains noindex`);
+        const xRobotsParsed = xRobots ? parseRobotsDirectives(xRobots) : { noindex: false, nofollow: false };
+        if (xRobotsParsed.noindex)
+            reasons.push(`X-Robots-Tag header contains noindex`);
+        const canonicalSelfReferencing = parsed.canonical === parsed.url || parsed.canonical === "";
+        if (parsed.canonical && !canonicalSelfReferencing) {
+            reasons.push(`canonical points to ${parsed.canonical} (not self-referencing)`);
+        }
+        return {
+            url: parsed.url,
+            indexable: !meta.noindex && !xRobotsParsed.noindex && canonicalSelfReferencing,
+            reasons,
+            metaRobots: parsed.robotsMeta,
+            metaNoindex: meta.noindex,
+            xRobotsNoindex: xRobotsParsed.noindex,
+            canonicalUrl: parsed.canonical,
+            canonicalSelfReferencing,
+        };
+    },
+});
+//# sourceMappingURL=check-indexability.js.map

package/dist/ai/tools/check-indexability.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-indexability.js","sourceRoot":"","sources":["../../../src/ai/tools/check-indexability.ts"],"names":[],"mappings":"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"}

package/dist/ai/tools/check-robots.d.ts

@@ -0,0 +1,68 @@
+import { z } from "zod";
+/**
+ * General-purpose robots.txt fetch + parse + URL test. Wraps the existing
+ * `parseDisallowPatterns`, `isBlockedByPattern`, and `parseCrawlDelaySeconds`
+ * primitives. The AI-crawler-specific check lives in
+ * `check_domain_crawler_access`; this is the lower-level building block.
+ */
+export declare const checkRobotsTool: {
+    name: string;
+    description: string;
+    inputSchema: z.ZodType<{
+        origin: string;
+        testUrl?: string | undefined;
+        userAgent?: string | undefined;
+        timeoutMs?: number | undefined;
+    }, unknown, z.core.$ZodTypeInternals<{
+        origin: string;
+        testUrl?: string | undefined;
+        userAgent?: string | undefined;
+        timeoutMs?: number | undefined;
+    }, unknown>>;
+    outputSchema: z.ZodType<{
+        origin: string;
+        robotsTxtUrl: string;
+        robotsTxtPresent: boolean;
+        disallowPatterns: string[];
+        crawlDelaySeconds: number;
+        hasSitemapDirective: boolean;
+        testUrlBlocked: boolean | null;
+    }, unknown, z.core.$ZodTypeInternals<{
+        origin: string;
+        robotsTxtUrl: string;
+        robotsTxtPresent: boolean;
+        disallowPatterns: string[];
+        crawlDelaySeconds: number;
+        hasSitemapDirective: boolean;
+        testUrlBlocked: boolean | null;
+    }, unknown>>;
+    toAiTool(): import("ai").Tool<{
+        origin: string;
+        testUrl?: string | undefined;
+        userAgent?: string | undefined;
+        timeoutMs?: number | undefined;
+    }, import("./types.js").ToolResult<{
+        origin: string;
+        robotsTxtUrl: string;
+        robotsTxtPresent: boolean;
+        disallowPatterns: string[];
+        crawlDelaySeconds: number;
+        hasSitemapDirective: boolean;
+        testUrlBlocked: boolean | null;
+    }>>;
+    run(input: {
+        origin: string;
+        testUrl?: string | undefined;
+        userAgent?: string | undefined;
+        timeoutMs?: number | undefined;
+    }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
+        origin: string;
+        robotsTxtUrl: string;
+        robotsTxtPresent: boolean;
+        disallowPatterns: string[];
+        crawlDelaySeconds: number;
+        hasSitemapDirective: boolean;
+        testUrlBlocked: boolean | null;
+    }>>;
+};
+//# sourceMappingURL=check-robots.d.ts.map

package/dist/ai/tools/check-robots.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-robots.d.ts","sourceRoot":"","sources":["../../../src/ai/tools/check-robots.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAyCxB;;;;;GAKG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsD1B,CAAC"}

package/dist/ai/tools/check-robots.js

@@ -0,0 +1,90 @@
+import { z } from "zod";
+import { cachedFetch } from "../../cache.js";
+import { validateTargetHost } from "../../ssrf-guard.js";
+import { parseDisallowPatterns, isBlockedByPattern, parseCrawlDelaySeconds, } from "../../rules/tech/robots-sitemap-presence.js";
+import { defineTool } from "./types.js";
+const inputSchema = z.object({
+    origin: z
+        .string()
+        .url()
+        .describe("Site origin (e.g. https://example.com). The tool fetches /robots.txt."),
+    testUrl: z
+        .string()
+        .url()
+        .optional()
+        .describe("Optional URL to test against the robots.txt rules. Returns whether it would be blocked for the wildcard user agent."),
+    userAgent: z
+        .string()
+        .optional()
+        .describe("User agent to evaluate rules against. Default '*'. Pass 'GPTBot' / 'ClaudeBot' / 'PerplexityBot' to test AI-crawler-specific rules."),
+    timeoutMs: z.number().int().positive().max(15_000).optional(),
+});
+const outputSchema = z.object({
+    origin: z.string(),
+    robotsTxtUrl: z.string(),
+    robotsTxtPresent: z.boolean(),
+    disallowPatterns: z.array(z.string()),
+    crawlDelaySeconds: z.number().int().nonnegative(),
+    hasSitemapDirective: z.boolean(),
+    testUrlBlocked: z.boolean().nullable(),
+});
+/**
+ * General-purpose robots.txt fetch + parse + URL test. Wraps the existing
+ * `parseDisallowPatterns`, `isBlockedByPattern`, and `parseCrawlDelaySeconds`
+ * primitives. The AI-crawler-specific check lives in
+ * `check_domain_crawler_access`; this is the lower-level building block.
+ */
+export const checkRobotsTool = defineTool({
+    name: "check_robots",
+    description: "Fetch and parse a domain's robots.txt. Returns disallow patterns, crawl-delay, and whether a Sitemap directive is present. Pass `testUrl` to check whether a specific URL would be blocked for the named user agent (default '*'). Use this when the orchestrator needs to know if a candidate URL is fetchable before scheduling fetch_page.",
+    inputSchema,
+    outputSchema,
+    async execute({ origin, testUrl, userAgent = "*", timeoutMs = 10_000 }, ctx) {
+        const robotsUrl = `${new URL(origin).origin}/robots.txt`;
+        const validateHop = async (hopUrl) => {
+            let host;
+            try {
+                host = new URL(hopUrl).hostname;
+            }
+            catch {
+                throw new Error(`check_robots: invalid URL ${hopUrl}`);
+            }
+            await validateTargetHost(host);
+        };
+        let robotsTxtContent = "";
+        let robotsTxtPresent = false;
+        try {
+            const res = await cachedFetch(robotsUrl, { timeoutMs, cache: null, validateHop, signal: ctx?.signal });
+            if (res.status >= 200 && res.status < 300) {
+                robotsTxtContent = res.body;
+                robotsTxtPresent = true;
+            }
+        }
+        catch {
+            // robots.txt absent or unreachable — caller decides what to do.
+        }
+        const disallowPatterns = robotsTxtPresent ? parseDisallowPatterns(robotsTxtContent, [userAgent]) : [];
+        const crawlDelaySeconds = robotsTxtPresent ? parseCrawlDelaySeconds(robotsTxtContent) : 0;
+        const hasSitemapDirective = robotsTxtPresent && /^\s*sitemap\s*:/gim.test(robotsTxtContent);
+        let testUrlBlocked = null;
+        if (testUrl) {
+            try {
+                const path = new URL(testUrl).pathname || "/";
+                testUrlBlocked = disallowPatterns.some((p) => isBlockedByPattern(path, p));
+            }
+            catch {
+                testUrlBlocked = null;
+            }
+        }
+        return {
+            origin: new URL(origin).origin,
+            robotsTxtUrl: robotsUrl,
+            robotsTxtPresent,
+            disallowPatterns,
+            crawlDelaySeconds,
+            hasSitemapDirective,
+            testUrlBlocked,
+        };
+    },
+});
+//# sourceMappingURL=check-robots.js.map

package/dist/ai/tools/check-robots.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-robots.js","sourceRoot":"","sources":["../../../src/ai/tools/check-robots.ts"],"names":[],"mappings":"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"}

package/dist/ai/tools/check-rule-answer-first.d.ts

@@ -0,0 +1,54 @@
+import { z } from "zod";
+export declare const checkRuleAnswerFirstTool: {
+    name: string;
+    description: string;
+    inputSchema: z.ZodType<{
+        pageId: string;
+        maxFirstParagraphWords?: number | undefined;
+    }, unknown, z.core.$ZodTypeInternals<{
+        pageId: string;
+        maxFirstParagraphWords?: number | undefined;
+    }, unknown>>;
+    outputSchema: z.ZodType<{
+        finding: {
+            ruleId: "aeo/answer-first";
+            severity: "warning" | "error";
+            confidence: "high" | "medium" | "low" | "speculative";
+            message: string;
+            fix?: string | undefined;
+        } | null;
+    }, unknown, z.core.$ZodTypeInternals<{
+        finding: {
+            ruleId: "aeo/answer-first";
+            severity: "warning" | "error";
+            confidence: "high" | "medium" | "low" | "speculative";
+            message: string;
+            fix?: string | undefined;
+        } | null;
+    }, unknown>>;
+    toAiTool(): import("ai").Tool<{
+        pageId: string;
+        maxFirstParagraphWords?: number | undefined;
+    }, import("./types.js").ToolResult<{
+        finding: {
+            ruleId: "aeo/answer-first";
+            severity: "warning" | "error";
+            confidence: "high" | "medium" | "low" | "speculative";
+            message: string;
+            fix?: string | undefined;
+        } | null;
+    }>>;
+    run(input: {
+        pageId: string;
+        maxFirstParagraphWords?: number | undefined;
+    }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
+        finding: {
+            ruleId: "aeo/answer-first";
+            severity: "warning" | "error";
+            confidence: "high" | "medium" | "low" | "speculative";
+            message: string;
+            fix?: string | undefined;
+        } | null;
+    }>>;
+};
+//# sourceMappingURL=check-rule-answer-first.d.ts.map

package/dist/ai/tools/check-rule-answer-first.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-rule-answer-first.d.ts","sourceRoot":"","sources":["../../../src/ai/tools/check-rule-answer-first.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA6BxB,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwBnC,CAAC"}

package/dist/ai/tools/check-rule-answer-first.js

@@ -0,0 +1,50 @@
+import { z } from "zod";
+import { parseHtmlPage } from "../../parser.js";
+import { answerFirstRule } from "../../rules/aeo/answer-first.js";
+import { resolvePage } from "../orchestrator/page-cache.js";
+import { defineTool } from "./types.js";
+const inputSchema = z.object({
+    pageId: z.string().describe("Page reference returned by fetch_page."),
+    maxFirstParagraphWords: z
+        .number()
+        .int()
+        .positive()
+        .max(500)
+        .optional()
+        .describe("Opener should fit under this many words to count as extractable. Default 100."),
+});
+const outputSchema = z.object({
+    finding: z
+        .object({
+        ruleId: z.literal("aeo/answer-first"),
+        severity: z.enum(["warning", "error"]),
+        confidence: z.enum(["high", "medium", "low", "speculative"]),
+        message: z.string(),
+        fix: z.string().optional(),
+    })
+        .nullable(),
+});
+export const checkRuleAnswerFirstTool = defineTool({
+    name: "check_rule_answer_first",
+    description: "Check whether a previously-fetched page opens with a direct, extractable answer (concrete fact, named entity, complete sentence, <100 words). Critical for AI Overview / Perplexity citability. Returns a finding when the opener is boilerplate, too long, or lacks specifics. Note: cross-page template detection (same opener across N pages) is NOT done here — call this per page and aggregate identical openers yourself.",
+    inputSchema,
+    outputSchema,
+    async execute({ pageId, maxFirstParagraphWords = 100 }) {
+        const entry = resolvePage(pageId);
+        const parsed = parseHtmlPage(entry.html, entry.url);
+        const findings = answerFirstRule([parsed], [], { maxFirstParagraphWords });
+        const finding = findings[0];
+        return {
+            finding: finding
+                ? {
+                    ruleId: "aeo/answer-first",
+                    severity: finding.severity === "error" ? "error" : "warning",
+                    confidence: finding.confidence ?? "medium",
+                    message: finding.message,
+                    fix: finding.fix,
+                }
+                : null,
+        };
+    },
+});
+//# sourceMappingURL=check-rule-answer-first.js.map

package/dist/ai/tools/check-rule-answer-first.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-rule-answer-first.js","sourceRoot":"","sources":["../../../src/ai/tools/check-rule-answer-first.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAClE,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAC5D,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAExC,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC;IAC3B,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,wCAAwC,CAAC;IACrE,sBAAsB,EAAE,CAAC;SACtB,MAAM,EAAE;SACR,GAAG,EAAE;SACL,QAAQ,EAAE;SACV,GAAG,CAAC,GAAG,CAAC;SACR,QAAQ,EAAE;SACV,QAAQ,CAAC,+EAA+E,CAAC;CAC7F,CAAC,CAAC;AAEH,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC;IAC5B,OAAO,EAAE,CAAC;SACP,MAAM,CAAC;QACN,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,kBAAkB,CAAC;QACrC,QAAQ,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;QACtC,UAAU,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC;QAC5D,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;QACnB,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;KAC3B,CAAC;SACD,QAAQ,EAAE;CACd,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,wBAAwB,GAAG,UAAU,CAAC;IACjD,IAAI,EAAE,yBAAyB;IAC/B,WAAW,EACT,kaAAka;IACpa,WAAW;IACX,YAAY;IACZ,KAAK,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,sBAAsB,GAAG,GAAG,EAAE;QACpD,MAAM,KAAK,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC;QAClC,MAAM,MAAM,GAAG,aAAa,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;QACpD,MAAM,QAAQ,GAAG,eAAe,CAAC,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,EAAE,sBAAsB,EAAE,CAAC,CAAC;QAC3E,MAAM,OAAO,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;QAE5B,OAAO;YACL,OAAO,EAAE,OAAO;gBACd,CAAC,CAAC;oBACE,MAAM,EAAE,kBAA2B;oBACnC,QAAQ,EAAE,OAAO,CAAC,QAAQ,KAAK,OAAO,CAAC,CAAC,CAAE,OAAiB,CAAC,CAAC,CAAE,SAAmB;oBAClF,UAAU,EAAE,OAAO,CAAC,UAAU,IAAI,QAAQ;oBAC1C,OAAO,EAAE,OAAO,CAAC,OAAO;oBACxB,GAAG,EAAE,OAAO,CAAC,GAAG;iBACjB;gBACH,CAAC,CAAC,IAAI;SACT,CAAC;IACJ,CAAC;CACF,CAAC,CAAC"}

package/dist/ai/tools/check-rule-canonical-consistency.d.ts

@@ -0,0 +1,66 @@
+import { z } from "zod";
+export declare const checkRuleCanonicalConsistencyTool: {
+    name: string;
+    description: string;
+    inputSchema: z.ZodType<{
+        pageId: string;
+        knownUrls?: string[] | undefined;
+    }, unknown, z.core.$ZodTypeInternals<{
+        pageId: string;
+        knownUrls?: string[] | undefined;
+    }, unknown>>;
+    outputSchema: z.ZodType<{
+        hasCanonical: boolean;
+        canonicalUrl: string | null;
+        selfReferencing: boolean;
+        findings: {
+            ruleId: "tech/canonical-consistency";
+            severity: "info" | "warning" | "error" | "critical";
+            message: string;
+            fix?: string | undefined;
+            relatedUrls?: string[] | undefined;
+        }[];
+    }, unknown, z.core.$ZodTypeInternals<{
+        hasCanonical: boolean;
+        canonicalUrl: string | null;
+        selfReferencing: boolean;
+        findings: {
+            ruleId: "tech/canonical-consistency";
+            severity: "info" | "warning" | "error" | "critical";
+            message: string;
+            fix?: string | undefined;
+            relatedUrls?: string[] | undefined;
+        }[];
+    }, unknown>>;
+    toAiTool(): import("ai").Tool<{
+        pageId: string;
+        knownUrls?: string[] | undefined;
+    }, import("./types.js").ToolResult<{
+        hasCanonical: boolean;
+        canonicalUrl: string | null;
+        selfReferencing: boolean;
+        findings: {
+            ruleId: "tech/canonical-consistency";
+            severity: "info" | "warning" | "error" | "critical";
+            message: string;
+            fix?: string | undefined;
+            relatedUrls?: string[] | undefined;
+        }[];
+    }>>;
+    run(input: {
+        pageId: string;
+        knownUrls?: string[] | undefined;
+    }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
+        hasCanonical: boolean;
+        canonicalUrl: string | null;
+        selfReferencing: boolean;
+        findings: {
+            ruleId: "tech/canonical-consistency";
+            severity: "info" | "warning" | "error" | "critical";
+            message: string;
+            fix?: string | undefined;
+            relatedUrls?: string[] | undefined;
+        }[];
+    }>>;
+};
+//# sourceMappingURL=check-rule-canonical-consistency.d.ts.map

package/dist/ai/tools/check-rule-canonical-consistency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-rule-canonical-consistency.d.ts","sourceRoot":"","sources":["../../../src/ai/tools/check-rule-canonical-consistency.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAgCxB,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0B5C,CAAC"}

package/dist/ai/tools/check-rule-canonical-consistency.js

@@ -0,0 +1,51 @@
+import { z } from "zod";
+import { parseHtmlPage } from "../../parser.js";
+import { canonicalConsistencyRule } from "../../rules/tech/canonical-consistency.js";
+import { mergeNormalizeUrlOptions } from "../../url-normalize.js";
+import { resolvePage } from "../orchestrator/page-cache.js";
+import { defineTool } from "./types.js";
+const inputSchema = z.object({
+    pageId: z.string().describe("Page reference returned by fetch_page."),
+    knownUrls: z
+        .array(z.string())
+        .optional()
+        .describe("Other URLs already crawled in this audit. Lets the rule classify cross-page canonicalization severity (warning when canonical points to a known URL; info when it points outside)."),
+});
+const outputSchema = z.object({
+    hasCanonical: z.boolean(),
+    canonicalUrl: z.string().nullable(),
+    selfReferencing: z.boolean(),
+    findings: z.array(z.object({
+        ruleId: z.literal("tech/canonical-consistency"),
+        severity: z.enum(["info", "warning", "error", "critical"]),
+        message: z.string(),
+        fix: z.string().optional(),
+        relatedUrls: z.array(z.string()).optional(),
+    })),
+});
+export const checkRuleCanonicalConsistencyTool = defineTool({
+    name: "check_rule_canonical_consistency",
+    description: "Check the canonical tag on a previously-fetched page: missing, invalid, points to another crawled page, or HTTP-Link/HTML-link mismatch. Pass `knownUrls` (URLs crawled so far) to differentiate cross-page canonicals from external ones. Returns 0-2 findings depending on what's wrong.",
+    inputSchema,
+    outputSchema,
+    async execute({ pageId, knownUrls = [] }) {
+        const entry = resolvePage(pageId);
+        const parsed = parseHtmlPage(entry.html, entry.url);
+        const known = new Set(knownUrls);
+        const normalizeOpts = mergeNormalizeUrlOptions();
+        const findings = canonicalConsistencyRule([parsed], known, normalizeOpts);
+        return {
+            hasCanonical: parsed.canonical !== "",
+            canonicalUrl: parsed.canonical || null,
+            selfReferencing: parsed.canonical === parsed.url,
+            findings: findings.map((f) => ({
+                ruleId: "tech/canonical-consistency",
+                severity: f.severity,
+                message: f.message,
+                fix: f.fix,
+                relatedUrls: f.relatedUrls,
+            })),
+        };
+    },
+});
+//# sourceMappingURL=check-rule-canonical-consistency.js.map

package/dist/ai/tools/check-rule-canonical-consistency.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-rule-canonical-consistency.js","sourceRoot":"","sources":["../../../src/ai/tools/check-rule-canonical-consistency.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,wBAAwB,EAAE,MAAM,2CAA2C,CAAC;AACrF,OAAO,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAC;AAClE,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAC5D,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAExC,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC;IAC3B,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,wCAAwC,CAAC;IACrE,SAAS,EAAE,CAAC;SACT,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;SACjB,QAAQ,EAAE;SACV,QAAQ,CACP,oLAAoL,CACrL;CACJ,CAAC,CAAC;AAEH,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC;IAC5B,YAAY,EAAE,CAAC,CAAC,OAAO,EAAE;IACzB,YAAY,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACnC,eAAe,EAAE,CAAC,CAAC,OAAO,EAAE;IAC5B,QAAQ,EAAE,CAAC,CAAC,KAAK,CACf,CAAC,CAAC,MAAM,CAAC;QACP,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,4BAA4B,CAAC;QAC/C,QAAQ,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC;QAC1D,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;QACnB,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;QAC1B,WAAW,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE;KAC5C,CAAC,CACH;CACF,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,iCAAiC,GAAG,UAAU,CAAC;IAC1D,IAAI,EAAE,kCAAkC;IACxC,WAAW,EACT,4RAA4R;IAC9R,WAAW;IACX,YAAY;IACZ,KAAK,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,SAAS,GAAG,EAAE,EAAE;QACtC,MAAM,KAAK,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC;QAClC,MAAM,MAAM,GAAG,aAAa,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;QACpD,MAAM,KAAK,GAAG,IAAI,GAAG,CAAC,SAAS,CAAC,CAAC;QACjC,MAAM,aAAa,GAAG,wBAAwB,EAAE,CAAC;QACjD,MAAM,QAAQ,GAAG,wBAAwB,CAAC,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC;QAE1E,OAAO;YACL,YAAY,EAAE,MAAM,CAAC,SAAS,KAAK,EAAE;YACrC,YAAY,EAAE,MAAM,CAAC,SAAS,IAAI,IAAI;YACtC,eAAe,EAAE,MAAM,CAAC,SAAS,KAAK,MAAM,CAAC,GAAG;YAChD,QAAQ,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;gBAC7B,MAAM,EAAE,4BAAqC;gBAC7C,QAAQ,EAAE,CAAC,CAAC,QAAQ;gBACpB,OAAO,EAAE,CAAC,CAAC,OAAO;gBAClB,GAAG,EAAE,CAAC,CAAC,GAAG;gBACV,WAAW,EAAE,CAAC,CAAC,WAAW;aAC3B,CAAC,CAAC;SACJ,CAAC;IACJ,CAAC;CACF,CAAC,CAAC"}

package/dist/ai/tools/check-rule-citable-facts.d.ts

@@ -0,0 +1,58 @@
+import { z } from "zod";
+export declare const checkRuleCitableFactsTool: {
+    name: string;
+    description: string;
+    inputSchema: z.ZodType<{
+        pageIds: string[];
+        minFactsPerPage?: number | undefined;
+    }, unknown, z.core.$ZodTypeInternals<{
+        pageIds: string[];
+        minFactsPerPage?: number | undefined;
+    }, unknown>>;
+    outputSchema: z.ZodType<{
+        findings: {
+            ruleId: "aeo/citable-facts";
+            severity: "info" | "warning" | "error" | "critical";
+            message: string;
+            confidence?: "high" | "medium" | "low" | "speculative" | undefined;
+            pageUrl?: string | undefined;
+            fix?: string | undefined;
+        }[];
+    }, unknown, z.core.$ZodTypeInternals<{
+        findings: {
+            ruleId: "aeo/citable-facts";
+            severity: "info" | "warning" | "error" | "critical";
+            message: string;
+            confidence?: "high" | "medium" | "low" | "speculative" | undefined;
+            pageUrl?: string | undefined;
+            fix?: string | undefined;
+        }[];
+    }, unknown>>;
+    toAiTool(): import("ai").Tool<{
+        pageIds: string[];
+        minFactsPerPage?: number | undefined;
+    }, import("./types.js").ToolResult<{
+        findings: {
+            ruleId: "aeo/citable-facts";
+            severity: "info" | "warning" | "error" | "critical";
+            message: string;
+            confidence?: "high" | "medium" | "low" | "speculative" | undefined;
+            pageUrl?: string | undefined;
+            fix?: string | undefined;
+        }[];
+    }>>;
+    run(input: {
+        pageIds: string[];
+        minFactsPerPage?: number | undefined;
+    }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
+        findings: {
+            ruleId: "aeo/citable-facts";
+            severity: "info" | "warning" | "error" | "critical";
+            message: string;
+            confidence?: "high" | "medium" | "low" | "speculative" | undefined;
+            pageUrl?: string | undefined;
+            fix?: string | undefined;
+        }[];
+    }>>;
+};
+//# sourceMappingURL=check-rule-citable-facts.d.ts.map

package/dist/ai/tools/check-rule-citable-facts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-rule-citable-facts.d.ts","sourceRoot":"","sources":["../../../src/ai/tools/check-rule-citable-facts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAwBxB,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyBpC,CAAC"}

package/dist/ai/tools/check-rule-citable-facts.js

@@ -0,0 +1,41 @@
+import { z } from "zod";
+import { parseHtmlPage } from "../../parser.js";
+import { citableFactsRule } from "../../rules/aeo/citable-facts.js";
+import { resolvePages } from "../orchestrator/page-cache.js";
+import { defineTool } from "./types.js";
+const inputSchema = z.object({
+    pageIds: z.array(z.string()).min(1).max(50).describe("Page references from fetch_page."),
+    minFactsPerPage: z.number().int().nonnegative().max(20).optional(),
+});
+const outputSchema = z.object({
+    findings: z.array(z.object({
+        ruleId: z.literal("aeo/citable-facts"),
+        severity: z.enum(["info", "warning", "error", "critical"]),
+        confidence: z.enum(["high", "medium", "low", "speculative"]).optional(),
+        message: z.string(),
+        pageUrl: z.string().optional(),
+        fix: z.string().optional(),
+    })),
+});
+export const checkRuleCitableFactsTool = defineTool({
+    name: "check_rule_citable_facts",
+    description: "Count citable facts (numbers, dates, percentages, dollar amounts, named entities) per page. Pages with too few quotable specifics get skipped by AI Overview / Perplexity / ChatGPT for citation. Default threshold is 3 facts per page.",
+    inputSchema,
+    outputSchema,
+    async execute({ pageIds, minFactsPerPage }) {
+        const entries = resolvePages(pageIds);
+        const parsed = entries.map((e) => parseHtmlPage(e.html, e.url));
+        const findings = citableFactsRule(parsed, [], minFactsPerPage !== undefined ? { minFactsPerPage } : undefined);
+        return {
+            findings: findings.map((f) => ({
+                ruleId: "aeo/citable-facts",
+                severity: f.severity,
+                confidence: f.confidence,
+                message: f.message,
+                pageUrl: f.pageUrl,
+                fix: f.fix,
+            })),
+        };
+    },
+});
+//# sourceMappingURL=check-rule-citable-facts.js.map

package/dist/ai/tools/check-rule-citable-facts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-rule-citable-facts.js","sourceRoot":"","sources":["../../../src/ai/tools/check-rule-citable-facts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACpE,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAC7D,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAExC,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC;IAC3B,OAAO,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,kCAAkC,CAAC;IACxF,eAAe,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,QAAQ,EAAE;CACnE,CAAC,CAAC;AAEH,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC;IAC5B,QAAQ,EAAE,CAAC,CAAC,KAAK,CACf,CAAC,CAAC,MAAM,CAAC;QACP,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,mBAAmB,CAAC;QACtC,QAAQ,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC;QAC1D,UAAU,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,QAAQ,EAAE;QACvE,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;QACnB,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;QAC9B,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;KAC3B,CAAC,CACH;CACF,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,yBAAyB,GAAG,UAAU,CAAC;IAClD,IAAI,EAAE,0BAA0B;IAChC,WAAW,EACT,0OAA0O;IAC5O,WAAW;IACX,YAAY;IACZ,KAAK,CAAC,OAAO,CAAC,EAAE,OAAO,EAAE,eAAe,EAAE;QACxC,MAAM,OAAO,GAAG,YAAY,CAAC,OAAO,CAAC,CAAC;QACtC,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;QAChE,MAAM,QAAQ,GAAG,gBAAgB,CAC/B,MAAM,EACN,EAAE,EACF,eAAe,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,eAAe,EAAE,CAAC,CAAC,CAAC,SAAS,CAChE,CAAC;QACF,OAAO;YACL,QAAQ,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;gBAC7B,MAAM,EAAE,mBAA4B;gBACpC,QAAQ,EAAE,CAAC,CAAC,QAAQ;gBACpB,UAAU,EAAE,CAAC,CAAC,UAAU;gBACxB,OAAO,EAAE,CAAC,CAAC,OAAO;gBAClB,OAAO,EAAE,CAAC,CAAC,OAAO;gBAClB,GAAG,EAAE,CAAC,CAAC,GAAG;aACX,CAAC,CAAC;SACJ,CAAC;IACJ,CAAC;CACF,CAAC,CAAC"}

package/dist/ai/tools/check-rule-content-modularity.d.ts

@@ -0,0 +1,58 @@
+import { z } from "zod";
+export declare const checkRuleContentModularityTool: {
+    name: string;
+    description: string;
+    inputSchema: z.ZodType<{
+        pageIds: string[];
+        maxParagraphWords?: number | undefined;
+        minSelfContainedRatio?: number | undefined;
+    }, unknown, z.core.$ZodTypeInternals<{
+        pageIds: string[];
+        maxParagraphWords?: number | undefined;
+        minSelfContainedRatio?: number | undefined;
+    }, unknown>>;
+    outputSchema: z.ZodType<{
+        findings: {
+            ruleId: "aeo/content-modularity";
+            severity: "info" | "warning" | "error" | "critical";
+            message: string;
+            pageUrl?: string | undefined;
+            fix?: string | undefined;
+        }[];
+    }, unknown, z.core.$ZodTypeInternals<{
+        findings: {
+            ruleId: "aeo/content-modularity";
+            severity: "info" | "warning" | "error" | "critical";
+            message: string;
+            pageUrl?: string | undefined;
+            fix?: string | undefined;
+        }[];
+    }, unknown>>;
+    toAiTool(): import("ai").Tool<{
+        pageIds: string[];
+        maxParagraphWords?: number | undefined;
+        minSelfContainedRatio?: number | undefined;
+    }, import("./types.js").ToolResult<{
+        findings: {
+            ruleId: "aeo/content-modularity";
+            severity: "info" | "warning" | "error" | "critical";
+            message: string;
+            pageUrl?: string | undefined;
+            fix?: string | undefined;
+        }[];
+    }>>;
+    run(input: {
+        pageIds: string[];
+        maxParagraphWords?: number | undefined;
+        minSelfContainedRatio?: number | undefined;
+    }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
+        findings: {
+            ruleId: "aeo/content-modularity";
+            severity: "info" | "warning" | "error" | "critical";
+            message: string;
+            pageUrl?: string | undefined;
+            fix?: string | undefined;
+        }[];
+    }>>;
+};
+//# sourceMappingURL=check-rule-content-modularity.d.ts.map