slidev-addon-agent 0.0.1

package/dist/agent/middleware.js

@@ -0,0 +1,134 @@
+import path from "node:path";
+import { createMiddleware, ToolMessage } from "langchain";
+const FILESYSTEM_TOOL_NAMES = new Set([
+    "ls",
+    "read_file",
+    "write_file",
+    "edit_file",
+    "glob",
+    "grep",
+]);
+const SINGLE_PATH_ARG_KEYS = ["path", "file_path"];
+const ARRAY_PATH_ARG_KEYS = ["paths"];
+const HOST_ABSOLUTE_PREFIXES = [
+    "/Users/",
+    "/private/",
+    "/var/",
+    "/tmp/",
+    "/etc/",
+    "/opt/",
+    "/Volumes/",
+    "/home/",
+];
+const HOST_RELATIVE_PREFIXES = HOST_ABSOLUTE_PREFIXES.map(prefix => prefix.slice(1));
+function isWithinRoot(rootDir, candidatePath) {
+    const relativePath = path.relative(rootDir, candidatePath);
+    return relativePath === "" || (!relativePath.startsWith("..") && !path.isAbsolute(relativePath));
+}
+function toProjectRelativePath(rootDir, candidatePath) {
+    const relativePath = path.relative(rootDir, candidatePath).replaceAll(path.sep, "/");
+    return relativePath ? `/${relativePath}` : "/";
+}
+function looksLikeHostAbsolutePath(value) {
+    return HOST_ABSOLUTE_PREFIXES.some(prefix => value.startsWith(prefix));
+}
+function looksLikeMissingLeadingSlashHostPath(value) {
+    return HOST_RELATIVE_PREFIXES.some(prefix => value.startsWith(prefix));
+}
+function normalizeFilesystemPath(rootDir, rawValue) {
+    const value = rawValue.trim();
+    if (!value)
+        return { normalized: rawValue, error: null };
+    if (looksLikeHostAbsolutePath(value)) {
+        const candidatePath = path.resolve(value);
+        if (isWithinRoot(rootDir, candidatePath)) {
+            return { normalized: toProjectRelativePath(rootDir, candidatePath), error: null };
+        }
+        return {
+            normalized: rawValue,
+            error: [
+                `Filesystem tools are rooted at the agent project, so host absolute paths are not allowed here: ${value}`,
+                "Use a project-root-relative path such as `/slides.md`, `/pages/foo.md`, or `/example/slides.md` instead.",
+            ].join("\n"),
+        };
+    }
+    if (looksLikeMissingLeadingSlashHostPath(value)) {
+        const candidatePath = path.resolve(path.sep, value);
+        if (isWithinRoot(rootDir, candidatePath))
+            return { normalized: toProjectRelativePath(rootDir, candidatePath), error: null };
+        return {
+            normalized: rawValue,
+            error: [
+                `Filesystem tools received a host-style path instead of a project-relative path: ${value}`,
+                "Use a project-root-relative path such as `/slides.md`, `/pages/foo.md`, or `/example/slides.md` instead.",
+            ].join("\n"),
+        };
+    }
+    return { normalized: rawValue, error: null };
+}
+function toolErrorMessage(toolCallId, content) {
+    return new ToolMessage({
+        content,
+        tool_call_id: toolCallId || "",
+    });
+}
+export function createFilesystemPathGuardMiddleware(rootDir) {
+    const absoluteRootDir = path.resolve(rootDir);
+    return createMiddleware({
+        name: "FilesystemPathGuardMiddleware",
+        wrapToolCall: async (request, handler) => {
+            const { toolCall } = request;
+            const { args: rawArgs, id: toolCallId, name: toolName } = toolCall;
+            if (!FILESYSTEM_TOOL_NAMES.has(toolName)) {
+                return handler(request);
+            }
+            if (!rawArgs || typeof rawArgs !== "object" || Array.isArray(rawArgs)) {
+                return handler(request);
+            }
+            let changed = false;
+            const nextArgs = { ...rawArgs };
+            for (const key of SINGLE_PATH_ARG_KEYS) {
+                const value = nextArgs[key];
+                if (typeof value !== "string")
+                    continue;
+                const { normalized, error } = normalizeFilesystemPath(absoluteRootDir, value);
+                if (error) {
+                    return toolErrorMessage(toolCallId, error);
+                }
+                if (normalized !== value) {
+                    nextArgs[key] = normalized;
+                    changed = true;
+                }
+            }
+            for (const key of ARRAY_PATH_ARG_KEYS) {
+                const value = nextArgs[key];
+                if (!Array.isArray(value))
+                    continue;
+                const normalizedPaths = [];
+                for (const entry of value) {
+                    if (typeof entry !== "string") {
+                        normalizedPaths.push(entry);
+                        continue;
+                    }
+                    const { normalized, error } = normalizeFilesystemPath(absoluteRootDir, entry);
+                    if (error) {
+                        return toolErrorMessage(toolCallId, error);
+                    }
+                    normalizedPaths.push(normalized);
+                    if (normalized !== entry)
+                        changed = true;
+                }
+                nextArgs[key] = normalizedPaths;
+            }
+            if (!changed)
+                return handler(request);
+            return handler({
+                ...request,
+                toolCall: {
+                    ...toolCall,
+                    args: nextArgs,
+                },
+            });
+        },
+    });
+}

