@pseolint/core 0.4.3 → 0.5.4

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

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

package/dist/ai/tools/check-rule-content-modularity.js

@@ -0,0 +1,45 @@
+import { z } from "zod";
+import { parseHtmlPage } from "../../parser.js";
+import { contentModularityRule } from "../../rules/aeo/content-modularity.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."),
+    maxParagraphWords: z.number().int().positive().max(2000).optional(),
+    minSelfContainedRatio: z.number().min(0).max(1).optional(),
+});
+const outputSchema = z.object({
+    findings: z.array(z.object({
+        ruleId: z.literal("aeo/content-modularity"),
+        severity: z.enum(["info", "warning", "error", "critical"]),
+        message: z.string(),
+        pageUrl: z.string().optional(),
+        fix: z.string().optional(),
+    })),
+});
+export const checkRuleContentModularityTool = defineTool({
+    name: "check_rule_content_modularity",
+    description: "Check whether paragraphs are modular (short, self-contained, lift-able as standalone snippets). AI engines prefer to quote discrete blocks. Default thresholds: paragraphs <= 200 words, >= 70% self-contained.",
+    inputSchema,
+    outputSchema,
+    async execute({ pageIds, maxParagraphWords, minSelfContainedRatio }) {
+        const entries = resolvePages(pageIds);
+        const parsed = entries.map((e) => parseHtmlPage(e.html, e.url));
+        const opts = {};
+        if (maxParagraphWords !== undefined)
+            opts.maxParagraphWords = maxParagraphWords;
+        if (minSelfContainedRatio !== undefined)
+            opts.minSelfContainedRatio = minSelfContainedRatio;
+        const findings = contentModularityRule(parsed, opts);
+        return {
+            findings: findings.map((f) => ({
+                ruleId: "aeo/content-modularity",
+                severity: f.severity,
+                message: f.message,
+                pageUrl: f.pageUrl,
+                fix: f.fix,
+            })),
+        };
+    },
+});
+//# sourceMappingURL=check-rule-content-modularity.js.map

package/dist/ai/tools/check-rule-content-modularity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-rule-content-modularity.js","sourceRoot":"","sources":["../../../src/ai/tools/check-rule-content-modularity.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,qBAAqB,EAAE,MAAM,uCAAuC,CAAC;AAC9E,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,iBAAiB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE;IACnE,qBAAqB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE;CAC3D,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,wBAAwB,CAAC;QAC3C,QAAQ,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC;QAC1D,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,8BAA8B,GAAG,UAAU,CAAC;IACvD,IAAI,EAAE,+BAA+B;IACrC,WAAW,EACT,iNAAiN;IACnN,WAAW;IACX,YAAY;IACZ,KAAK,CAAC,OAAO,CAAC,EAAE,OAAO,EAAE,iBAAiB,EAAE,qBAAqB,EAAE;QACjE,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,IAAI,GAAmE,EAAE,CAAC;QAChF,IAAI,iBAAiB,KAAK,SAAS;YAAE,IAAI,CAAC,iBAAiB,GAAG,iBAAiB,CAAC;QAChF,IAAI,qBAAqB,KAAK,SAAS;YAAE,IAAI,CAAC,qBAAqB,GAAG,qBAAqB,CAAC;QAC5F,MAAM,QAAQ,GAAG,qBAAqB,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QACrD,OAAO;YACL,QAAQ,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;gBAC7B,MAAM,EAAE,wBAAiC;gBACzC,QAAQ,EAAE,CAAC,CAAC,QAAQ;gBACpB,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-faq-coverage.d.ts

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

package/dist/ai/tools/check-rule-faq-coverage.d.ts.map

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

