@pseolint/core 0.4.1 → 0.5.3

package/dist/ai/tools/check-rule-required-fields.d.ts

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

package/dist/ai/tools/check-rule-required-fields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-rule-required-fields.d.ts","sourceRoot":"","sources":["../../../src/ai/tools/check-rule-required-fields.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAsBxB,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoBtC,CAAC"}

package/dist/ai/tools/check-rule-required-fields.js

@@ -0,0 +1,38 @@
+import { z } from "zod";
+import { parseHtmlPage } from "../../parser.js";
+import { requiredFieldsRule } from "../../rules/schema/required-fields.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."),
+});
+const outputSchema = z.object({
+    findings: z.array(z.object({
+        ruleId: z.literal("schema/required-fields"),
+        severity: z.enum(["info", "warning", "error", "critical"]),
+        message: z.string(),
+        pageUrl: z.string().optional(),
+        fix: z.string().optional(),
+    })),
+});
+export const checkRuleRequiredFieldsTool = defineTool({
+    name: "check_rule_required_fields",
+    description: "For each JSON-LD block declaring an @type on the referenced pages, verify required Schema.org properties are present (Article: headline/datePublished/author; Product: name/offers; FAQPage: mainEntity; etc.). Flags missing fields per page so the orchestrator can propose `add_jsonld` patches with the correct shape.",
+    inputSchema,
+    outputSchema,
+    async execute({ pageIds }) {
+        const entries = resolvePages(pageIds);
+        const parsed = entries.map((e) => parseHtmlPage(e.html, e.url));
+        const findings = requiredFieldsRule(parsed);
+        return {
+            findings: findings.map((f) => ({
+                ruleId: "schema/required-fields",
+                severity: f.severity,
+                message: f.message,
+                pageUrl: f.pageUrl,
+                fix: f.fix,
+            })),
+        };
+    },
+});
+//# sourceMappingURL=check-rule-required-fields.js.map

package/dist/ai/tools/check-rule-required-fields.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-rule-required-fields.js","sourceRoot":"","sources":["../../../src/ai/tools/check-rule-required-fields.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,kBAAkB,EAAE,MAAM,uCAAuC,CAAC;AAC3E,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;CACzF,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,2BAA2B,GAAG,UAAU,CAAC;IACpD,IAAI,EAAE,4BAA4B;IAClC,WAAW,EACT,4TAA4T;IAC9T,WAAW;IACX,YAAY;IACZ,KAAK,CAAC,OAAO,CAAC,EAAE,OAAO,EAAE;QACvB,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,kBAAkB,CAAC,MAAM,CAAC,CAAC;QAC5C,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-schema-consistency.d.ts

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

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

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

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