package/dist/agent/slide-preview-tool.js

@@ -0,0 +1,257 @@
+import { spawnSync } from "node:child_process";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { tool } from "langchain";
+import { z } from "zod";
+function env(name, fallback = "") {
+    const value = process.env[name];
+    return typeof value === "string" && value.trim() ? value.trim() : fallback;
+}
+function normalizeOrigin(raw) {
+    return raw.replace(/\/$/, "");
+}
+const SLIDE_OVERFLOW_EVAL_SCRIPT = `(() => {
+  const root = document.querySelector("#slide-content") || document.querySelector(".slidev-slide-content")
+  if (!root || !(root instanceof HTMLElement))
+    return { ok: false, error: "no_slide_content" }
+
+  const tolerance = 3
+  const rootRect = root.getBoundingClientRect()
+
+  // Scrollable overflow (layout) — complements geometry when descendants use transforms.
+  const scrollOverflowX = root.scrollWidth > root.clientWidth + tolerance
+  const scrollOverflowY = root.scrollHeight > root.clientHeight + tolerance
+
+  let maxRight = rootRect.left
+  let maxBottom = rootRect.top
+  let minLeft = rootRect.right
+  let minTop = rootRect.bottom
+
+  const walk = (node) => {
+    if (node instanceof HTMLElement) {
+      const style = window.getComputedStyle(node)
+      if (style.visibility === "hidden" || style.display === "none")
+        return
+      const rect = node.getBoundingClientRect()
+      if (rect.width < 1 && rect.height < 1)
+        return
+      maxRight = Math.max(maxRight, rect.right)
+      maxBottom = Math.max(maxBottom, rect.bottom)
+      minLeft = Math.min(minLeft, rect.left)
+      minTop = Math.min(minTop, rect.top)
+      for (const c of node.children)
+        walk(c)
+      if (node.shadowRoot)
+        walk(node.shadowRoot)
+    }
+    else if (node instanceof ShadowRoot) {
+      for (const c of node.children)
+        walk(c)
+    }
+  }
+
+  walk(root)
+
+  const horizontalGeom = maxRight > rootRect.right + tolerance || minLeft < rootRect.left - tolerance
+  const verticalGeom = maxBottom > rootRect.bottom + tolerance || minTop < rootRect.top - tolerance
+  const horizontalOverflow = scrollOverflowX || horizontalGeom
+  const verticalOverflow = scrollOverflowY || verticalGeom
+
+  return {
+    ok: true,
+    overflow: { horizontal: horizontalOverflow, vertical: verticalOverflow },
+    scrollOverflow: { horizontal: scrollOverflowX, vertical: scrollOverflowY },
+    geometryOverflow: { horizontal: horizontalGeom, vertical: verticalGeom },
+    scrollMetrics: {
+      scrollWidth: root.scrollWidth,
+      clientWidth: root.clientWidth,
+      scrollHeight: root.scrollHeight,
+      clientHeight: root.clientHeight,
+    },
+    slideRect: {
+      left: rootRect.left,
+      top: rootRect.top,
+      right: rootRect.right,
+      bottom: rootRect.bottom,
+      width: rootRect.width,
+      height: rootRect.height,
+    },
+    contentBounds: { minLeft, minTop, maxRight, maxBottom },
+    viewport: { width: window.innerWidth, height: window.innerHeight },
+  }
+})()`;
+function getAgentBrowserJsPath() {
+    const custom = env("SLIDEV_AGENT_BROWSER_PATH");
+    if (custom)
+        return custom;
+    try {
+        const require = createRequire(import.meta.url);
+        const pkgDir = path.dirname(require.resolve("agent-browser/package.json"));
+        return path.join(pkgDir, "bin", "agent-browser.js");
+    }
+    catch {
+        return null;
+    }
+}
+function parseEvalResultStdout(stdout) {
+    const trimmed = stdout.trim();
+    if (!trimmed)
+        throw new Error("empty eval output");
+    const parsed = JSON.parse(trimmed);
+    if (parsed.success === false)
+        throw new Error(parsed.error || "agent-browser eval failed");
+    if (parsed.data && typeof parsed.data === "object" && "result" in parsed.data)
+        return parsed.data.result;
+    return parsed.data;
+}
+function runAgentBrowser(args, stdin) {
+    const jsPath = getAgentBrowserJsPath();
+    if (!jsPath) {
+        return {
+            ok: false,
+            stdout: "",
+            stderr: "agent-browser is not installed. Add it to the project (e.g. pnpm add -D agent-browser) and run `agent-browser install` once to fetch Chrome for Testing, or install the agent-browser CLI globally.",
+        };
+    }
+    const r = spawnSync(process.execPath, [jsPath, ...args], {
+        encoding: "utf8",
+        maxBuffer: 12 * 1024 * 1024,
+        input: stdin,
+        env: process.env,
+    });
+    const stdout = r.stdout ?? "";
+    const stderr = r.stderr ?? "";
+    const ok = r.status === 0 && !r.error;
+    if (r.error)
+        return { ok: false, stdout, stderr: `${r.error.message}\n${stderr}` };
+    return { ok, stdout, stderr };
+}
+export function createInspectSlidePreviewTool() {
+    return tool(async (input) => {
+        const slideNumber = Math.floor(input.slideNumber);
+        if (!Number.isFinite(slideNumber) || slideNumber < 1) {
+            return JSON.stringify({
+                ok: false,
+                error: "slideNumber must be a positive integer (Slidev route index, e.g. 1 for /1).",
+            });
+        }
+        const origin = normalizeOrigin(input.origin || env("SLIDEV_AGENT_PREVIEW_ORIGIN", "http://127.0.0.1:3030"));
+        const url = `${origin}/${slideNumber}`;
+        const session = env("SLIDEV_AGENT_BROWSER_SESSION", "slidev-agent-preview");
+        const sessionArgs = ["--json", "--session", session];
+        const viewport = runAgentBrowser([...sessionArgs, "set", "viewport", "1920", "1080"]);
+        if (!viewport.ok)
+            return formatToolError(url, viewport, "set viewport");
+        const opened = runAgentBrowser([...sessionArgs, "open", url]);
+        if (!opened.ok) {
+            runAgentBrowser([...sessionArgs, "close"]);
+            return JSON.stringify({
+                ok: false,
+                error: `Could not open ${url}. Is the Slidev dev server running and SLIDEV_AGENT_PREVIEW_ORIGIN correct?`,
+                detail: combineOut(opened),
+                url,
+            });
+        }
+        const load = runAgentBrowser([...sessionArgs, "wait", "--load", "domcontentloaded"]);
+        if (!load.ok)
+            void load;
+        const settle = runAgentBrowser([...sessionArgs, "wait", "600"]);
+        if (!settle.ok)
+            void settle;
+        let dom;
+        try {
+            const ev = runAgentBrowser([...sessionArgs, "eval", "--stdin"], SLIDE_OVERFLOW_EVAL_SCRIPT);
+            if (!ev.ok) {
+                runAgentBrowser([...sessionArgs, "close"]);
+                return JSON.stringify({
+                    ok: false,
+                    error: "eval failed while measuring slide layout.",
+                    detail: combineOut(ev),
+                    url,
+                });
+            }
+            dom = parseEvalPayload(ev.stdout);
+        }
+        catch (e) {
+            runAgentBrowser([...sessionArgs, "close"]);
+            const message = e instanceof Error ? e.message : String(e);
+            return JSON.stringify({
+                ok: false,
+                error: `Could not parse slide inspection result: ${message}`,
+                url,
+            });
+        }
+        runAgentBrowser([...sessionArgs, "close"]);
+        if (dom.ok === false || dom.error) {
+            return JSON.stringify({
+                ok: false,
+                error: `Loaded ${url} but could not find slide content (#slide-content).`,
+                url,
+            });
+        }
+        const overflow = dom.overflow;
+        const horizontal = Boolean(overflow?.horizontal);
+        const vertical = Boolean(overflow?.vertical);
+        const hasOverflow = horizontal || vertical;
+        const scrollOverflow = dom.scrollOverflow;
+        const geometryOverflow = dom.geometryOverflow;
+        return JSON.stringify({
+            ok: true,
+            url,
+            engine: "agent-browser",
+            overflow: { horizontal, vertical },
+            scrollOverflow: {
+                horizontal: Boolean(scrollOverflow?.horizontal),
+                vertical: Boolean(scrollOverflow?.vertical),
+            },
+            geometryOverflow: {
+                horizontal: Boolean(geometryOverflow?.horizontal),
+                vertical: Boolean(geometryOverflow?.vertical),
+            },
+            hasOverflow,
+            slideRect: dom.slideRect,
+            contentBounds: dom.contentBounds,
+            scrollMetrics: dom.scrollMetrics,
+            viewport: dom.viewport,
+            hint: hasOverflow
+                ? "Content appears clipped or extending past the slide frame. Remove or shrink elements, split into another slide, simplify diagrams, or reduce columns/font sizes; then re-run this check."
+                : "No obvious overflow detected against the slide content box (scroll size + descendant geometry within #slide-content). Content teleported outside this node cannot be measured here.",
+        });
+    }, {
+        name: "inspect_slide_preview",
+        description: [
+            "Verify how a Slidev slide renders in the running dev server before finishing slide work.",
+            "Uses the agent-browser CLI (Vercel) to open the slide in Chrome and measure overflow inside `#slide-content` (scroll dimensions + bounding boxes of descendants, including open shadow roots). Does not capture a PNG screenshot.",
+            "Requires agent-browser on PATH or as a dependency, a one-time `agent-browser install` for Chrome for Testing, a running Slidev preview (default origin http://127.0.0.1:3030), and optional env SLIDEV_AGENT_PREVIEW_ORIGIN.",
+            "Optional: SLIDEV_AGENT_BROWSER_PATH (path to agent-browser.js), SLIDEV_AGENT_BROWSER_SESSION (isolated session name).",
+            "Pass the 1-based slide index as shown in the app URL (e.g. slide 3 → slideNumber: 3).",
+            "If the new slide is not imported into the deck yet, skip this tool and say so; the orchestrator can import it and re-delegate so you can re-run this check.",
+            "Call this after substantive slide edits when the slide index is known; do not skip only because the layout looks correct in the file.",
+            "Successful responses include `url` (full page URL for that slide); surface that URL as a markdown link in your final message so the user can open the slide in one click.",
+        ].join(" "),
+        schema: z.object({
+            slideNumber: z.number().describe("1-based Slidev slide number in the URL path (e.g. 5 for /5)."),
+            origin: z.string().optional().describe("Preview server origin, e.g. http://127.0.0.1:3030. Defaults to SLIDEV_AGENT_PREVIEW_ORIGIN or http://127.0.0.1:3030."),
+        }),
+    });
+}
+function combineOut(r) {
+    return [r.stderr, r.stdout].filter(Boolean).join("\n").trim();
+}
+function formatToolError(url, r, step) {
+    return JSON.stringify({
+        ok: false,
+        skipped: true,
+        error: `agent-browser failed during ${step}. Install: https://github.com/vercel-labs/agent-browser — add the npm package or global CLI, run \`agent-browser install\` once, then retry.`,
+        detail: combineOut(r),
+        url,
+    });
+}
+function parseEvalPayload(stdout) {
+    const raw = parseEvalResultStdout(stdout);
+    if (raw && typeof raw === "object" && !Array.isArray(raw))
+        return raw;
+    if (typeof raw === "string")
+        return JSON.parse(raw);
+    throw new Error("unexpected eval payload shape");
+}