package/dist/ai/tools/check-rule-faq-coverage.js

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import { parseHtmlPage } from "../../parser.js";
+import { faqCoverageRule } from "../../rules/aeo/faq-coverage.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."),
+    minQuestionHeadings: z.number().int().nonnegative().max(20).optional(),
+});
+const outputSchema = z.object({
+    findings: z.array(z.object({
+        ruleId: z.literal("aeo/faq-coverage"),
+        severity: z.enum(["info", "warning", "error", "critical"]),
+        message: z.string(),
+        pageUrl: z.string().optional(),
+        fix: z.string().optional(),
+    })),
+});
+export const checkRuleFaqCoverageTool = defineTool({
+    name: "check_rule_faq_coverage",
+    description: "Check whether FAQ-style pages have visible question headings that AI engines can quote. Pass pageIds for a sample of '/faq/*' or '/questions/*' URLs; returns warnings for pages that look like they should have Q&A structure but don't.",
+    inputSchema,
+    outputSchema,
+    async execute({ pageIds, minQuestionHeadings }) {
+        const entries = resolvePages(pageIds);
+        const parsed = entries.map((e) => parseHtmlPage(e.html, e.url));
+        const findings = faqCoverageRule(parsed, minQuestionHeadings !== undefined ? { minQuestionHeadings } : undefined);
+        return {
+            findings: findings.map((f) => ({
+                ruleId: "aeo/faq-coverage",
+                severity: f.severity,
+                message: f.message,
+                pageUrl: f.pageUrl,
+                fix: f.fix,
+            })),
+        };
+    },
+});
+//# sourceMappingURL=check-rule-faq-coverage.js.map

package/dist/ai/tools/check-rule-faq-coverage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-rule-faq-coverage.js","sourceRoot":"","sources":["../../../src/ai/tools/check-rule-faq-coverage.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,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,mBAAmB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,QAAQ,EAAE;CACvE,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,kBAAkB,CAAC;QACrC,QAAQ,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC;QAC1D,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,wBAAwB,GAAG,UAAU,CAAC;IACjD,IAAI,EAAE,yBAAyB;IAC/B,WAAW,EACT,2OAA2O;IAC7O,WAAW;IACX,YAAY;IACZ,KAAK,CAAC,OAAO,CAAC,EAAE,OAAO,EAAE,mBAAmB,EAAE;QAC5C,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,eAAe,CAC9B,MAAM,EACN,mBAAmB,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,mBAAmB,EAAE,CAAC,CAAC,CAAC,SAAS,CACxE,CAAC;QACF,OAAO;YACL,QAAQ,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;gBAC7B,MAAM,EAAE,kBAA2B;gBACnC,QAAQ,EAAE,CAAC,CAAC,QAAQ;gBACpB,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-freshness-signals.d.ts

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

package/dist/ai/tools/check-rule-freshness-signals.d.ts.map

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

package/dist/ai/tools/check-rule-freshness-signals.js

@@ -0,0 +1,45 @@
+import { z } from "zod";
+import { parseHtmlPage } from "../../parser.js";
+import { freshnessSignalsRule } from "../../rules/aeo/freshness-signals.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."),
+    maxStaleDays: z
+        .number()
+        .int()
+        .positive()
+        .max(3650)
+        .optional()
+        .describe("Max days since last update before flagging as stale. Default 180."),
+});
+const outputSchema = z.object({
+    findings: z.array(z.object({
+        ruleId: z.literal("aeo/freshness-signals"),
+        severity: z.enum(["info", "warning", "error", "critical"]),
+        message: z.string(),
+        pageUrl: z.string().optional(),
+        fix: z.string().optional(),
+    })),
+});
+export const checkRuleFreshnessSignalsTool = defineTool({
+    name: "check_rule_freshness_signals",
+    description: "Check pages for visible or structured freshness signals (datePublished / dateModified in JSON-LD, <time> elements, 'Updated YYYY' text). Flags pages older than maxStaleDays and pages missing any freshness signal.",
+    inputSchema,
+    outputSchema,
+    async execute({ pageIds, maxStaleDays }) {
+        const entries = resolvePages(pageIds);
+        const parsed = entries.map((e) => parseHtmlPage(e.html, e.url));
+        const findings = freshnessSignalsRule(parsed, maxStaleDays !== undefined ? { maxStaleDays } : undefined);
+        return {
+            findings: findings.map((f) => ({
+                ruleId: "aeo/freshness-signals",
+                severity: f.severity,
+                message: f.message,
+                pageUrl: f.pageUrl,
+                fix: f.fix,
+            })),
+        };
+    },
+});
+//# sourceMappingURL=check-rule-freshness-signals.js.map

