mcp-scraper 0.4.5 → 0.4.12

package/dist/{chunk-WI4A3KFQ.js → chunk-6EXP6DQG.js}

@@ -17,7 +17,7 @@ import {
 } from "./chunk-XGIPATLV.js";
 import {
   PACKAGE_VERSION
-} from "./chunk-UGQC2FOX.js";
+} from "./chunk-SHXJQQOH.js";
 import {
   sanitizeVendorName
 } from "./chunk-M2S27J6Z.js";
@@ -1019,6 +1019,56 @@ ${headingSection}${kpoSection}${brandingSection}${bodySectionFull}${memSection}$
   }
   return { ...textResult, structuredContent };
 }
+var DIFF_PAGE_PREVIEW_HUNKS = 20;
+function formatDiffPage(raw, input) {
+  const parsed = parseData(raw);
+  if ("error" in parsed) return { content: [{ type: "text", text: parsed.error }], isError: true };
+  const d = parsed.data;
+  const url = d.url ?? input.url;
+  const title = d.title ?? "Untitled";
+  const statusLine = d.status === "baseline" ? d.isReset ? "\u{1F195} **Baseline reset** \u2014 prior history discarded, this check is now the new baseline." : "\u{1F195} **Baseline captured** \u2014 first check for this URL, nothing to compare yet." : d.status === "unchanged" ? `\u2705 **No changes** since ${d.previousCheckedAt ?? "the last check"}.` : `\u{1F504} **Changed** since ${d.previousCheckedAt ?? "the last check"} \u2014 +${d.summary.linesAdded}/-${d.summary.linesRemoved} lines (${d.summary.percentChanged ?? 0}% of content).`;
+  const previewHunks = d.hunks.slice(0, DIFF_PAGE_PREVIEW_HUNKS);
+  const diffBlock = previewHunks.length ? [
+    "\n## Diff",
+    "```diff",
+    ...previewHunks.flatMap((h) => h.lines.map((l) => `${h.type === "added" ? "+" : "-"} ${l}`)),
+    "```",
+    previewHunks.length < d.hunks.length ? `*(showing ${previewHunks.length} of ${d.hunks.length} returned hunks)*` : ""
+  ].filter(Boolean).join("\n") : "";
+  const truncationNotes = [
+    d.contentTruncated ? "\n\u26A0\uFE0F Page content exceeded the storable cap and was truncated before hashing/diffing \u2014 changes past that point are not visible to this comparison." : "",
+    d.hunksTruncatedReason ? `
+\u26A0\uFE0F ${d.hunksTruncatedReason}` : ""
+  ].filter(Boolean).join("\n");
+  const tips = `
+---
+\u{1F4A1} **Tips**
+- Call \`diff_page\` again anytime to re-check \u2014 this tool is on-demand, not automatic.
+- Want the page's current content with nothing to compare? use \`extract_url\`.`;
+  const full = `# Page Diff: ${url}
+**${title}**
+
+${statusLine}${diffBlock}${truncationNotes}${tips}`;
+  return {
+    ...oneBlock(full),
+    structuredContent: {
+      url,
+      title: d.title,
+      status: d.status,
+      isReset: d.isReset,
+      previousCheckedAt: d.previousCheckedAt,
+      currentCheckedAt: d.currentCheckedAt,
+      contentHash: d.contentHash,
+      previousContentHash: d.previousContentHash,
+      summary: d.summary,
+      hunks: d.hunks,
+      contentTruncated: d.contentTruncated,
+      hunksTruncated: d.hunksTruncated,
+      hunksTruncatedReason: d.hunksTruncatedReason,
+      totalChangedLineCount: d.totalChangedLineCount
+    }
+  };
+}
 async function formatMapSiteUrls(raw, input, ctx) {
   const parsed = parseData(raw);
   if ("error" in parsed) return { content: [{ type: "text", text: parsed.error }], isError: true };
@@ -2776,6 +2826,11 @@ var ExtractUrlInputSchema = {
   depositToVault: z.boolean().default(false).describe("Save the full page content into the user's MCP Memory vault server-side, embedded for semantic recall \u2014 the full body is NOT returned to chat."),
   vaultName: z.string().trim().min(1).max(120).optional().describe("Optional vault to deposit into. Defaults to the user's personal vault.")
 };
+var DiffPageInputSchema = {
+  url: z.string().url().describe("Public http/https URL to check for changes since the last diff_page call."),
+  allowLocal: z.boolean().default(false).describe("Allow localhost and private-network URLs. Local development only."),
+  resetBaseline: z.boolean().default(false).describe("Discard any previously stored snapshot for this URL and capture the current content as a fresh baseline instead of diffing against history. Use when you deliberately want to restart change tracking.")
+};
 var MapSiteUrlsInputSchema = {
   url: z.string().url().describe("Public website URL or domain to crawl for internal URLs. Use before extract_site when the user asks to audit/map/crawl a site."),
   maxUrls: z.number().int().min(1).max(1e4).optional().describe("Maximum URLs to discover. Use 100 for normal maps, up to 10000 for a full inventory. Large maps (over 500 URLs) write the complete inventory to a local file and return only a summary plus the file path instead of the full list inline.")
@@ -3169,6 +3224,29 @@ var ExtractUrlOutputSchema = {
     error: z.string().optional()
   }).optional()
 };