package/dist/agent/tools/export-tool.js

@@ -0,0 +1,167 @@
+import path from "node:path";
+import { mkdir, readFile, readdir, realpath } from "node:fs/promises";
+import { spawn } from "node:child_process";
+import { createRequire } from "node:module";
+import { pathToFileURL } from "node:url";
+import { tool } from "langchain";
+import { z } from "zod";
+import { resolveDeckExecutionContext } from "../deck-context.js";
+const slidevExportScreenshotSchema = z.object({
+    slideIndex: z.number().int().positive().describe("1-based slide index to export as PNG."),
+    outputDir: z.string().optional().describe("Optional output directory. Prefer omitting this unless you need a custom project-local path."),
+    timeout: z.number().int().positive().optional().describe("Optional Slidev export timeout in milliseconds. Defaults to 60000."),
+    wait: z.number().int().nonnegative().optional().describe("Optional Slidev export wait in milliseconds. Defaults to 500."),
+});
+function isWithinRoot(rootDir, candidatePath) {
+    return candidatePath === rootDir || candidatePath.startsWith(`${rootDir}${path.sep}`);
+}
+async function resolveOutputDir(rootDir, deckHostDir, slideIndex, outputDir) {
+    const fallbackOutputDir = path.join(deckHostDir, ".slidev-agent-artifacts", `verify-${slideIndex}`);
+    const requestedOutputDir = outputDir?.trim() || fallbackOutputDir;
+    const resolvedOutputDir = path.isAbsolute(requestedOutputDir)
+        ? path.resolve(requestedOutputDir)
+        : path.resolve(deckHostDir, requestedOutputDir);
+    const [realRoot, realOutputDirParent] = await Promise.all([
+        realpath(rootDir).catch(() => rootDir),
+        realpath(path.dirname(resolvedOutputDir)).catch(() => path.dirname(resolvedOutputDir)),
+    ]);
+    if (!isWithinRoot(realRoot, realOutputDirParent) && !isWithinRoot(rootDir, resolvedOutputDir)) {
+        throw new Error(`slidev_export_screenshot outputDir must stay within the project root (${rootDir}).`);
+    }
+    return resolvedOutputDir;
+}
+function getPnpmCommand() {
+    return process.platform === "win32" ? "pnpm.cmd" : "pnpm";
+}
+const ANSI_ESCAPE_PATTERN = /\u001B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g;
+async function resolveDeckSlideCount(deckHostDir, entryPath) {
+    const requireFromDeck = createRequire(path.join(deckHostDir, "package.json"));
+    const slidevCliPackageJsonPath = requireFromDeck.resolve("@slidev/cli/package.json");
+    const slidevCliPackageJson = JSON.parse(await readFile(slidevCliPackageJsonPath, "utf8"));
+    const slidevCliEntry = path.resolve(path.dirname(slidevCliPackageJsonPath), slidevCliPackageJson.module || slidevCliPackageJson.main || "dist/index.mjs");
+    const slidevCli = await import(pathToFileURL(slidevCliEntry).href);
+    const resolved = await slidevCli.resolveOptions?.({ entry: entryPath }, "export");
+    return Array.isArray(resolved?.data?.slides) ? resolved.data.slides.length : null;
+}
+function stripAnsi(output) {
+    return output.replace(ANSI_ESCAPE_PATTERN, "");
+}
+function extractLikelyBuildError(output) {
+    const cleanedOutput = stripAnsi(output);
+    const lines = cleanedOutput.split(/\r?\n/);
+    const errorStartIndex = lines.findIndex(line => /\[vite\].*(Pre-transform error|Internal server error)/.test(line)
+        || /Plugin:\s+vite:vue/.test(line)
+        || /Failed to resolve import/i.test(line)
+        || /Invalid end tag\./.test(line));
+    if (errorStartIndex === -1)
+        return null;
+    const errorLines = [];
+    for (let index = errorStartIndex; index < lines.length; index += 1) {
+        const line = lines[index];
+        if (index > errorStartIndex && !line.trim())
+            break;
+        if (/^\s*✓\s+exported to\b/.test(line))
+            break;
+        errorLines.push(line);
+        if (errorLines.length >= 30)
+            break;
+    }
+    return errorLines.join("\n").trim() || null;
+}
+function runCommand(cwd, args) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(getPnpmCommand(), args, {
+            cwd,
+            env: process.env,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let output = "";
+        child.stdout.on("data", (chunk) => {
+            output += chunk.toString();
+        });
+        child.stderr.on("data", (chunk) => {
+            output += chunk.toString();
+        });
+        child.on("error", reject);
+        child.on("close", (exitCode) => {
+            resolve({
+                exitCode: exitCode ?? 1,
+                output,
+            });
+        });
+    });
+}
+export function createSlidevExportScreenshotTool(rootDir) {
+    return tool(async ({ slideIndex, outputDir, timeout, wait }) => {
+        const deckContext = resolveDeckExecutionContext(path.resolve(rootDir));
+        const resolvedOutputDir = await resolveOutputDir(deckContext.rootDir, deckContext.deckHostDir, slideIndex, outputDir);
+        const totalSlides = await resolveDeckSlideCount(deckContext.deckHostDir, deckContext.entryPath).catch(() => null);
+        if (totalSlides !== null && slideIndex > totalSlides) {
+            throw new Error([
+                `slidev_export_screenshot requested slide ${slideIndex}, but the resolved deck only has ${totalSlides} slides.`,
+                `Resolved deck entry: ${path.relative(deckContext.rootDir, deckContext.entryPath) || path.basename(deckContext.entryPath)}`,
+                "This usually means the slide is not imported into the final deck yet or the 1-based slide index was counted incorrectly.",
+            ].join("\n"));
+        }
+        await mkdir(resolvedOutputDir, { recursive: true });
+        const args = [
+            "exec",
+            "slidev-agent",
+            "export",
+            "--format",
+            "png",
+            "--range",
+            String(slideIndex),
+            "--per-slide",
+            "--output",
+            resolvedOutputDir,
+            "--timeout",
+            String(timeout ?? 60000),
+            "--wait",
+            String(wait ?? 500),
+            "--scale",
+            "1",
+        ];
+        const result = await runCommand(deckContext.deckHostDir, args);
+        if (result.exitCode !== 0) {
+            throw new Error([
+                `slidev_export_screenshot failed with exit code ${result.exitCode}.`,
+                `Deck directory: ${deckContext.deckHostDir}`,
+                `Command: ${getPnpmCommand()} ${args.join(" ")}`,
+                result.output.trim(),
+            ].filter(Boolean).join("\n"));
+        }
+        const imageFiles = (await readdir(resolvedOutputDir))
+            .filter(fileName => fileName.toLowerCase().endsWith(".png"))
+            .sort((a, b) => a.localeCompare(b));
+        if (imageFiles.length === 0) {
+            const buildError = extractLikelyBuildError(result.output);
+            if (buildError) {
+                throw new Error([
+                    "slidev_export_screenshot hit a Slidev/Vite build error and produced no PNG files.",
+                    `Deck directory: ${deckContext.deckHostDir}`,
+                    `Command: ${getPnpmCommand()} ${args.join(" ")}`,
+                    buildError,
+                ].join("\n"));
+            }
+            throw new Error([
+                `slidev_export_screenshot succeeded but produced no PNG files in ${resolvedOutputDir}.`,
+                totalSlides !== null ? `Resolved deck slide count: ${totalSlides}. Requested slide: ${slideIndex}.` : "",
+                "This usually means the requested 1-based slide index does not exist in the final rendered deck yet.",
+            ].filter(Boolean).join("\n"));
+        }
+        const imagePaths = imageFiles.map(fileName => path.join(resolvedOutputDir, fileName));
+        return {
+            slideIndex,
+            deckDir: deckContext.deckHostDir,
+            outputDir: resolvedOutputDir,
+            imagePaths,
+            primaryImagePath: imagePaths[0],
+            command: `${getPnpmCommand()} ${args.join(" ")}`,
+        };
+    }, {
+        name: "slidev_export_screenshot",
+        description: "Export one Slidev slide to PNG from the correct deck directory and return the generated image path.",
+        schema: slidevExportScreenshotSchema,
+    });
+}