package/dist/ai/tools/check-rule-freshness-signals.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-rule-freshness-signals.js","sourceRoot":"","sources":["../../../src/ai/tools/check-rule-freshness-signals.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,oBAAoB,EAAE,MAAM,sCAAsC,CAAC;AAC5E,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,YAAY,EAAE,CAAC;SACZ,MAAM,EAAE;SACR,GAAG,EAAE;SACL,QAAQ,EAAE;SACV,GAAG,CAAC,IAAI,CAAC;SACT,QAAQ,EAAE;SACV,QAAQ,CAAC,mEAAmE,CAAC;CACjF,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,uBAAuB,CAAC;QAC1C,QAAQ,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC;QAC1D,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,6BAA6B,GAAG,UAAU,CAAC;IACtD,IAAI,EAAE,8BAA8B;IACpC,WAAW,EACT,sNAAsN;IACxN,WAAW;IACX,YAAY;IACZ,KAAK,CAAC,OAAO,CAAC,EAAE,OAAO,EAAE,YAAY,EAAE;QACrC,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,oBAAoB,CACnC,MAAM,EACN,YAAY,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,CAAC,CAAC,SAAS,CAC1D,CAAC;QACF,OAAO;YACL,QAAQ,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;gBAC7B,MAAM,EAAE,uBAAgC;gBACxC,QAAQ,EAAE,CAAC,CAAC,QAAQ;gBACpB,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-json-ld-valid.d.ts

@@ -0,0 +1,54 @@
+import { z } from "zod";
+export declare const checkRuleJsonLdValidTool: {
+    name: string;
+    description: string;
+    inputSchema: z.ZodType<{
+        pageId: string;
+    }, unknown, z.core.$ZodTypeInternals<{
+        pageId: string;
+    }, unknown>>;
+    outputSchema: z.ZodType<{
+        jsonLdBlockCount: number;
+        hasParseError: boolean;
+        findings: {
+            ruleId: "schema/json-ld-valid";
+            severity: "error";
+            message: string;
+            fix?: string | undefined;
+        }[];
+    }, unknown, z.core.$ZodTypeInternals<{
+        jsonLdBlockCount: number;
+        hasParseError: boolean;
+        findings: {
+            ruleId: "schema/json-ld-valid";
+            severity: "error";
+            message: string;
+            fix?: string | undefined;
+        }[];
+    }, unknown>>;
+    toAiTool(): import("ai").Tool<{
+        pageId: string;
+    }, import("./types.js").ToolResult<{
+        jsonLdBlockCount: number;
+        hasParseError: boolean;
+        findings: {
+            ruleId: "schema/json-ld-valid";
+            severity: "error";
+            message: string;
+            fix?: string | undefined;
+        }[];
+    }>>;
+    run(input: {
+        pageId: string;
+    }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
+        jsonLdBlockCount: number;
+        hasParseError: boolean;
+        findings: {
+            ruleId: "schema/json-ld-valid";
+            severity: "error";
+            message: string;
+            fix?: string | undefined;
+        }[];
+    }>>;
+};
+//# sourceMappingURL=check-rule-json-ld-valid.d.ts.map

package/dist/ai/tools/check-rule-json-ld-valid.d.ts.map

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

package/dist/ai/tools/check-rule-json-ld-valid.js