@@ -0,0 +1,44 @@
+import { z } from "zod";
+import { parseHtmlPage } from "../../parser.js";
+import { schemaConsistencyRule } from "../../rules/schema/consistency.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("Min 2 pageIds — consistency only makes sense across a sample."),
+});
+const outputSchema = z.object({
+    findings: z.array(z.object({
+        ruleId: z.literal("schema/consistency"),
+        severity: z.enum(["info", "warning", "error", "critical"]),
+        message: z.string(),
+        pageUrl: z.string().optional(),
+        relatedUrls: z.array(z.string()).optional(),
+        fix: z.string().optional(),
+    })),
+});
+export const checkRuleSchemaConsistencyTool = defineTool({
+    name: "check_rule_schema_consistency",
+    description: "Detect JSON-LD @type mismatches across a page sample (e.g. most /city/* pages declare Place+Service but a few drop Service). Min 2 pageIds — pass a representative sample of one template at a time for the cleanest signal.",
+    inputSchema,
+    outputSchema,
+    async execute({ pageIds }) {
+        const entries = resolvePages(pageIds);
+        const parsed = entries.map((e) => parseHtmlPage(e.html, e.url));
+        const findings = schemaConsistencyRule(parsed);
+        return {
+            findings: findings.map((f) => ({
+                ruleId: "schema/consistency",
+                severity: f.severity,
+                message: f.message,
+                pageUrl: f.pageUrl,
+                relatedUrls: f.relatedUrls,
+                fix: f.fix,
+            })),
+        };
+    },
+});
+//# sourceMappingURL=check-rule-schema-consistency.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"check-rule-schema-consistency.js","sourceRoot":"","sources":["../../../src/ai/tools/check-rule-schema-consistency.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,mCAAmC,CAAC;AAC1E,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;SACP,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;SACjB,GAAG,CAAC,CAAC,CAAC;SACN,GAAG,CAAC,EAAE,CAAC;SACP,QAAQ,CAAC,+DAA+D,CAAC;CAC7E,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,oBAAoB,CAAC;QACvC,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,WAAW,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE;QAC3C,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,8NAA8N;IAChO,WAAW;IACX,YAAY;IACZ,KAAK,CAAC,OAAO,CAAC,EAAE,OAAO,EAAE;QACvB,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,qBAAqB,CAAC,MAAM,CAAC,CAAC;QAC/C,OAAO;YACL,QAAQ,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;gBAC7B,MAAM,EAAE,oBAA6B;gBACrC,QAAQ,EAAE,CAAC,CAAC,QAAQ;gBACpB,OAAO,EAAE,CAAC,CAAC,OAAO;gBAClB,OAAO,EAAE,CAAC,CAAC,OAAO;gBAClB,WAAW,EAAE,CAAC,CAAC,WAAW;gBAC1B,GAAG,EAAE,CAAC,CAAC,GAAG;aACX,CAAC,CAAC;SACJ,CAAC;IACJ,CAAC;CACF,CAAC,CAAC"}

package/dist/ai/tools/check-rule-summary-bait.d.ts

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

package/dist/ai/tools/check-rule-summary-bait.d.ts.map

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

package/dist/ai/tools/check-rule-summary-bait.js

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import { parseHtmlPage } from "../../parser.js";
+import { summaryBaitRule } from "../../rules/aeo/summary-bait.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."),
+    openerWordCount: z.number().int().positive().max(500).optional(),
+});
+const outputSchema = z.object({
+    findings: z.array(z.object({
+        ruleId: z.literal("aeo/summary-bait"),
+        severity: z.enum(["info", "warning", "error", "critical"]),
+        message: z.string(),
+        pageUrl: z.string().optional(),
+        fix: z.string().optional(),
+    })),
+});
+export const checkRuleSummaryBaitTool = defineTool({
+    name: "check_rule_summary_bait",
+    description: "Detect 'summary bait' openers — content that withholds the answer to extract a scroll/click instead of resolving the query. AI engines preferentially cite pages that answer in the opener. Pass at least 3 pages so the rule can detect templated bait patterns across a sample.",
+    inputSchema,
+    outputSchema,
+    async execute({ pageIds, openerWordCount }) {
+        const entries = resolvePages(pageIds);
+        const parsed = entries.map((e) => parseHtmlPage(e.html, e.url));
+        const findings = summaryBaitRule(parsed, [], openerWordCount !== undefined ? { openerWordCount } : undefined);
+        return {
+            findings: findings.map((f) => ({
+                ruleId: "aeo/summary-bait",
+                severity: f.severity,
+                message: f.message,
+                pageUrl: f.pageUrl,
+                fix: f.fix,
+            })),
+        };
+    },
+});
+//# sourceMappingURL=check-rule-summary-bait.js.map

package/dist/ai/tools/check-rule-summary-bait.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-rule-summary-bait.js","sourceRoot":"","sources":["../../../src/ai/tools/check-rule-summary-bait.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,eAAe,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE;CACjE,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,mRAAmR;IACrR,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,eAAe,CAC9B,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,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-thin-content.d.ts

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

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

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

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