package/dist/agent/tools/review-tool.js

@@ -0,0 +1,111 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { readFile, realpath, stat } from "node:fs/promises";
+import { initChatModel, tool } from "langchain";
+import { z } from "zod";
+import { model } from "../../lib/env.js";
+const slidevReviewScreenshotSchema = z.object({
+    imagePath: z.string().min(1).describe("Path to the exported PNG screenshot file. Use a path inside the project root, for example `.slidev-agent-artifacts/verify-5/1.png`."),
+    slideIndex: z.number().int().positive().optional().describe("Optional 1-based slide index represented by the screenshot."),
+    focus: z.string().optional().describe("Optional short note about what to scrutinize most closely."),
+});
+const slidevReviewScreenshotResultSchema = z.object({
+    pass: z.boolean().describe("Whether the slide looks presentation-ready in the screenshot."),
+    summary: z.string().describe("Short visual verdict."),
+    issues: z.array(z.string()).describe("Concrete visual problems found in the screenshot."),
+    suggestions: z.array(z.string()).describe("Targeted improvements to address the issues."),
+});
+function isWithinRoot(rootDir, candidatePath) {
+    return candidatePath === rootDir || candidatePath.startsWith(`${rootDir}${path.sep}`);
+}
+function normalizeImagePathInput(imagePath) {
+    const trimmed = imagePath.trim();
+    if (!trimmed)
+        return trimmed;
+    if (trimmed.startsWith("file://"))
+        return fileURLToPath(trimmed);
+    return trimmed;
+}
+async function resolveImagePath(rootDir, imagePath) {
+    const absoluteRoot = path.resolve(rootDir);
+    const normalizedImagePath = normalizeImagePathInput(imagePath);
+    const resolved = path.isAbsolute(normalizedImagePath)
+        ? path.resolve(normalizedImagePath)
+        : path.resolve(absoluteRoot, normalizedImagePath);
+    if (resolved === absoluteRoot)
+        throw new Error("Screenshot path must point to an image file, not the project root.");
+    if (isWithinRoot(absoluteRoot, resolved))
+        return resolved;
+    const [realRoot, realResolved] = await Promise.all([
+        realpath(absoluteRoot).catch(() => absoluteRoot),
+        realpath(resolved).catch(() => resolved),
+    ]);
+    if (!isWithinRoot(realRoot, realResolved)) {
+        throw new Error(`Screenshot path must stay within the project root (${absoluteRoot}). Export the PNG into a project-local folder such as ".slidev-agent-artifacts/verify-<slideIndex>" and pass that PNG file path to slidev_review_screenshot.`);
+    }
+    return realResolved;
+}
+function isPngBuffer(fileBuffer) {
+    return fileBuffer.length >= 8
+        && fileBuffer[0] === 0x89
+        && fileBuffer[1] === 0x50
+        && fileBuffer[2] === 0x4E
+        && fileBuffer[3] === 0x47
+        && fileBuffer[4] === 0x0D
+        && fileBuffer[5] === 0x0A
+        && fileBuffer[6] === 0x1A
+        && fileBuffer[7] === 0x0A;
+}
+export function createSlidevReviewScreenshotTool(rootDir) {
+    return tool(async ({ imagePath, slideIndex, focus }) => {
+        const resolvedImagePath = await resolveImagePath(rootDir, imagePath);
+        const fileInfo = await stat(resolvedImagePath).catch(() => null);
+        if (!fileInfo?.isFile())
+            throw new Error(`Screenshot not found: ${imagePath}`);
+        const imageBuffer = await readFile(resolvedImagePath);
+        if (path.extname(resolvedImagePath).toLowerCase() !== ".png") {
+            throw new Error(`slidev_review_screenshot only accepts PNG files. Got: ${path.extname(resolvedImagePath) || "unknown"}`);
+        }
+        if (!isPngBuffer(imageBuffer))
+            throw new Error(`slidev_review_screenshot expected a real PNG file at: ${imagePath}`);
+        const imageData = imageBuffer.toString("base64");
+        const reviewModel = await initChatModel(model, {
+            temperature: 0,
+        });
+        const structuredReviewer = reviewModel.withStructuredOutput(slidevReviewScreenshotResultSchema);
+        const review = await structuredReviewer.invoke([
+            {
+                role: "user",
+                content: [
+                    {
+                        type: "text",
+                        text: [
+                            `Review this rendered Slidev slide screenshot${slideIndex ? ` for slide ${slideIndex}` : ""}.`,
+                            "Judge only what is visible in the image. Do not guess about hidden or source markdown content.",
+                            "Mark the slide as failing if you notice clipped or off-screen content, overflow, cramped layout, collisions, unreadable or tiny text, broken wrapping, poor contrast, or obvious alignment problems.",
+                            "Only pass the slide if it looks presentation-ready.",
+                            focus ? `Pay extra attention to: ${focus}` : "",
+                            "Return concise structured output.",
+                        ].filter(Boolean).join("\n"),
+                    },
+                    {
+                        type: "image",
+                        source_type: "base64",
+                        data: imageData,
+                        mimeType: "image/png",
+                        mime_type: "image/png",
+                    },
+                ],
+            },
+        ]);
+        return {
+            ...review,
+            imagePath: path.relative(rootDir, resolvedImagePath) || path.basename(resolvedImagePath),
+            slideIndex: slideIndex || null,
+        };
+    }, {
+        name: "slidev_review_screenshot",
+        description: "Review an exported PNG slide screenshot with a multimodal model and report visual issues such as clipping, overflow, collisions, poor contrast, and unreadable text.",
+        schema: slidevReviewScreenshotSchema,
+    });
+}