@@ -0,0 +1,44 @@
+import { z } from "zod";
+import { parseHtmlPage } from "../../parser.js";
+import { jsonLdValidRule } from "../../rules/schema/json-ld-valid.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."),
+});
+const outputSchema = z.object({
+    jsonLdBlockCount: z.number().int().nonnegative(),
+    hasParseError: z.boolean(),
+    findings: z.array(z.object({
+        ruleId: z.literal("schema/json-ld-valid"),
+        severity: z.literal("error"),
+        message: z.string(),
+        fix: z.string().optional(),
+    })),
+});
+export const checkRuleJsonLdValidTool = defineTool({
+    name: "check_rule_json_ld_valid",
+    description: "Validate JSON-LD blocks on a previously-fetched page for parse errors, missing @context, and invalid @type values. Reports one finding per malformed block. For Schema.org-spec compliance (required properties per type), use validate_jsonld.",
+    inputSchema,
+    outputSchema,
+    async execute({ pageId }) {
+        const entry = resolvePage(pageId);
+        const parsed = parseHtmlPage(entry.html, entry.url);
+        const hasParseError = parsed.jsonLd.some((e) => typeof e === "object" &&
+            e !== null &&
+            "__parseError" in e &&
+            e.__parseError === true);
+        const findings = jsonLdValidRule([parsed]);
+        return {
+            jsonLdBlockCount: parsed.jsonLd.length,
+            hasParseError,
+            findings: findings.map((f) => ({
+                ruleId: "schema/json-ld-valid",
+                severity: "error",
+                message: f.message,
+                fix: f.fix,
+            })),
+        };
+    },
+});
+//# sourceMappingURL=check-rule-json-ld-valid.js.map

package/dist/ai/tools/check-rule-json-ld-valid.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-rule-json-ld-valid.js","sourceRoot":"","sources":["../../../src/ai/tools/check-rule-json-ld-valid.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,qCAAqC,CAAC;AACtE,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;CACtE,CAAC,CAAC;AAEH,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC;IAC5B,gBAAgB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE;IAChD,aAAa,EAAE,CAAC,CAAC,OAAO,EAAE;IAC1B,QAAQ,EAAE,CAAC,CAAC,KAAK,CACf,CAAC,CAAC,MAAM,CAAC;QACP,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,sBAAsB,CAAC;QACzC,QAAQ,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC;QAC5B,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;QACnB,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;KAC3B,CAAC,CACH;CACF,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,wBAAwB,GAAG,UAAU,CAAC;IACjD,IAAI,EAAE,0BAA0B;IAChC,WAAW,EACT,iPAAiP;IACnP,WAAW;IACX,YAAY;IACZ,KAAK,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE;QACtB,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,aAAa,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CACtC,CAAC,CAAC,EAAE,EAAE,CACJ,OAAO,CAAC,KAAK,QAAQ;YACrB,CAAC,KAAK,IAAI;YACV,cAAc,IAAI,CAAC;YAClB,CAA6B,CAAC,YAAY,KAAK,IAAI,CACvD,CAAC;QACF,MAAM,QAAQ,GAAG,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;QAE3C,OAAO;YACL,gBAAgB,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM;YACtC,aAAa;YACb,QAAQ,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;gBAC7B,MAAM,EAAE,sBAA+B;gBACvC,QAAQ,EAAE,OAAgB;gBAC1B,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-missing-author.d.ts

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

package/dist/ai/tools/check-rule-missing-author.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-rule-missing-author.d.ts","sourceRoot":"","sources":["../../../src/ai/tools/check-rule-missing-author.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAuBxB,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyBrC,CAAC"}

package/dist/ai/tools/check-rule-missing-author.js