@@ -0,0 +1,58 @@
+import { z } from "zod";
+import { parseHtmlPage } from "../../parser.js";
+import { thinContentRule } from "../../rules/spam/thin-content.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."),
+    minWords: z
+        .number()
+        .int()
+        .positive()
+        .max(5000)
+        .optional()
+        .describe("Threshold for thin content. Default 300 (matches v0.4 engine default)."),
+});
+const outputSchema = z.object({
+    isThin: z.boolean(),
+    wordCount: z.number().int().nonnegative(),
+    threshold: z.number().int().positive(),
+    finding: z
+        .object({
+        ruleId: z.literal("spam/thin-content"),
+        severity: z.literal("error"),
+        confidence: z.enum(["high", "medium", "low", "speculative"]),
+        message: z.string(),
+        fix: z.string().optional(),
+    })
+        .nullable(),
+});
+const DEFAULT_MIN_WORDS = 300;
+export const checkRuleThinContentTool = defineTool({
+    name: "check_rule_thin_content",
+    description: "Check if a single page (referenced by pageId from fetch_page) is thin content (fewer than N words of substantive copy). Returns the word count, threshold, and the finding object if thin. Default threshold 300 words; lower it (e.g. 150) for landing-page-style sites to reduce false positives.",
+    inputSchema,
+    outputSchema,
+    async execute({ pageId, minWords = DEFAULT_MIN_WORDS }) {
+        const entry = resolvePage(pageId);
+        const parsed = parseHtmlPage(entry.html, entry.url);
+        const { findings } = thinContentRule([parsed], minWords);
+        const wordCount = parsed.contentText.split(/\s+/).filter(Boolean).length;
+        const finding = findings[0];
+        return {
+            isThin: findings.length > 0,
+            wordCount,
+            threshold: minWords,
+            finding: finding
+                ? {
+                    ruleId: "spam/thin-content",
+                    severity: "error",
+                    confidence: finding.confidence ?? "high",
+                    message: finding.message,
+                    fix: finding.fix,
+                }
+                : null,
+        };
+    },
+});
+//# sourceMappingURL=check-rule-thin-content.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"check-rule-thin-content.js","sourceRoot":"","sources":["../../../src/ai/tools/check-rule-thin-content.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,kCAAkC,CAAC;AACnE,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,QAAQ,EAAE,CAAC;SACR,MAAM,EAAE;SACR,GAAG,EAAE;SACL,QAAQ,EAAE;SACV,GAAG,CAAC,IAAI,CAAC;SACT,QAAQ,EAAE;SACV,QAAQ,CAAC,wEAAwE,CAAC;CACtF,CAAC,CAAC;AAEH,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC;IAC5B,MAAM,EAAE,CAAC,CAAC,OAAO,EAAE;IACnB,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE;IACzC,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE;IACtC,OAAO,EAAE,CAAC;SACP,MAAM,CAAC;QACN,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,mBAAmB,CAAC;QACtC,QAAQ,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC;QAC5B,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,iBAAiB,GAAG,GAAG,CAAC;AAE9B,MAAM,CAAC,MAAM,wBAAwB,GAAG,UAAU,CAAC;IACjD,IAAI,EAAE,yBAAyB;IAC/B,WAAW,EACT,qSAAqS;IACvS,WAAW;IACX,YAAY;IACZ,KAAK,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,QAAQ,GAAG,iBAAiB,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,EAAE,QAAQ,EAAE,GAAG,eAAe,CAAC,CAAC,MAAM,CAAC,EAAE,QAAQ,CAAC,CAAC;QACzD,MAAM,SAAS,GAAG,MAAM,CAAC,WAAW,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC;QAEzE,MAAM,OAAO,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;QAC5B,OAAO;YACL,MAAM,EAAE,QAAQ,CAAC,MAAM,GAAG,CAAC;YAC3B,SAAS;YACT,SAAS,EAAE,QAAQ;YACnB,OAAO,EAAE,OAAO;gBACd,CAAC,CAAC;oBACE,MAAM,EAAE,mBAA4B;oBACpC,QAAQ,EAAE,OAAgB;oBAC1B,UAAU,EAAE,OAAO,CAAC,UAAU,IAAI,MAAM;oBACxC,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/detect-templates.d.ts