+var DiffPageOutputSchema = {
+  url: z.string(),
+  title: NullableString,
+  status: z.enum(["baseline", "unchanged", "changed"]).describe('"baseline" = first-ever check for this URL, or resetBaseline was used \u2014 nothing to compare against. "unchanged" = content hash matched the stored snapshot. "changed" = a diff was computed.'),
+  isReset: z.boolean().describe("True only when resetBaseline discarded a real prior snapshot \u2014 distinguishes an explicit reset from a URL's true first-ever check."),
+  previousCheckedAt: NullableString.describe("ISO timestamp of the snapshot this was compared against, or null if there was none."),
+  currentCheckedAt: z.string().describe("ISO timestamp of this check, now stored as the new snapshot."),
+  contentHash: z.string().describe("sha256 of the full (untruncated) page content just captured."),
+  previousContentHash: NullableString,
+  summary: z.object({
+    linesAdded: z.number().int().min(0),
+    linesRemoved: z.number().int().min(0),
+    percentChanged: z.number().min(0).max(100).nullable().describe('Proportion of changed lines relative to the larger of the two versions. Null when status is "baseline".')
+  }),
+  hunks: z.array(z.object({
+    type: z.enum(["added", "removed"]).describe("Unchanged context lines are omitted \u2014 only added/removed lines are returned."),
+    lines: z.array(z.string())
+  })).describe("Ordered added/removed line hunks, capped for response size \u2014 see hunksTruncated."),
+  contentTruncated: z.boolean().describe("True if the scraped page exceeded the 250,000-character storable cap and was truncated before hashing/diffing/storing \u2014 changes past that point are invisible to this comparison."),
+  hunksTruncated: z.boolean().describe("True if the hunks list above was capped for response size \u2014 see hunksTruncatedReason."),
+  hunksTruncatedReason: NullableString,
+  totalChangedLineCount: z.number().int().min(0).describe("Total changed lines found before any hunksTruncated capping was applied.")
+};
 var ExtractSiteOutputSchema = {
   url: z.string(),
   pageCount: z.number().int().min(0),
@@ -4173,6 +4251,13 @@ function registerPaaExtractorMcpTools(server, executor, options = {}) {
     outputSchema: recordOutputSchema("extract_url", ExtractUrlOutputSchema),
     annotations: liveWebToolAnnotations("Single URL Extract")
   }, async (input) => formatExtractUrl(await executor.extractUrl(input), input));
+  server.registerTool("diff_page", {
+    title: "Page Change Check",
+    description: "Check whether a public URL has changed since you last checked it with this tool: scrapes the current page, diffs it against your last stored snapshot for that URL, and returns what was added or removed (or confirms no change). Stores the new snapshot as the baseline for next time \u2014 on-demand only, no automatic recurring checks. Use extract_url instead when you just want the page's current content with nothing to compare against.",
+    inputSchema: DiffPageInputSchema,
+    outputSchema: recordOutputSchema("diff_page", DiffPageOutputSchema),
+    annotations: liveWebToolAnnotations("Page Change Check")
+  }, async (input) => formatDiffPage(await executor.diffPage(input), input));
   server.registerTool("map_site_urls", {
     title: "Site URL Map",
     description: `Map/crawl a public website for a sitemap, URL inventory, or broken-link scan. Returns internal URLs with HTTP status; ${fileBehavior("maps over 500 URLs are written to a local CSV file instead of inlined.", "large results are stored as a retrievable artifact \u2014 you get an inline summary plus an artifactId for report_artifact_read.")}`,
@@ -4580,6 +4665,9 @@ var HttpMcpToolExecutor = class {
   extractUrl(input) {
     return this.call("/extract-url", input);
   }
+  diffPage(input) {
+    return this.call("/diff-page", input);
+  }
   mapSiteUrls(input) {
     return this.call("/map-urls", input);
   }
@@ -8365,4 +8453,4 @@ export {
   registerMemoryMcpTools,
   MemoryMcpToolExecutor
 };
-//# sourceMappingURL=chunk-WI4A3KFQ.js.map
+//# sourceMappingURL=chunk-6EXP6DQG.js.map