@@ -0,0 +1,45 @@
+import { z } from "zod";
+import { parseHtmlPage } from "../../parser.js";
+import { missingAuthorRule } from "../../rules/content/missing-author.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."),
+});
+const outputSchema = z.object({
+    hasAuthorSignal: z.boolean(),
+    finding: z
+        .object({
+        ruleId: z.literal("content/missing-author"),
+        severity: z.literal("warning"),
+        confidence: z.enum(["high", "medium", "low", "speculative"]),
+        message: z.string(),
+        fix: z.string().optional(),
+    })
+        .nullable(),
+});
+export const checkRuleMissingAuthorTool = defineTool({
+    name: "check_rule_missing_author",
+    description: "Check if a previously-fetched page has any author attribution signal (meta[name=author], JSON-LD author, visible byline, rel=author link). Returns a warning finding when none are present. Severity is `warning` (not `error`) because docs/product/marketing pages legitimately ship without bylines — this matters most on blog/news content.",
+    inputSchema,
+    outputSchema,
+    async execute({ pageId }) {
+        const entry = resolvePage(pageId);
+        const parsed = parseHtmlPage(entry.html, entry.url);
+        const findings = missingAuthorRule([parsed]);
+        const finding = findings[0];
+        return {
+            hasAuthorSignal: findings.length === 0,
+            finding: finding
+                ? {
+                    ruleId: "content/missing-author",
+                    severity: "warning",
+                    confidence: finding.confidence ?? "medium",
+                    message: finding.message,
+                    fix: finding.fix,
+                }
+                : null,
+        };
+    },
+});
+//# sourceMappingURL=check-rule-missing-author.js.map

package/dist/ai/tools/check-rule-missing-author.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-rule-missing-author.js","sourceRoot":"","sources":["../../../src/ai/tools/check-rule-missing-author.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,iBAAiB,EAAE,MAAM,uCAAuC,CAAC;AAC1E,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;CACtE,CAAC,CAAC;AAEH,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC;IAC5B,eAAe,EAAE,CAAC,CAAC,OAAO,EAAE;IAC5B,OAAO,EAAE,CAAC;SACP,MAAM,CAAC;QACN,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,wBAAwB,CAAC;QAC3C,QAAQ,EAAE,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC;QAC9B,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,0BAA0B,GAAG,UAAU,CAAC;IACnD,IAAI,EAAE,2BAA2B;IACjC,WAAW,EACT,kVAAkV;IACpV,WAAW;IACX,YAAY;IACZ,KAAK,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE;QACtB,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,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;QAC7C,MAAM,OAAO,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;QAE5B,OAAO;YACL,eAAe,EAAE,QAAQ,CAAC,MAAM,KAAK,CAAC;YACtC,OAAO,EAAE,OAAO;gBACd,CAAC,CAAC;oBACE,MAAM,EAAE,wBAAiC;oBACzC,QAAQ,EAAE,SAAkB;oBAC5B,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-near-duplicate.d.ts

@@ -0,0 +1,82 @@
+import { z } from "zod";
+export declare const checkRuleNearDuplicateTool: {
+    name: string;
+    description: string;
+    inputSchema: z.ZodType<{
+        pageIds: string[];
+        threshold?: number | undefined;
+    }, unknown, z.core.$ZodTypeInternals<{
+        pageIds: string[];
+        threshold?: number | undefined;
+    }, unknown>>;
+    outputSchema: z.ZodType<{
+        pairCount: number;
+        pairs: {
+            leftUrl: string;
+            rightUrl: string;
+            similarity: number;
+        }[];
+        findings: {
+            ruleId: "spam/near-duplicate";
+            severity: "critical";
+            message: string;
+            pageUrl: string;
+            similarity: number;
+            relatedUrls?: string[] | undefined;
+        }[];
+    }, unknown, z.core.$ZodTypeInternals<{
+        pairCount: number;
+        pairs: {
+            leftUrl: string;
+            rightUrl: string;
+            similarity: number;
+        }[];
+        findings: {
+            ruleId: "spam/near-duplicate";
+            severity: "critical";
+            message: string;
+            pageUrl: string;
+            similarity: number;
+            relatedUrls?: string[] | undefined;
+        }[];
+    }, unknown>>;
+    toAiTool(): import("ai").Tool<{
+        pageIds: string[];
+        threshold?: number | undefined;
+    }, import("./types.js").ToolResult<{
+        pairCount: number;
+        pairs: {
+            leftUrl: string;
+            rightUrl: string;
+            similarity: number;
+        }[];
+        findings: {
+            ruleId: "spam/near-duplicate";
+            severity: "critical";
+            message: string;
+            pageUrl: string;
+            similarity: number;
+            relatedUrls?: string[] | undefined;
+        }[];
+    }>>;
+    run(input: {
+        pageIds: string[];
+        threshold?: number | undefined;
+    }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
+        pairCount: number;
+        pairs: {
+            leftUrl: string;
+            rightUrl: string;
+            similarity: number;
+        }[];
+        findings: {
+            ruleId: "spam/near-duplicate";
+            severity: "critical";
+            message: string;
+            pageUrl: string;
+            similarity: number;
+            relatedUrls?: string[] | undefined;
+        }[];
+    }>>;
+};
+//# sourceMappingURL=check-rule-near-duplicate.d.ts.map