@@ -0,0 +1,60 @@
+import { z } from "zod";
+/**
+ * Group URLs into template clusters. Wraps `clusterUrlTemplates` from the
+ * site classifier. Lets the orchestrator decide where to focus sampling —
+ * high-ratio templates (e.g. 80% of URLs share `/city/:slug`) deserve
+ * deeper inspection than long-tail one-offs.
+ */
+export declare const detectTemplatesTool: {
+    name: string;
+    description: string;
+    inputSchema: z.ZodType<{
+        urls: string[];
+        minRatio?: number | undefined;
+    }, unknown, z.core.$ZodTypeInternals<{
+        urls: string[];
+        minRatio?: number | undefined;
+    }, unknown>>;
+    outputSchema: z.ZodType<{
+        templateCount: number;
+        totalUrls: number;
+        templates: {
+            template: string;
+            count: number;
+            ratio: number;
+        }[];
+    }, unknown, z.core.$ZodTypeInternals<{
+        templateCount: number;
+        totalUrls: number;
+        templates: {
+            template: string;
+            count: number;
+            ratio: number;
+        }[];
+    }, unknown>>;
+    toAiTool(): import("ai").Tool<{
+        urls: string[];
+        minRatio?: number | undefined;
+    }, import("./types.js").ToolResult<{
+        templateCount: number;
+        totalUrls: number;
+        templates: {
+            template: string;
+            count: number;
+            ratio: number;
+        }[];
+    }>>;
+    run(input: {
+        urls: string[];
+        minRatio?: number | undefined;
+    }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
+        templateCount: number;
+        totalUrls: number;
+        templates: {
+            template: string;
+            count: number;
+            ratio: number;
+        }[];
+    }>>;
+};
+//# sourceMappingURL=detect-templates.d.ts.map

package/dist/ai/tools/detect-templates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect-templates.d.ts","sourceRoot":"","sources":["../../../src/ai/tools/detect-templates.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA0BxB;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAe9B,CAAC"}

package/dist/ai/tools/detect-templates.js

@@ -0,0 +1,43 @@
+import { z } from "zod";
+import { clusterUrlTemplates } from "../../site-classifier.js";
+import { defineTool } from "./types.js";
+const inputSchema = z.object({
+    urls: z.array(z.string()).min(1).describe("URL list, typically from fetch_sitemap."),
+    minRatio: z
+        .number()
+        .min(0)
+        .max(1)
+        .optional()
+        .describe("Drop templates that account for less than this fraction of URLs. Default 0.01 (1%)."),
+});
+const outputSchema = z.object({
+    templateCount: z.number().int().nonnegative(),
+    totalUrls: z.number().int().nonnegative(),
+    templates: z.array(z.object({
+        template: z.string().describe("Generalized URL pattern, e.g. '/city/:slug'."),
+        count: z.number().int().nonnegative(),
+        ratio: z.number().min(0).max(1),
+    })),
+});
+/**
+ * Group URLs into template clusters. Wraps `clusterUrlTemplates` from the
+ * site classifier. Lets the orchestrator decide where to focus sampling —
+ * high-ratio templates (e.g. 80% of URLs share `/city/:slug`) deserve
+ * deeper inspection than long-tail one-offs.
+ */
+export const detectTemplatesTool = defineTool({
+    name: "detect_templates",
+    description: "Group a URL list into template clusters (e.g. 80% of URLs share '/city/:slug', 5% share '/blog/:slug'). Returns templates sorted by descending count with the ratio of URLs each represents. Use this after fetch_sitemap to identify which template patterns dominate the site, then use sample_template to pull representative pages from each.",
+    inputSchema,
+    outputSchema,
+    async execute({ urls, minRatio = 0.01 }) {
+        const clustered = clusterUrlTemplates(urls);
+        const filtered = clustered.filter((t) => t.ratio >= minRatio);
+        return {
+            templateCount: filtered.length,
+            totalUrls: urls.length,
+            templates: filtered,
+        };
+    },
+});
+//# sourceMappingURL=detect-templates.js.map

