@hutusi/amytis 1.14.0 → 1.16.0

package/tests/integration/reading-time-headings.test.ts

@@ -2,22 +2,24 @@ import { describe, expect, test } from "bun:test";
 import { getAllPosts, getPostBySlug } from "../../src/lib/markdown";
 
 describe("Integration: Reading Time & Headings", () => {
-  test("posts have readingTime matching expected format", () => {
+  test("posts have a positive whole-minute readingMinutes", () => {
     const posts = getAllPosts();
     expect(posts.length).toBeGreaterThan(0);
 
     posts.forEach((post) => {
-      expect(post.readingTime).toMatch(/^\d+ min read$/);
+      expect(Number.isInteger(post.readingMinutes)).toBe(true);
+      expect(post.readingMinutes).toBeGreaterThanOrEqual(1);
     });
   });
 
-  test("kitchen-sink post has readingTime in correct format", () => {
+  test("kitchen-sink post has a positive readingMinutes", () => {
     const post = getPostBySlug("kitchen-sink");
     if (!post) {
       console.warn("Skipping: kitchen-sink post not found");
       return;
     }
-    expect(post.readingTime).toMatch(/^\d+ min read$/);
+    expect(Number.isInteger(post.readingMinutes)).toBe(true);
+    expect(post.readingMinutes).toBeGreaterThanOrEqual(1);
   });
 
   test("headings on real posts have correct structure", () => {
@@ -49,17 +51,13 @@ describe("Integration: Reading Time & Headings", () => {
     });
   });
 
-  test("short posts have 1 min read", () => {
-    const posts = getAllPosts();
-    // Find a short post (content < 200 words)
-    const shortPost = posts.find((p) => {
-      const wordCount = p.content.split(/\s+/).length;
-      return wordCount < 200;
-    });
-
-    if (shortPost) {
-      expect(shortPost.readingTime).toBe("1 min read");
+  test("short posts have readingMinutes === 1 (floor)", () => {
+    const shortPost = getPostBySlug("legacy-markdown");
+    expect(shortPost).toBeDefined();
+    if (!shortPost) {
+      throw new Error("fixture 'legacy-markdown' not found");
     }
+    expect(shortPost.readingMinutes).toBe(1);
   });
 
   test("multilingual post has headings with correct IDs", () => {

package/tests/integration/series-draft.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, test } from "bun:test";
 import { getSeriesData, getAllSeries } from "../../src/lib/markdown";
+import { setEnvVar, restoreEnvVar } from "../helpers/env";
 
 describe("Integration: Series Draft Support", () => {
   test("all series are included when NODE_ENV is not production", () => {
@@ -18,29 +19,35 @@ describe("Integration: Series Draft Support", () => {
 
   test("draft filtering code path runs without error in production mode", () => {
     const originalEnv = process.env.NODE_ENV;
+    const originalPythonRst = process.env.AMYTIS_ENABLE_PYTHON_RST;
     try {
-      process.env.NODE_ENV = "production";
+      setEnvVar("NODE_ENV", "production");
+      setEnvVar("AMYTIS_ENABLE_PYTHON_RST", "0");
       // This should not throw; draft series are simply excluded
       const series = getAllSeries();
       expect(typeof series).toBe("object");
     } finally {
-      process.env.NODE_ENV = originalEnv;
+      restoreEnvVar("NODE_ENV", originalEnv);
+      restoreEnvVar("AMYTIS_ENABLE_PYTHON_RST", originalPythonRst);
     }
   });
 
   test("draft series are excluded in production mode", () => {
     const originalEnv = process.env.NODE_ENV;
+    const originalPythonRst = process.env.AMYTIS_ENABLE_PYTHON_RST;
     try {
-      process.env.NODE_ENV = "production";
+      setEnvVar("NODE_ENV", "production");
+      setEnvVar("AMYTIS_ENABLE_PYTHON_RST", "0");
       const allSeries = getAllSeries();
-      
+
       // Verify that every series returned has draft: false (or undefined which defaults to false)
       Object.keys(allSeries).forEach(slug => {
         const seriesData = getSeriesData(slug);
         expect(seriesData?.draft).not.toBe(true);
       });
     } finally {
-      process.env.NODE_ENV = originalEnv;
+      restoreEnvVar("NODE_ENV", originalEnv);
+      restoreEnvVar("AMYTIS_ENABLE_PYTHON_RST", originalPythonRst);
     }
   });
 });

package/tests/integration/series.test.ts

@@ -1,7 +1,10 @@
 import { describe, expect, test } from "bun:test";
+import { parseRstDocument, RstParseError } from "../../src/lib/rst";
 import {
   getAllSeries,
+  getAdjacentPosts,
   getSeriesData,
+  getSeriesLatestPostDate,
   getSeriesPosts,
   getFeaturedPosts,
   getFeaturedSeries,
@@ -13,6 +16,10 @@ describe("Integration: Series", () => {
     expect(Object.keys(series).length).toBeGreaterThan(0);
     expect(series).toHaveProperty("nextjs-deep-dive");
     expect(series).toHaveProperty("digital-garden");
+    expect(series).toHaveProperty("rst-legacy");
+    expect(series).toHaveProperty("rst-readme");
+    expect(series).toHaveProperty("rst-toctree");
+    expect(series).toHaveProperty("rst-toctree-precedence");
   });
 
   test("getSeriesData returns metadata with correct fields", () => {
@@ -30,6 +37,49 @@ describe("Integration: Series", () => {
     expect(data).toBeNull();
   });
 
+  test("getSeriesData loads rST series metadata", () => {
+    const data = getSeriesData("rst-legacy");
+    expect(data).not.toBeNull();
+    expect(data!.title).toBe("Rst Legacy Series");
+    expect(data!.sourceFormat).toBe("rst");
+    expect(data!.sort).toBe("manual");
+    expect(data!.posts).toEqual(["getting-started", "deeper-notes"]);
+  });
+
+  test("getSeriesData accepts README.rst as the series index", () => {
+    const data = getSeriesData("rst-readme");
+    expect(data).not.toBeNull();
+    expect(data!.title).toBe("Rst README Series");
+    expect(data!.sourceFormat).toBe("rst");
+    expect(data!.posts).toEqual(["readme-index-post"]);
+  });
+
+  test("getSeriesData derives manual order from rST toctree when posts metadata is absent", () => {
+    const data = getSeriesData("rst-toctree");
+    expect(data).not.toBeNull();
+    expect(data!.title).toBe("Rst Toctree Series");
+    expect(data!.sourceFormat).toBe("rst");
+    expect(data!.sort).toBe("manual");
+    expect(data!.posts).toEqual(["second-post", "first-post"]);
+  });
+
+  test("getSeriesData rejects unsafe series slugs", () => {
+    expect(() => getSeriesData("../etc/passwd")).toThrow();
+    expect(() => getSeriesData("nested/slug")).toThrow();
+  });
+
+  test("rST series indexes reject impossible dates", () => {
+    expect(() => parseRstDocument([
+      "Broken rST Series",
+      "=================",
+      "",
+      ":date: 2021-16-15",
+      "",
+      "Body.",
+      "",
+    ].join("\n"))).toThrow(RstParseError);
+  });
+
   test("getSeriesPosts returns posts in manual order for manual series", () => {
     const seriesData = getSeriesData("nextjs-deep-dive");
     expect(seriesData?.sort).toBe("manual");
@@ -62,6 +112,49 @@ describe("Integration: Series", () => {
     expect(posts).toEqual([]);
   });
 
+  test("getSeriesPosts returns rST posts in manual order", () => {
+    const posts = getSeriesPosts("rst-legacy");
+    expect(posts.map(post => post.slug)).toEqual(["getting-started", "deeper-notes"]);
+    expect(posts.every(post => post.sourceFormat === "rst")).toBe(true);
+  });
+
+  test("getSeriesPosts loads posts for README.rst-based series", () => {
+    const posts = getSeriesPosts("rst-readme");
+    expect(posts.map(post => post.slug)).toEqual(["readme-index-post"]);
+    expect(posts[0]?.sourceFormat).toBe("rst");
+  });
+
+  test("getSeriesPosts follows rST toctree order when posts metadata is absent", () => {
+    const posts = getSeriesPosts("rst-toctree");
+    expect(posts.map(post => post.slug)).toEqual(["second-post", "first-post"]);
+    expect(posts.every(post => post.sourceFormat === "rst")).toBe(true);
+  });
+
+  test("getSeriesLatestPostDate uses the newest post date instead of manual series order", () => {
+    expect(getSeriesData("nextjs-deep-dive")?.sort).toBe("manual");
+    expect(getSeriesPosts("nextjs-deep-dive").map(post => post.date)).toEqual(["2026-01-30", "2026-01-31"]);
+    expect(getSeriesLatestPostDate("nextjs-deep-dive")).toBe("2026-01-31");
+  });
+
+  test("getAdjacentPosts follows rST series order instead of global post date order", () => {
+    const first = getAdjacentPosts("getting-started");
+    expect(first.prev?.slug ?? null).toBeNull();
+    expect(first.next?.slug).toBe("deeper-notes");
+
+    const second = getAdjacentPosts("deeper-notes");
+    expect(second.prev?.slug).toBe("getting-started");
+    expect(second.next?.slug ?? null).toBeNull();
+  });
+
+  test("explicit rST posts metadata takes precedence over toctree order", () => {
+    const data = getSeriesData("rst-toctree-precedence");
+    expect(data).not.toBeNull();
+    expect(data!.posts).toEqual(["first-post", "second-post"]);
+
+    const posts = getSeriesPosts("rst-toctree-precedence");
+    expect(posts.map(post => post.slug)).toEqual(["first-post", "second-post"]);
+  });
+
   test("getFeaturedPosts returns only posts with featured: true", () => {
     const featured = getFeaturedPosts();
     featured.forEach((post) => {

package/tests/integration/sync-vuepress-book.test.ts

@@ -0,0 +1,240 @@
+import { describe, expect, test, beforeEach, afterEach } from "bun:test";
+import { spawnSync } from "child_process";
+import { mkdirSync, mkdtempSync, rmSync, existsSync, readFileSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import path from "path";
+import matter from "gray-matter";
+
+const FIXTURE_SOURCE = path.resolve("tests/fixtures/sync-vuepress-book/docs");
+
+// Invoke through the published `bun run sync-vuepress-book` entrypoint and the
+// `--source` / `--dest` flags so the test exercises everything a real user does:
+// the package.json script wiring + the CLI argv parser, not just the inner sync
+// pipeline.
+function runSync(source: string, dest: string) {
+  return spawnSync(
+    "bun",
+    ["run", "sync-vuepress-book", "--source", source, "--dest", dest],
+    {
+      encoding: "utf8",
+      cwd: process.cwd(),
+    },
+  );
+}
+
+describe("Integration: sync-vuepress-book script", () => {
+  let dest: string;
+
+  beforeEach(() => {
+    dest = mkdtempSync(path.join(tmpdir(), "sync-vuepress-book-"));
+  });
+
+  afterEach(() => {
+    if (dest && existsSync(dest)) rmSync(dest, { recursive: true, force: true });
+  });
+
+  test("runs end-to-end and produces the expected layout", () => {
+    const res = runSync(FIXTURE_SOURCE, dest);
+    expect(res.status).toBe(0);
+
+    // Markdown content was rsynced verbatim (no rewriting on copy).
+    expect(existsSync(path.join(dest, "intro", "welcome.md"))).toBe(true);
+    expect(existsSync(path.join(dest, "maths", "linear", "vectors.md"))).toBe(true);
+    expect(existsSync(path.join(dest, "maths", "linear", "matrices.md"))).toBe(true);
+
+    // Asset folders co-located with chapters were copied.
+    expect(existsSync(path.join(dest, "maths", "linear", "assets", "diagram.png"))).toBe(true);
+
+    // .vuepress was excluded.
+    expect(existsSync(path.join(dest, ".vuepress"))).toBe(false);
+
+    // index.mdx exists with parsed nested TOC.
+    const indexPath = path.join(dest, "index.mdx");
+    expect(existsSync(indexPath)).toBe(true);
+    const { data } = matter(readFileSync(indexPath, "utf8")) as unknown as { data: Record<string, unknown> };
+    expect(data.title).toBe("Fixture Book");
+    const chapters = data.chapters as Array<Record<string, unknown>>;
+    expect(chapters[0]).toMatchObject({ title: "Intro", id: "intro/welcome" });
+    expect(chapters[1]).toMatchObject({ section: "Maths" });
+    const mathsItems = (chapters[1].items as Array<Record<string, unknown>>);
+    expect(mathsItems[0]).toMatchObject({ section: "Linear Algebra" });
+    const linearItems = mathsItems[0].items as Array<Record<string, unknown>>;
+    expect(linearItems).toEqual([
+      { title: "Vectors", id: "maths/linear/vectors" },
+      { title: "Matrices", id: "maths/linear/matrices" },
+    ]);
+  });
+
+  test("preserves user-controlled frontmatter on re-run", () => {
+    // First run creates index.mdx.
+    expect(runSync(FIXTURE_SOURCE, dest).status).toBe(0);
+
+    // Author edits cover image + featured flag.
+    const indexPath = path.join(dest, "index.mdx");
+    const parsed = matter(readFileSync(indexPath, "utf8")) as unknown as { data: Record<string, unknown>; content: string };
+    const edited = matter.stringify(parsed.content, {
+      ...parsed.data,
+      coverImage: "text:FB",
+      featured: true,
+      excerpt: "A tiny book for tests.",
+    });
+    writeFileSync(indexPath, edited);
+
+    // Re-run should keep the edited fields and refresh `chapters`.
+    expect(runSync(FIXTURE_SOURCE, dest).status).toBe(0);
+    const { data: refreshed } = matter(readFileSync(indexPath, "utf8")) as unknown as { data: Record<string, unknown> };
+    expect(refreshed.coverImage).toBe("text:FB");
+    expect(refreshed.featured).toBe(true);
+    expect(refreshed.excerpt).toBe("A tiny book for tests.");
+    expect(Array.isArray(refreshed.chapters)).toBe(true);
+  });
+
+  test("prunes dest files removed upstream (mirror semantics)", () => {
+    // First sync — dest now has every fixture file.
+    expect(runSync(FIXTURE_SOURCE, dest).status).toBe(0);
+    expect(existsSync(path.join(dest, "maths", "linear", "matrices.md"))).toBe(true);
+
+    // Simulate an upstream deletion by syncing from a smaller temp source tree
+    // (just the bits we need for the still-listed chapters) and a config that
+    // no longer references matrices.
+    const trimmed = mkdtempSync(path.join(tmpdir(), "sync-trimmed-"));
+    try {
+      const docs = path.join(trimmed, "docs");
+      const vp = path.join(docs, ".vuepress");
+      mkdirSync(vp, { recursive: true });
+      writeFileSync(
+        path.join(vp, "config.js"),
+        `export default {
+          title: 'Fixture Book',
+          theme: { sidebar: [{ text: 'Vectors', link: '/maths/linear/vectors' }] },
+        }
+        `,
+      );
+      mkdirSync(path.join(docs, "maths", "linear"), { recursive: true });
+      writeFileSync(path.join(docs, "maths", "linear", "vectors.md"), "---\ntitle: Vectors\n---\n# Vectors\n");
+
+      expect(runSync(docs, dest).status).toBe(0);
+
+      // Vectors survives, matrices is gone, the now-empty assets/ dir is cleaned up.
+      expect(existsSync(path.join(dest, "maths", "linear", "vectors.md"))).toBe(true);
+      expect(existsSync(path.join(dest, "maths", "linear", "matrices.md"))).toBe(false);
+      expect(existsSync(path.join(dest, "intro"))).toBe(false);
+      expect(existsSync(path.join(dest, "maths", "linear", "assets"))).toBe(false);
+      // index.mdx is regenerated, not pruned.
+      expect(existsSync(path.join(dest, "index.mdx"))).toBe(true);
+    } finally {
+      rmSync(trimmed, { recursive: true, force: true });
+    }
+  });
+
+  test("preserves user-added dotfiles on re-run (out-of-band overlay state)", () => {
+    expect(runSync(FIXTURE_SOURCE, dest).status).toBe(0);
+    const dotfile = path.join(dest, ".gitkeep");
+    writeFileSync(dotfile, "");
+    expect(runSync(FIXTURE_SOURCE, dest).status).toBe(0);
+    expect(existsSync(dotfile)).toBe(true);
+  });
+
+  test("resolves folder-index sidebar links (e.g. /guide/ → guide/README.md)", () => {
+    const folder = mkdtempSync(path.join(tmpdir(), "sync-folder-"));
+    try {
+      const docs = path.join(folder, "docs");
+      const vp = path.join(docs, ".vuepress");
+      mkdirSync(vp, { recursive: true });
+      writeFileSync(
+        path.join(vp, "config.js"),
+        `export default {
+          title: 'Folder-Index Book',
+          theme: { sidebar: [{ text: 'Guide', link: '/guide/' }] },
+        }
+        `,
+      );
+      mkdirSync(path.join(docs, "guide"), { recursive: true });
+      writeFileSync(path.join(docs, "guide", "README.md"), "---\ntitle: Guide\n---\n# Guide\n");
+
+      const res = runSync(docs, dest);
+      expect(res.status).toBe(0);
+      // The chapter id strips the trailing slash, so the folder-index target
+      // exists at <dest>/guide/README.md and the TOC entry's id is `guide`.
+      const { data } = matter(readFileSync(path.join(dest, "index.mdx"), "utf8")) as unknown as { data: Record<string, unknown> };
+      expect((data.chapters as Array<{ id: string }>)[0].id).toBe("guide");
+      expect(existsSync(path.join(dest, "guide", "README.md"))).toBe(true);
+    } finally {
+      rmSync(folder, { recursive: true, force: true });
+    }
+  });
+
+  test("rejects a config.ts with a clear message instead of acorn parse failure", () => {
+    const tsConfig = mkdtempSync(path.join(tmpdir(), "sync-ts-config-"));
+    try {
+      const docs = path.join(tsConfig, "docs");
+      const vp = path.join(docs, ".vuepress");
+      mkdirSync(vp, { recursive: true });
+      writeFileSync(
+        path.join(vp, "config.ts"),
+        "const x: number = 1; export default { theme: { sidebar: [] } }\n",
+      );
+      const res = runSync(docs, dest);
+      expect(res.status).not.toBe(0);
+      expect(res.stderr).toMatch(/config\.ts/);
+      // Match the actionable phrasing only — if a regression let the raw
+      // acorn parse error through, that should fail this assertion.
+      expect(res.stderr).toMatch(/Compile to JavaScript|JS-only/);
+    } finally {
+      rmSync(tsConfig, { recursive: true, force: true });
+    }
+  });
+
+  test("drops a leaf with id 'contents' from the TOC (Amytis renders its own)", () => {
+    const withContents = mkdtempSync(path.join(tmpdir(), "sync-contents-"));
+    try {
+      const docs = path.join(withContents, "docs");
+      const vp = path.join(docs, ".vuepress");
+      mkdirSync(vp, { recursive: true });
+      writeFileSync(
+        path.join(vp, "config.js"),
+        `export default {
+          title: 'TOC-Heavy Book',
+          theme: {
+            sidebar: [
+              { text: '目录', link: 'contents' },
+              { text: 'Real', link: '/real-chapter' },
+            ],
+          },
+        }
+        `,
+      );
+      writeFileSync(path.join(docs, "contents.md"), "# Table of Contents\n- [Real](real-chapter.md)\n");
+      writeFileSync(path.join(docs, "real-chapter.md"), "---\ntitle: Real\n---\n# Real\n");
+
+      const res = runSync(docs, dest);
+      expect(res.status).toBe(0);
+      const { data } = matter(readFileSync(path.join(dest, "index.mdx"), "utf8")) as unknown as { data: Record<string, unknown> };
+      const chapterIds = (data.chapters as Array<{ id?: string; section?: string }>).map(c => c.id ?? c.section);
+      expect(chapterIds).toEqual(["real-chapter"]);
+      // The summary mentions the dropped leaf so the run isn't silent.
+      expect(res.stdout).toMatch(/contents/);
+    } finally {
+      rmSync(withContents, { recursive: true, force: true });
+    }
+  });
+
+  test("exits with an error when a sidebar leaf points to a missing source file", () => {
+    // Create a corrupt config with a broken link.
+    const broken = mkdtempSync(path.join(tmpdir(), "sync-broken-"));
+    try {
+      const docsDir = path.join(broken, "docs");
+      const vp = path.join(docsDir, ".vuepress");
+      mkdirSync(vp, { recursive: true });
+      writeFileSync(
+        path.join(vp, "config.js"),
+        "export default { theme: { sidebar: [{ text: 'Missing', link: '/nope' }] } }\n",
+      );
+      const res = runSync(docsDir, dest);
+      expect(res.status).not.toBe(0);
+      expect(res.stderr).toContain("source files that do not exist");
+    } finally {
+      rmSync(broken, { recursive: true, force: true });
+    }
+  });
+});

package/tests/integration/vuepress-containers.test.ts

@@ -0,0 +1,107 @@
+import { describe, expect, test } from "bun:test";
+import MarkdownRenderer from "@/components/MarkdownRenderer";
+import { renderAsync } from "@/test-utils/render";
+
+describe("Integration: VuePress :::container alerts", () => {
+  test(":::note renders as a note GitHub Alert", async () => {
+    const html = await renderAsync(
+      MarkdownRenderer({ content: "::: note\n\nBody text\n:::" }),
+    );
+    expect(html).toContain('class="alert alert-note"');
+    expect(html).toContain("Body text");
+  });
+
+  test(":::tip preserves a custom title", async () => {
+    const html = await renderAsync(
+      MarkdownRenderer({ content: "::: tip 智慧的疆界\n\nBody\n:::" }),
+    );
+    expect(html).toContain('class="alert alert-tip"');
+    expect(html).toContain("智慧的疆界");
+    // The hardcoded default label should not appear when a custom title is given.
+    expect(html).not.toMatch(/<span>Tip<\/span>/);
+  });
+
+  test(":::warning renders as a warning alert", async () => {
+    const html = await renderAsync(
+      MarkdownRenderer({ content: "::: warning\n\nWatch out\n:::" }),
+    );
+    expect(html).toContain('class="alert alert-warning"');
+  });
+
+  test(":::danger maps to caution (GitHub Alert vocabulary)", async () => {
+    const html = await renderAsync(
+      MarkdownRenderer({ content: "::: danger\n\nUnsafe\n:::" }),
+    );
+    expect(html).toContain('class="alert alert-caution"');
+  });
+
+  test(":::info maps to note", async () => {
+    const html = await renderAsync(
+      MarkdownRenderer({ content: "::: info\n\nFYI\n:::" }),
+    );
+    expect(html).toContain('class="alert alert-note"');
+  });
+
+  test("unknown container names pass through without becoming alerts", async () => {
+    const html = await renderAsync(
+      MarkdownRenderer({ content: "::: random\n\nSomething\n:::" }),
+    );
+    expect(html).not.toContain('class="alert');
+  });
+
+  test("plain content is not rewritten", async () => {
+    const html = await renderAsync(
+      MarkdownRenderer({ content: "Plain paragraph." }),
+    );
+    expect(html).not.toContain('class="alert');
+  });
+
+  test("VuePress syntax inside a fenced code block is NOT rewritten", async () => {
+    // A documentation example showing VuePress syntax verbatim. The normalizer
+    // must skip fenced regions; otherwise the code sample silently becomes the
+    // syntax itself and the doc example breaks.
+    const html = await renderAsync(
+      MarkdownRenderer({
+        content: [
+          "Here is how to write a tip:",
+          "",
+          "```markdown",
+          "::: tip 智慧的疆界",
+          "Body of the tip.",
+          ":::",
+          "```",
+          "",
+          "And here is a real one:",
+          "",
+          "::: tip 真实的提示",
+          "Hello",
+          ":::",
+        ].join("\n"),
+      }),
+    );
+    // The code block keeps the relaxed `::: tip ...` form verbatim — no
+    // `:::tip[...]` rewrite leaks through.
+    expect(html).toContain("::: tip 智慧的疆界");
+    expect(html).not.toContain(":::tip[智慧的疆界]");
+    // The real container outside the code block still renders as an alert.
+    expect(html).toContain('class="alert alert-tip"');
+    expect(html).toContain("真实的提示");
+  });
+
+  test("fence character type matters (~~~ vs ```)", async () => {
+    // A `~~~` fence isn't closed by a ``` line, so the container after the
+    // ``` is still inside the open `~~~` fence and must NOT be rewritten.
+    const html = await renderAsync(
+      MarkdownRenderer({
+        content: [
+          "~~~",
+          "::: tip Inside tilde fence",
+          "```",
+          "::: tip Still inside",
+          "~~~",
+        ].join("\n"),
+      }),
+    );
+    expect(html).not.toContain('class="alert');
+  });
+});

package/tests/tooling/build-pagefind.test.ts

@@ -0,0 +1,66 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import {
+  collectHtmlFileHashes,
+  getPagefindManifestPathForTests,
+  shouldSkipPagefindBuild,
+} from "../../scripts/build-pagefind";
+
+const createdDirs: string[] = [];
+
+afterEach(() => {
+  for (const dir of createdDirs.splice(0)) {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+  fs.rmSync(path.join(process.cwd(), ".cache", "pagefind"), { recursive: true, force: true });
+});
+
+function makeTempDir(prefix: string): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+  createdDirs.push(dir);
+  return dir;
+}
+
+describe("Tooling: build-pagefind", () => {
+  test("collectHtmlFileHashes hashes HTML files by relative path", () => {
+    const siteDir = makeTempDir("amytis-pagefind-site-");
+    fs.mkdirSync(path.join(siteDir, "posts"), { recursive: true });
+    fs.writeFileSync(path.join(siteDir, "index.html"), "<html><body>Home</body></html>", "utf8");
+    fs.writeFileSync(path.join(siteDir, "posts", "hello.html"), "<html><body>Hello</body></html>", "utf8");
+    fs.writeFileSync(path.join(siteDir, "notes.txt"), "ignore", "utf8");
+
+    const hashes = collectHtmlFileHashes(siteDir);
+
+    expect(Object.keys(hashes)).toEqual(["index.html", "posts/hello.html"]);
+    expect(hashes["index.html"]).toBeTruthy();
+    expect(hashes["posts/hello.html"]).toBeTruthy();
+  });
+
+  test("skips Pagefind when HTML hashes and output path are unchanged", () => {
+    const siteDir = makeTempDir("amytis-pagefind-site-");
+    const outputDir = makeTempDir("amytis-pagefind-out-");
+    fs.writeFileSync(path.join(siteDir, "index.html"), "<html><body>Home</body></html>", "utf8");
+    fs.writeFileSync(path.join(outputDir, "pagefind.js"), "stub", "utf8");
+
+    const hashes = collectHtmlFileHashes(siteDir);
+    const manifestPath = getPagefindManifestPathForTests(siteDir, outputDir);
+    fs.mkdirSync(path.dirname(manifestPath), { recursive: true });
+    fs.writeFileSync(
+      manifestPath,
+      JSON.stringify({
+        version: "1",
+        sitePath: path.resolve(siteDir),
+        outputPath: path.resolve(outputDir),
+        files: hashes,
+      }),
+      "utf8",
+    );
+
+    expect(shouldSkipPagefindBuild(siteDir, outputDir, hashes)).toBe(true);
+
+    fs.writeFileSync(path.join(siteDir, "index.html"), "<html><body>Changed</body></html>", "utf8");
+    expect(shouldSkipPagefindBuild(siteDir, outputDir, collectHtmlFileHashes(siteDir))).toBe(false);
+  });
+});

package/tests/tooling/new-post.test.ts

@@ -16,7 +16,7 @@ describe("Tooling: New Post Script", () => {
       if (fs.existsSync(file)) fs.unlinkSync(file);
     });
     createdDirs.forEach(dir => {
-      if (fs.existsSync(dir)) fs.rmdirSync(dir, { recursive: true });
+      if (fs.existsSync(dir)) fs.rmSync(dir, { recursive: true, force: true });
     });
   });