package/dist/ai/tools/check-rule-near-duplicate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-rule-near-duplicate.d.ts","sourceRoot":"","sources":["../../../src/ai/tools/check-rule-near-duplicate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA2CxB,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BrC,CAAC"}

package/dist/ai/tools/check-rule-near-duplicate.js

@@ -0,0 +1,63 @@
+import { z } from "zod";
+import { parseHtmlPage } from "../../parser.js";
+import { nearDuplicateRule } from "../../rules/spam/near-duplicate.js";
+import { resolvePages } from "../orchestrator/page-cache.js";
+import { defineTool } from "./types.js";
+const inputSchema = z.object({
+    pageIds: z
+        .array(z.string())
+        .min(2)
+        .max(50)
+        .describe("Page references from fetch_page. Min 2, max 50 to bound O(n^2) work."),
+    threshold: z
+        .number()
+        .min(0)
+        .max(1)
+        .optional()
+        .describe("Minimum simhash similarity (0-1) to flag as near-duplicate. Default 0.85."),
+});
+const outputSchema = z.object({
+    pairCount: z.number().int().nonnegative(),
+    pairs: z.array(z.object({
+        leftUrl: z.string(),
+        rightUrl: z.string(),
+        similarity: z.number().min(0).max(1),
+    })),
+    findings: z.array(z.object({
+        ruleId: z.literal("spam/near-duplicate"),
+        severity: z.literal("critical"),
+        message: z.string(),
+        pageUrl: z.string(),
+        relatedUrls: z.array(z.string()).optional(),
+        similarity: z.number().min(0).max(1),
+    })),
+});
+const DEFAULT_THRESHOLD = 0.85;
+export const checkRuleNearDuplicateTool = defineTool({
+    name: "check_rule_near_duplicate",
+    description: "Detect near-duplicate page pairs across a sample (simhash + Hamming distance). Pass an array of pageIds (min 2, max 50). Returns each pair above the similarity threshold (default 0.85) plus a critical finding per pair. Use after sample_template + fetch_page to check whether template-instance pages are differentiated enough.",
+    inputSchema,
+    outputSchema,
+    async execute({ pageIds, threshold = DEFAULT_THRESHOLD }) {
+        const entries = resolvePages(pageIds);
+        const parsed = entries.map((e) => parseHtmlPage(e.html, e.url));
+        const { findings, pairs } = nearDuplicateRule(parsed, threshold);
+        return {
+            pairCount: pairs.length,
+            pairs: pairs.map((p) => ({
+                leftUrl: p.leftUrl,
+                rightUrl: p.rightUrl,
+                similarity: p.similarity,
+            })),
+            findings: findings.map((f) => ({
+                ruleId: "spam/near-duplicate",
+                severity: "critical",
+                message: f.message,
+                pageUrl: f.pageUrl ?? "",
+                relatedUrls: f.relatedUrls,
+                similarity: f.similarity ?? 0,
+            })),
+        };
+    },
+});
+//# sourceMappingURL=check-rule-near-duplicate.js.map

package/dist/ai/tools/check-rule-near-duplicate.js.map

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