package/dist/ai/tools/detect-templates.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect-templates.js","sourceRoot":"","sources":["../../../src/ai/tools/detect-templates.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAExC,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC;IAC3B,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,yCAAyC,CAAC;IACpF,QAAQ,EAAE,CAAC;SACR,MAAM,EAAE;SACR,GAAG,CAAC,CAAC,CAAC;SACN,GAAG,CAAC,CAAC,CAAC;SACN,QAAQ,EAAE;SACV,QAAQ,CAAC,qFAAqF,CAAC;CACnG,CAAC,CAAC;AAEH,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC;IAC5B,aAAa,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE;IAC7C,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE;IACzC,SAAS,EAAE,CAAC,CAAC,KAAK,CAChB,CAAC,CAAC,MAAM,CAAC;QACP,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,8CAA8C,CAAC;QAC7E,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE;QACrC,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;KAChC,CAAC,CACH;CACF,CAAC,CAAC;AAEH;;;;;GAKG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,UAAU,CAAC;IAC5C,IAAI,EAAE,kBAAkB;IACxB,WAAW,EACT,mVAAmV;IACrV,WAAW;IACX,YAAY;IACZ,KAAK,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,QAAQ,GAAG,IAAI,EAAE;QACrC,MAAM,SAAS,GAAG,mBAAmB,CAAC,IAAI,CAAC,CAAC;QAC5C,MAAM,QAAQ,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,IAAI,QAAQ,CAAC,CAAC;QAC9D,OAAO;YACL,aAAa,EAAE,QAAQ,CAAC,MAAM;YAC9B,SAAS,EAAE,IAAI,CAAC,MAAM;YACtB,SAAS,EAAE,QAAQ;SACpB,CAAC;IACJ,CAAC;CACF,CAAC,CAAC"}

package/dist/ai/tools/fetch-page.d.ts

@@ -0,0 +1,70 @@
+import { z } from "zod";
+/**
+ * SSRF-guarded HTTP fetch with optional disk cache. Wraps the existing
+ * `cachedFetch` primitive plus `validateTargetHost` so private/reserved IPs
+ * are rejected on every redirect hop.
+ *
+ * Returned as a tool to the orchestrator — typically the first call the
+ * model makes when auditing a domain.
+ */
+export declare const fetchPageTool: {
+    name: string;
+    description: string;
+    inputSchema: z.ZodType<{
+        url: string;
+        timeoutMs?: number | undefined;
+        cacheDir?: string | undefined;
+        cacheTtlMs?: number | undefined;
+    }, unknown, z.core.$ZodTypeInternals<{
+        url: string;
+        timeoutMs?: number | undefined;
+        cacheDir?: string | undefined;
+        cacheTtlMs?: number | undefined;
+    }, unknown>>;
+    outputSchema: z.ZodType<{
+        url: string;
+        status: number;
+        headers: Record<string, string>;
+        pageId: string;
+        bodyExcerpt: string;
+        fromCache: boolean;
+        bodyBytes: number;
+    }, unknown, z.core.$ZodTypeInternals<{
+        url: string;
+        status: number;
+        headers: Record<string, string>;
+        pageId: string;
+        bodyExcerpt: string;
+        fromCache: boolean;
+        bodyBytes: number;
+    }, unknown>>;
+    toAiTool(): import("ai").Tool<{
+        url: string;
+        timeoutMs?: number | undefined;
+        cacheDir?: string | undefined;
+        cacheTtlMs?: number | undefined;
+    }, import("./types.js").ToolResult<{
+        url: string;
+        status: number;
+        headers: Record<string, string>;
+        pageId: string;
+        bodyExcerpt: string;
+        fromCache: boolean;
+        bodyBytes: number;
+    }>>;
+    run(input: {
+        url: string;
+        timeoutMs?: number | undefined;
+        cacheDir?: string | undefined;
+        cacheTtlMs?: number | undefined;
+    }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
+        url: string;
+        status: number;
+        headers: Record<string, string>;
+        pageId: string;
+        bodyExcerpt: string;
+        fromCache: boolean;
+        bodyBytes: number;
+    }>>;
+};
+//# sourceMappingURL=fetch-page.d.ts.map

package/dist/ai/tools/fetch-page.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch-page.d.ts","sourceRoot":"","sources":["../../../src/ai/tools/fetch-page.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA8CxB;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+CxB,CAAC"}