@riebeckite/plugin-diff 0.0.32 → 0.0.33

package/README_ja.md

@@ -32,7 +32,7 @@ const current = await api.getCurrentDiff("notes/hello.md");
 | `getCurrentDiff(filePath)` | 最新と一つ前のリビジョンの差分 |
 | `compareRevisions({ filePath, fromHash, toHash })` | 指定した二つのリビジョンの差分。`fromHash: null` なら空の本文との差分 |
 
-`cwd` は Git リポジトリを探すためのコンテンツルートで、既定値はビルド内の `config.content.directory`、それ以外では `process.cwd()` です。相対パスは `process.cwd()` 基準で解決されます。Git リポジトリ外を指定しても例外は投げず、空の結果を返します。
+`cwd` は Git リポジトリを探すためのコンテンツルートで、既定値はビルド時の `config.content.directory`、それ以外では `process.cwd()` です。相対パスは `process.cwd()` 基準で解決されます。Git リポジトリ外を指定しても例外は送出せず、空の結果を返します。
 
 ## オプションと型
 

package/dist/components/post-diff.d.ts

@@ -5,3 +5,5 @@ export type PostDiffProps = {
 };
 declare const PostDiff: ({ diff, title }: Readonly<PostDiffProps>) => import("hono/jsx/jsx-dev-runtime").JSX.Element;
 export default PostDiff;
+export type ArticlePostDiffProps = Omit<PostDiffProps, "diff">;
+export declare function ArticlePostDiffView(props: Readonly<ArticlePostDiffProps>): Promise<any[] | import("hono/utils/html").HtmlEscapedString>;

package/dist/components/post-diff.js

@@ -1,3 +1,247 @@
+// components/post-diff.tsx
+import { resolvePlugins } from "@riebeckite/core";
+import { useArticleContext, useSiteContext } from "@riebeckite/ui";
+
+// src/diff/line_diff.ts
+function createLineDiff(fromMarkdown, toMarkdown) {
+  const fromLines = splitLines(fromMarkdown);
+  const toLines = splitLines(toMarkdown);
+  const table = buildLongestCommonSubsequenceTable(fromLines, toLines);
+  const lines = [];
+  let fromIndex = 0;
+  let toIndex = 0;
+  let oldLineNumber = 1;
+  let newLineNumber = 1;
+  while (fromIndex < fromLines.length && toIndex < toLines.length) {
+    if (fromLines[fromIndex] === toLines[toIndex]) {
+      lines.push({
+        type: "context",
+        content: fromLines[fromIndex],
+        oldLineNumber,
+        newLineNumber
+      });
+      fromIndex += 1;
+      toIndex += 1;
+      oldLineNumber += 1;
+      newLineNumber += 1;
+      continue;
+    }
+    if (table[fromIndex + 1][toIndex] >= table[fromIndex][toIndex + 1]) {
+      lines.push({
+        type: "removed",
+        content: fromLines[fromIndex],
+        oldLineNumber,
+        newLineNumber: null
+      });
+      fromIndex += 1;
+      oldLineNumber += 1;
+    } else {
+      lines.push({
+        type: "added",
+        content: toLines[toIndex],
+        oldLineNumber: null,
+        newLineNumber
+      });
+      toIndex += 1;
+      newLineNumber += 1;
+    }
+  }
+  while (fromIndex < fromLines.length) {
+    lines.push({
+      type: "removed",
+      content: fromLines[fromIndex],
+      oldLineNumber,
+      newLineNumber: null
+    });
+    fromIndex += 1;
+    oldLineNumber += 1;
+  }
+  while (toIndex < toLines.length) {
+    lines.push({
+      type: "added",
+      content: toLines[toIndex],
+      oldLineNumber: null,
+      newLineNumber
+    });
+    toIndex += 1;
+    newLineNumber += 1;
+  }
+  return lines;
+}
+function splitLines(markdown) {
+  if (!markdown) return [];
+  return markdown.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
+}
+function buildLongestCommonSubsequenceTable(fromLines, toLines) {
+  const table = Array.from(
+    { length: fromLines.length + 1 },
+    () => Array.from({ length: toLines.length + 1 }, () => 0)
+  );
+  for (let fromIndex = fromLines.length - 1; fromIndex >= 0; fromIndex -= 1) {
+    for (let toIndex = toLines.length - 1; toIndex >= 0; toIndex -= 1) {
+      table[fromIndex][toIndex] = fromLines[fromIndex] === toLines[toIndex] ? table[fromIndex + 1][toIndex + 1] + 1 : Math.max(
+        table[fromIndex + 1][toIndex],
+        table[fromIndex][toIndex + 1]
+      );
+    }
+  }
+  return table;
+}
+
+// src/git/history_reader.ts
+import {
+  GitRepository,
+  normalizeContentPath,
+  runGit,
+  toRepositoryPath
+} from "@riebeckite/git-history";
+var fieldSeparator = "";
+var recordSeparator = "";
+var GitMarkdownHistoryReader = class {
+  #repository;
+  #historyCache = /* @__PURE__ */ new Map();
+  #markdownCache = /* @__PURE__ */ new Map();
+  /** Maps a content-relative path to `<revision hash>` → work tree path. */
+  #revisionPathCache = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    this.#repository = new GitRepository(options);
+  }
+  /**
+   * Revision history for one file, newest first, following renames.
+   *
+   * @param filePath Content-relative path, e.g. `notes/hello.md`.
+   */
+  getHistory(filePath) {
+    const normalizedPath = normalizeContentPath(filePath);
+    const cached = this.#historyCache.get(normalizedPath);
+    if (cached) return cached;
+    const history = this.#readHistory(normalizedPath);
+    this.#historyCache.set(normalizedPath, history);
+    return history;
+  }
+  /** Content of one revision of a file, or `null` when Git cannot read it. */
+  getRevisionMarkdown(filePath, hash) {
+    const normalizedPath = normalizeContentPath(filePath);
+    const cacheKey = `${hash}:${normalizedPath}`;
+    const cached = this.#markdownCache.get(cacheKey);
+    if (cached) return cached;
+    const markdown = this.#readRevisionMarkdown(normalizedPath, hash);
+    this.#markdownCache.set(cacheKey, markdown);
+    return markdown;
+  }
+  async #readHistory(filePath) {
+    const repository = await this.#resolvePaths();
+    if (!repository) return [];
+    const format = ["%H", "%h", "%cI", "%s", "%an"].join(fieldSeparator);
+    const result = await runGit(
+      [
+        "log",
+        "--follow",
+        "--name-status",
+        `--format=${recordSeparator}${format}`,
+        "--",
+        toRepositoryPath(repository, filePath)
+      ],
+      repository.repositoryRoot
+    );
+    if (!result.ok || !result.stdout.trim()) return [];
+    const revisionPaths = /* @__PURE__ */ new Map();
+    const fallbackPath = toRepositoryPath(repository, filePath);
+    const revisions = result.stdout.split(recordSeparator).map((record) => record.trim()).filter(Boolean).map((record) => parseRevisionRecord(record, revisionPaths, fallbackPath)).filter((revision) => revision !== null);
+    this.#revisionPathCache.set(filePath, revisionPaths);
+    return revisions;
+  }
+  async #readRevisionMarkdown(filePath, hash) {
+    const repository = await this.#resolvePaths();
+    if (!repository) return null;
+    await this.getHistory(filePath);
+    const revisionPath = this.#revisionPathCache.get(filePath)?.get(hash) ?? toRepositoryPath(repository, filePath);
+    const result = await runGit(
+      ["show", `${hash}:${revisionPath}`],
+      repository.repositoryRoot
+    );
+    return result.ok ? result.stdout : null;
+  }
+  getStateFingerprint() {
+    return this.#repository.getStateFingerprint();
+  }
+  /** `null` when the content directory has no readable work tree. */
+  #resolvePaths() {
+    return this.#repository.paths();
+  }
+};
+function parseRevisionRecord(record, revisionPaths, fallbackPath) {
+  const [metadata = "", ...nameStatusLines] = record.split("\n");
+  const [hash, shortHash, date, message, author] = metadata.split(fieldSeparator);
+  if (!hash || !shortHash || !date) return null;
+  revisionPaths.set(hash, getRevisionPath(nameStatusLines, fallbackPath));
+  return {
+    hash,
+    shortHash,
+    date,
+    message: message ?? "",
+    author: author ?? ""
+  };
+}
+function getRevisionPath(nameStatusLines, fallbackPath) {
+  const line = nameStatusLines.find((entry) => entry.trim().length > 0);
+  if (!line) return fallbackPath;
+  const [, ...paths] = line.split("	");
+  return normalizeContentPath(paths.at(-1) ?? fallbackPath);
+}
+
+// src/api.ts
+function createPostDiffApi(options = {}) {
+  return createPostDiffApiFromReader(new GitMarkdownHistoryReader(options));
+}
+function createPostDiffApiFromReader(reader) {
+  return {
+    getHistory: (filePath) => reader.getHistory(filePath),
+    getRevisionMarkdown: (filePath, hash) => reader.getRevisionMarkdown(filePath, hash),
+    getCurrentDiff: async (filePath) => {
+      const history = await reader.getHistory(filePath);
+      const [current, previous] = history;
+      if (!current) return null;
+      const toMarkdown = await reader.getRevisionMarkdown(
+        filePath,
+        current.hash
+      );
+      if (toMarkdown === null) return null;
+      const fromMarkdown = previous ? await reader.getRevisionMarkdown(filePath, previous.hash) : null;
+      return buildPostDiff({
+        from: previous ?? null,
+        fromMarkdown,
+        to: current,
+        toMarkdown
+      });
+    },
+    compareRevisions: async (input) => {
+      const history = await reader.getHistory(input.filePath);
+      const from = history.find((revision) => revision.hash === input.fromHash);
+      const to = history.find((revision) => revision.hash === input.toHash);
+      if (!to) return null;
+      const [fromMarkdown, toMarkdown] = await Promise.all([
+        input.fromHash ? reader.getRevisionMarkdown(input.filePath, input.fromHash) : Promise.resolve(null),
+        reader.getRevisionMarkdown(input.filePath, input.toHash)
+      ]);
+      if (toMarkdown === null) return null;
+      return buildPostDiff({
+        from: from ?? null,
+        fromMarkdown,
+        to,
+        toMarkdown
+      });
+    }
+  };
+}
+function buildPostDiff(input) {
+  return {
+    from: input.from,
+    to: input.to,
+    lines: createLineDiff(input.fromMarkdown ?? "", input.toMarkdown)
+  };
+}
+
 // components/post-diff.tsx
 import { jsx, jsxs } from "hono/jsx/jsx-runtime";
 var PostDiff = (({ diff, title = "History" }) => {
@@ -23,6 +267,23 @@ var PostDiff = (({ diff, title = "History" }) => {
   ] });
 });
 var post_diff_default = PostDiff;
+async function ArticlePostDiffView(props) {
+  const site = useSiteContext();
+  const article = useArticleContext();
+  if (!site || !article?.entry) return [];
+  const options = findDiffOptions(site.config.plugins);
+  if (!options || options.ui?.enabled === false) return [];
+  const filePath = site.manifest.contentIndex.get(article.entry.slug.toLowerCase()) ?? `${article.entry.slug}.md`;
+  const diff = await createPostDiffApi({
+    ...options,
+    cwd: options.cwd ?? site.config.content.directory
+  }).getCurrentDiff(filePath);
+  return /* @__PURE__ */ jsx(PostDiff, { diff, title: props.title });
+}
+function findDiffOptions(plugins) {
+  return resolvePlugins([...plugins]).find((plugin) => plugin.name === "diff")?.options;
+}
 export {
+  ArticlePostDiffView,
   post_diff_default as default
 };

package/dist/index.d.ts

@@ -1,25 +1,18 @@
 import { type PluginDataHelper } from "@riebeckite/core";
-export type { PostDiffProps } from "./components/post-diff.js";
-export { default as PostDiffView } from "./components/post-diff.js";
+export type { ArticlePostDiffProps, PostDiffProps, } from "./components/post-diff.js";
+export { ArticlePostDiffView, default as PostDiffView, } from "./components/post-diff.js";
 export { renderDiffHistory } from "./src/components/diff-history.js";
 export { renderDiffLine } from "./src/components/diff-line.js";
 export { renderDiffPanel, renderDiffViewer, } from "./src/components/diff-viewer.js";
-import type { DiffPluginUiOptions, DiffRevision, GitHistoryReaderOptions, PostDiff, RevisionComparisonInput } from "./src/types.js";
+import { type PostDiffApi } from "./src/api.js";
+import type { DiffPluginOptions, PostDiff } from "./src/types.js";
+export type { PostDiffApi } from "./src/api.js";
+export { createPostDiffApi } from "./src/api.js";
 export { createLineDiff } from "./src/diff/line_diff.js";
 export { GitMarkdownHistoryReader } from "./src/git/history_reader.js";
-export type { DiffLine, DiffLineType, DiffPluginUiOptions, DiffRevision, GitHistoryReaderOptions, MarkdownRevision, PostDiff, RevisionComparisonInput, } from "./src/types.js";
-export type DiffPluginOptions = GitHistoryReaderOptions & {
-    ui?: DiffPluginUiOptions;
-};
-export type PostDiffApi = {
-    getHistory(filePath: string): Promise<DiffRevision[]>;
-    getRevisionMarkdown(filePath: string, hash: string): Promise<string | null>;
-    getCurrentDiff(filePath: string): Promise<PostDiff | null>;
-    compareRevisions(input: RevisionComparisonInput): Promise<PostDiff | null>;
-};
+export type { DiffLine, DiffLineType, DiffPluginOptions, DiffPluginUiOptions, DiffRevision, GitHistoryReaderOptions, MarkdownRevision, PostDiff, RevisionComparisonInput, } from "./src/types.js";
 export declare const getPostDiff: PluginDataHelper<{
     api: PostDiffApi;
     filePath: string;
 }, Promise<PostDiff | null>>;
 export declare function diff(options?: DiffPluginOptions): import("@riebeckite/core").RiebeckitePlugin<DiffPluginOptions>;
-export declare function createPostDiffApi(options?: GitHistoryReaderOptions): PostDiffApi;

package/dist/index.js

@@ -7,128 +7,8 @@ import {
 } from "@riebeckite/core";
 
 // components/post-diff.tsx
-import { jsx, jsxs } from "hono/jsx/jsx-runtime";
-var PostDiff = (({ diff: diff2, title = "History" }) => {
-  if (!diff2) return null;
-  return /* @__PURE__ */ jsxs("section", { class: "rr-diff-history", "data-rr-diff-history": true, children: [
-    /* @__PURE__ */ jsx("h2", { class: "rr-diff-history__title", children: title }),
-    /* @__PURE__ */ jsxs("p", { class: "rr-diff-history__meta", children: [
-      diff2.from ? `${diff2.from.shortHash} → ` : "",
-      diff2.to.shortHash
-    ] }),
-    /* @__PURE__ */ jsx("pre", { class: "rr-diff-history__diff", children: /* @__PURE__ */ jsx("code", { children: diff2.lines.map((line, index) => /* @__PURE__ */ jsxs(
-      "span",
-      {
-        class: `rr-diff-line rr-diff-line--${line.type}`,
-        children: [
-          line.type === "added" ? "+" : line.type === "removed" ? "-" : " ",
-          line.content,
-          "\n"
-        ]
-      },
-      `${line.oldLineNumber}-${line.newLineNumber}-${index}`
-    )) }) })
-  ] });
-});
-var post_diff_default = PostDiff;
-
-// src/components/diff-line.tsx
-function renderDiffLine({ line }) {
-  const prefix = line.type === "added" ? "+" : line.type === "removed" ? "-" : " ";
-  return `<tr class="rr-diff-history__line rr-diff-history__line--${line.type}">
-    <td class="rr-diff-history__num">${line.oldLineNumber ?? ""}</td>
-    <td class="rr-diff-history__num">${line.newLineNumber ?? ""}</td>
-    <td class="rr-diff-history__code"><code>${prefix} ${escapeHtml(line.content)}</code></td>
-  </tr>`;
-}
-function escapeHtml(value) {
-  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-}
-
-// src/components/format-date.ts
-var MONTHS = [
-  "Jan",
-  "Feb",
-  "Mar",
-  "Apr",
-  "May",
-  "Jun",
-  "Jul",
-  "Aug",
-  "Sep",
-  "Oct",
-  "Nov",
-  "Dec"
-];
-function formatDiffDate(value) {
-  const date = new Date(value);
-  if (Number.isNaN(date.getTime())) return value;
-  return `${MONTHS[date.getUTCMonth()]} ${date.getUTCDate()}`;
-}
-
-// src/components/diff-viewer.tsx
-function renderDiffViewer({
-  history,
-  selected
-}) {
-  return `<div class="rr-diff-history__viewer">
-    <div class="rr-diff-history__controls">
-      <label>From ${renderRevisionSelect("from", history, selected.from?.hash ?? "")}</label>
-      <label>To ${renderRevisionSelect("to", history, selected.to.hash)}</label>
-    </div>
-    <div data-rr-diff-panel>${renderDiffPanel(selected)}</div>
-  </div>`;
-}
-function renderDiffPanel(diff2) {
-  return `<div class="rr-diff-history__diff" data-rr-diff-rendered>
-    <div class="rr-diff-history__table-wrap">
-      <table class="rr-diff-history__table">
-        <tbody>${diff2.lines.map((line) => renderDiffLine({ line })).join("")}</tbody>
-      </table>
-    </div>
-  </div>`;
-}
-function renderRevisionSelect(kind, history, value) {
-  const emptyOption = kind === "from" ? `<option value="">Beginning</option>` : "";
-  return `<select data-rr-diff-${kind}>${emptyOption}${history.map(
-    (revision) => `<option value="${escapeHtml(revision.hash)}"${revision.hash === value ? " selected" : ""}>${escapeHtml(revision.shortHash)} · ${escapeHtml(formatDiffDate(revision.date))}</option>`
-  ).join("")}</select>`;
-}
-
-// src/components/diff-history.tsx
-function renderDiffHistory(input) {
-  const history = input.revisions;
-  const selected = input.selected;
-  const payloadPath = input.payloadPath;
-  if (history.length === 0 || !selected) return "";
-  return `<section class="rr-diff-history" data-rr-diff-history>
-  <details class="rr-diff-history__panel">
-  <summary class="rr-diff-history__header">
-    <h2 class="rr-diff-history__title">History</h2>
-    <span class="rr-diff-history__header-meta"><span class="rr-diff-history__count">${history.length} changes</span><span class="rr-diff-history__toggle-label rr-diff-history__toggle-label--open">Collapse</span><span class="rr-diff-history__toggle-label rr-diff-history__toggle-label--closed">Expand</span><span class="rr-diff-history__toggle" aria-hidden="true"><svg class="rr-diff-history__toggle-icon" viewBox="0 0 16 16" width="16" height="16" focusable="false"><path d="M5.2 3.4 10.8 8l-5.6 4.6" fill="none" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.8"/></svg></span></span>
-  </summary>
-    ${renderContent(history, selected)}
-  </details>
-   ${payloadPath ? `<script type="application/json" data-rr-diff-history-data>${JSON.stringify({ path: payloadPath }).replace(/</g, "\\u003c")}</script>` : ""}
-</section>`;
-}
-function renderContent(history, selected) {
-  return `<div class="rr-diff-history__layout">
-    <ol class="rr-diff-history__list" aria-label="Commit history">
-      ${history.map((revision, index) => renderRevisionButton(revision, index === 0)).join("")}
-    </ol>
-    ${renderDiffViewer({ history, selected })}
-  </div>`;
-}
-function renderRevisionButton(revision, selected) {
-  return `<li class="rr-diff-history__item">
-    <button class="rr-diff-history__commit" type="button" data-rr-diff-select="${escapeHtml(revision.hash)}" aria-pressed="${selected}">
-      <span class="rr-diff-history__date">${escapeHtml(formatDiffDate(revision.date))}</span>
-      <span class="rr-diff-history__message">${escapeHtml(revision.message || "Untitled change")}</span>
-      <span class="rr-diff-history__meta">${escapeHtml(revision.shortHash)} · ${escapeHtml(revision.author)}</span>
-    </button>
-  </li>`;
-}
+import { resolvePlugins } from "@riebeckite/core";
+import { useArticleContext, useSiteContext } from "@riebeckite/ui";
 
 // src/diff/line_diff.ts
 function createLineDiff(fromMarkdown, toMarkdown) {
@@ -217,114 +97,22 @@ function buildLongestCommonSubsequenceTable(fromLines, toLines) {
 }
 
 // src/git/history_reader.ts
-import path2 from "node:path";
-
-// src/git/repo_paths.ts
-import path from "node:path";
-
-// src/git/run_git.ts
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-var execFileAsync = promisify(execFile);
-function isGitCommandFailure(result) {
-  return result.ok === false;
-}
-async function runGit(args, cwd) {
-  try {
-    const { stdout } = await execFileAsync(
-      "git",
-      ["-c", "core.quotePath=false", ...args],
-      {
-        ...cwd === void 0 ? {} : { cwd },
-        maxBuffer: 1024 * 1024 * 10
-      }
-    );
-    return { ok: true, stdout };
-  } catch (error) {
-    return {
-      ok: false,
-      spawnError: isSpawnFailure(readErrorCode(error)),
-      detail: describeGitFailure(error)
-    };
-  }
-}
-function readErrorCode(error) {
-  return typeof error === "object" && error !== null && "code" in error ? error.code : void 0;
-}
-function isSpawnFailure(code) {
-  return typeof code === "string" && !code.startsWith("ERR_");
-}
-function describeGitFailure(error) {
-  if (typeof error !== "object" || error === null) {
-    return error instanceof Error ? error.message : String(error);
-  }
-  const stderr = "stderr" in error ? error.stderr : void 0;
-  if (typeof stderr === "string" && stderr.trim()) return stderr.trim();
-  if (error instanceof Error) return error.message;
-  return String(error);
-}
-
-// src/git/repo_paths.ts
-async function resolveRepositoryPaths(contentRoot) {
-  const resolvedContentRoot = path.resolve(contentRoot);
-  const result = await runGit([
-    "-C",
-    resolvedContentRoot,
-    "rev-parse",
-    "--show-toplevel",
-    "--show-prefix"
-  ]);
-  if (isGitCommandFailure(result)) {
-    return result.spawnError ? { kind: "git-unavailable", detail: result.detail } : { kind: "content-outside-repository", detail: result.detail };
-  }
-  const [toplevel, prefix] = parseRevParseOutput(result.stdout);
-  if (!toplevel) {
-    return {
-      kind: "content-outside-repository",
-      detail: "git rev-parse reported no work tree root"
-    };
-  }
-  return {
-    kind: "resolved",
-    paths: {
-      repositoryRoot: toPosixPath(path.normalize(toplevel)),
-      contentRoot: toPosixPath(resolvedContentRoot),
-      contentPrefix: toPosixPath(prefix).replace(/\/+$/, "")
-    }
-  };
-}
-function toRepositoryPath(paths, contentRelativePath) {
-  const normalized = normalizeContentPath(contentRelativePath);
-  if (!paths.contentPrefix) return normalized;
-  if (!normalized) return paths.contentPrefix;
-  return `${paths.contentPrefix}/${normalized}`;
-}
-function normalizeContentPath(value) {
-  return value.replace(/\\/g, "/").replace(/^\.\//, "");
-}
-function isResolvedRepository(resolution) {
-  return resolution.kind === "resolved";
-}
-function parseRevParseOutput(stdout) {
-  const [toplevel = "", prefix = ""] = stdout.split(/\r?\n/);
-  return [toplevel.trim(), prefix.trim()];
-}
-function toPosixPath(value) {
-  return value.replace(/\\/g, "/");
-}
-
-// src/git/history_reader.ts
+import {
+  GitRepository,
+  normalizeContentPath,
+  runGit,
+  toRepositoryPath
+} from "@riebeckite/git-history";
 var fieldSeparator = "";
 var recordSeparator = "";
 var GitMarkdownHistoryReader = class {
-  #contentRoot;
+  #repository;
   #historyCache = /* @__PURE__ */ new Map();
   #markdownCache = /* @__PURE__ */ new Map();
   /** Maps a content-relative path to `<revision hash>` → work tree path. */
   #revisionPathCache = /* @__PURE__ */ new Map();
-  #repository;
   constructor(options = {}) {
-    this.#contentRoot = path2.resolve(options.cwd ?? process.cwd());
+    this.#repository = new GitRepository(options);
   }
   /**
    * Revision history for one file, newest first, following renames.
@@ -382,29 +170,12 @@ var GitMarkdownHistoryReader = class {
     );
     return result.ok ? result.stdout : null;
   }
-  async getStateFingerprint() {
-    const repository = await this.#resolvePaths();
-    if (!repository) return null;
-    const results = await Promise.all([
-      runGit(["rev-parse", "HEAD"], repository.repositoryRoot),
-      runGit(
-        ["status", "--porcelain=v1", "--untracked-files=all"],
-        repository.repositoryRoot
-      ),
-      runGit(
-        ["for-each-ref", "--format=%(refname):%(objectname)"],
-        repository.repositoryRoot
-      )
-    ]);
-    if (results.some((result) => !result.ok)) return null;
-    return results.filter((result) => result.ok).map((result) => result.stdout).join("");
+  getStateFingerprint() {
+    return this.#repository.getStateFingerprint();
   }
   /** `null` when the content directory has no readable work tree. */
-  async #resolvePaths() {
-    this.#repository ??= resolveRepositoryPaths(this.#contentRoot);
-    const resolution = await this.#repository;
-    if (!isResolvedRepository(resolution)) return null;
-    return resolution.paths;
+  #resolvePaths() {
+    return this.#repository.paths();
   }
 };
 function parseRevisionRecord(record, revisionPaths, fallbackPath) {
@@ -427,8 +198,212 @@ function getRevisionPath(nameStatusLines, fallbackPath) {
   return normalizeContentPath(paths.at(-1) ?? fallbackPath);
 }
 
+// src/api.ts
+function createPostDiffApi(options = {}) {
+  return createPostDiffApiFromReader(new GitMarkdownHistoryReader(options));
+}
+function createPostDiffApiFromReader(reader) {
+  return {
+    getHistory: (filePath) => reader.getHistory(filePath),
+    getRevisionMarkdown: (filePath, hash) => reader.getRevisionMarkdown(filePath, hash),
+    getCurrentDiff: async (filePath) => {
+      const history = await reader.getHistory(filePath);
+      const [current, previous] = history;
+      if (!current) return null;
+      const toMarkdown = await reader.getRevisionMarkdown(
+        filePath,
+        current.hash
+      );
+      if (toMarkdown === null) return null;
+      const fromMarkdown = previous ? await reader.getRevisionMarkdown(filePath, previous.hash) : null;
+      return buildPostDiff({
+        from: previous ?? null,
+        fromMarkdown,
+        to: current,
+        toMarkdown
+      });
+    },
+    compareRevisions: async (input) => {
+      const history = await reader.getHistory(input.filePath);
+      const from = history.find((revision) => revision.hash === input.fromHash);
+      const to = history.find((revision) => revision.hash === input.toHash);
+      if (!to) return null;
+      const [fromMarkdown, toMarkdown] = await Promise.all([
+        input.fromHash ? reader.getRevisionMarkdown(input.filePath, input.fromHash) : Promise.resolve(null),
+        reader.getRevisionMarkdown(input.filePath, input.toHash)
+      ]);
+      if (toMarkdown === null) return null;
+      return buildPostDiff({
+        from: from ?? null,
+        fromMarkdown,
+        to,
+        toMarkdown
+      });
+    }
+  };
+}
+async function getMarkdownRevisions(api, filePath, history) {
+  const revisions = await Promise.all(
+    history.map(async (revision) => ({
+      revision,
+      markdown: await api.getRevisionMarkdown(filePath, revision.hash)
+    }))
+  );
+  return revisions.flatMap(
+    ({ revision, markdown }) => markdown === null ? [] : [{ ...revision, markdown }]
+  );
+}
+function buildPostDiff(input) {
+  return {
+    from: input.from,
+    to: input.to,
+    lines: createLineDiff(input.fromMarkdown ?? "", input.toMarkdown)
+  };
+}
+
+// components/post-diff.tsx
+import { jsx, jsxs } from "hono/jsx/jsx-runtime";
+var PostDiff = (({ diff: diff2, title = "History" }) => {
+  if (!diff2) return null;
+  return /* @__PURE__ */ jsxs("section", { class: "rr-diff-history", "data-rr-diff-history": true, children: [
+    /* @__PURE__ */ jsx("h2", { class: "rr-diff-history__title", children: title }),
+    /* @__PURE__ */ jsxs("p", { class: "rr-diff-history__meta", children: [
+      diff2.from ? `${diff2.from.shortHash} → ` : "",
+      diff2.to.shortHash
+    ] }),
+    /* @__PURE__ */ jsx("pre", { class: "rr-diff-history__diff", children: /* @__PURE__ */ jsx("code", { children: diff2.lines.map((line, index) => /* @__PURE__ */ jsxs(
+      "span",
+      {
+        class: `rr-diff-line rr-diff-line--${line.type}`,
+        children: [
+          line.type === "added" ? "+" : line.type === "removed" ? "-" : " ",
+          line.content,
+          "\n"
+        ]
+      },
+      `${line.oldLineNumber}-${line.newLineNumber}-${index}`
+    )) }) })
+  ] });
+});
+var post_diff_default = PostDiff;
+async function ArticlePostDiffView(props) {
+  const site = useSiteContext();
+  const article = useArticleContext();
+  if (!site || !article?.entry) return [];
+  const options = findDiffOptions(site.config.plugins);
+  if (!options || options.ui?.enabled === false) return [];
+  const filePath = site.manifest.contentIndex.get(article.entry.slug.toLowerCase()) ?? `${article.entry.slug}.md`;
+  const diff2 = await createPostDiffApi({
+    ...options,
+    cwd: options.cwd ?? site.config.content.directory
+  }).getCurrentDiff(filePath);
+  return /* @__PURE__ */ jsx(PostDiff, { diff: diff2, title: props.title });
+}
+function findDiffOptions(plugins) {
+  return resolvePlugins([...plugins]).find((plugin) => plugin.name === "diff")?.options;
+}
+
+// src/components/diff-line.tsx
+function renderDiffLine({ line }) {
+  const prefix = line.type === "added" ? "+" : line.type === "removed" ? "-" : " ";
+  return `<tr class="rr-diff-history__line rr-diff-history__line--${line.type}">
+    <td class="rr-diff-history__num">${line.oldLineNumber ?? ""}</td>
+    <td class="rr-diff-history__num">${line.newLineNumber ?? ""}</td>
+    <td class="rr-diff-history__code"><code>${prefix} ${escapeHtml(line.content)}</code></td>
+  </tr>`;
+}
+function escapeHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+
+// src/components/format-date.ts
+var MONTHS = [
+  "Jan",
+  "Feb",
+  "Mar",
+  "Apr",
+  "May",
+  "Jun",
+  "Jul",
+  "Aug",
+  "Sep",
+  "Oct",
+  "Nov",
+  "Dec"
+];
+function formatDiffDate(value) {
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) return value;
+  return `${MONTHS[date.getUTCMonth()]} ${date.getUTCDate()}`;
+}
+
+// src/components/diff-viewer.tsx
+function renderDiffViewer({
+  history,
+  selected
+}) {
+  return `<div class="rr-diff-history__viewer">
+    <div class="rr-diff-history__controls">
+      <label>From ${renderRevisionSelect("from", history, selected.from?.hash ?? "")}</label>
+      <label>To ${renderRevisionSelect("to", history, selected.to.hash)}</label>
+    </div>
+    <div data-rr-diff-panel>${renderDiffPanel(selected)}</div>
+  </div>`;
+}
+function renderDiffPanel(diff2) {
+  return `<div class="rr-diff-history__diff" data-rr-diff-rendered>
+    <div class="rr-diff-history__table-wrap">
+      <table class="rr-diff-history__table">
+        <tbody>${diff2.lines.map((line) => renderDiffLine({ line })).join("")}</tbody>
+      </table>
+    </div>
+  </div>`;
+}
+function renderRevisionSelect(kind, history, value) {
+  const emptyOption = kind === "from" ? `<option value="">Beginning</option>` : "";
+  return `<select data-rr-diff-${kind}>${emptyOption}${history.map(
+    (revision) => `<option value="${escapeHtml(revision.hash)}"${revision.hash === value ? " selected" : ""}>${escapeHtml(revision.shortHash)} · ${escapeHtml(formatDiffDate(revision.date))}</option>`
+  ).join("")}</select>`;
+}
+
+// src/components/diff-history.tsx
+function renderDiffHistory(input) {
+  const history = input.revisions;
+  const selected = input.selected;
+  const payloadPath = input.payloadPath;
+  if (history.length === 0 || !selected) return "";
+  return `<section class="rr-diff-history" data-rr-diff-history>
+  <details class="rr-diff-history__panel">
+  <summary class="rr-diff-history__header">
+    <h2 class="rr-diff-history__title">History</h2>
+    <span class="rr-diff-history__header-meta"><span class="rr-diff-history__count">${history.length} changes</span><span class="rr-diff-history__toggle-label rr-diff-history__toggle-label--open">Collapse</span><span class="rr-diff-history__toggle-label rr-diff-history__toggle-label--closed">Expand</span><span class="rr-diff-history__toggle" aria-hidden="true"><svg class="rr-diff-history__toggle-icon" viewBox="0 0 16 16" width="16" height="16" focusable="false"><path d="M5.2 3.4 10.8 8l-5.6 4.6" fill="none" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.8"/></svg></span></span>
+  </summary>
+    ${renderContent(history, selected)}
+  </details>
+   ${payloadPath ? `<script type="application/json" data-rr-diff-history-data>${JSON.stringify({ path: payloadPath }).replace(/</g, "\\u003c")}</script>` : ""}
+</section>`;
+}
+function renderContent(history, selected) {
+  return `<div class="rr-diff-history__layout">
+    <ol class="rr-diff-history__list" aria-label="Commit history">
+      ${history.map((revision, index) => renderRevisionButton(revision, index === 0)).join("")}
+    </ol>
+    ${renderDiffViewer({ history, selected })}
+  </div>`;
+}
+function renderRevisionButton(revision, selected) {
+  return `<li class="rr-diff-history__item">
+    <button class="rr-diff-history__commit" type="button" data-rr-diff-select="${escapeHtml(revision.hash)}" aria-pressed="${selected}">
+      <span class="rr-diff-history__date">${escapeHtml(formatDiffDate(revision.date))}</span>
+      <span class="rr-diff-history__message">${escapeHtml(revision.message || "Untitled change")}</span>
+      <span class="rr-diff-history__meta">${escapeHtml(revision.shortHash)} · ${escapeHtml(revision.author)}</span>
+    </button>
+  </li>`;
+}
+
 // index.ts
 var getPostDiff = ({ api, filePath }) => api.getCurrentDiff(filePath);
+var manifestConcurrency = 12;
 function diff(options = {}) {
   const ui = { enabled: true, maxRevisions: 20, ...options.ui };
   let api;
@@ -486,28 +461,40 @@ function diff(options = {}) {
         return;
       }
       api ??= createPostDiffApiFromReader(snapshot.value);
-      for (const entry of context.manifest.discoverableEntries) {
-        const filePath = resolvePostFilePath({
-          slug: entry.slug,
-          contentIndex: context.contentIndex
-        });
-        const history = (await api.getHistory(filePath)).slice(
-          0,
-          ui.maxRevisions
+      const postDiffApi = api;
+      const entries = context.manifest.discoverableEntries;
+      for (let index = 0; index < entries.length; index += manifestConcurrency) {
+        const outputs = await Promise.all(
+          entries.slice(index, index + manifestConcurrency).map(async (entry) => {
+            const filePath = resolvePostFilePath({
+              slug: entry.slug,
+              contentIndex: context.contentIndex
+            });
+            const history = (await postDiffApi.getHistory(filePath)).slice(
+              0,
+              ui.maxRevisions
+            );
+            const revisions = await getMarkdownRevisions(
+              postDiffApi,
+              filePath,
+              history
+            );
+            if (revisions.length === 0) return void 0;
+            const selected = await postDiffApi.getCurrentDiff(filePath);
+            if (!selected) return void 0;
+            return {
+              path: diffPayloadPath(entry.slug),
+              content: JSON.stringify({ revisions }).replace(/</g, "\\u003c"),
+              dependencies: [
+                { type: "content", slug: entry.slug },
+                { type: "external", id: "diff:git-history" }
+              ]
+            };
+          })
         );
-        const revisions = await getMarkdownRevisions(api, filePath, history);
-        if (revisions.length === 0) continue;
-        const selected = await api.getCurrentDiff(filePath);
-        if (!selected) continue;
-        const payloadPath = diffPayloadPath(entry.slug);
-        context.output.emit({
-          path: payloadPath,
-          content: JSON.stringify({ revisions }).replace(/</g, "\\u003c"),
-          dependencies: [
-            { type: "content", slug: entry.slug },
-            { type: "external", id: "diff:git-history" }
-          ]
-        });
+        for (const output of outputs) {
+          if (output) context.output.emit(output);
+        }
       }
     }
   });
@@ -515,73 +502,13 @@ function diff(options = {}) {
 function diffPayloadPath(slug) {
   return `_riebeckite/diff/${Buffer.from(slug).toString("base64url")}.json`;
 }
-function createPostDiffApi(options = {}) {
-  return createPostDiffApiFromReader(new GitMarkdownHistoryReader(options));
-}
-function createPostDiffApiFromReader(reader) {
-  return {
-    getHistory: (filePath) => reader.getHistory(filePath),
-    getRevisionMarkdown: (filePath, hash) => reader.getRevisionMarkdown(filePath, hash),
-    getCurrentDiff: async (filePath) => {
-      const history = await reader.getHistory(filePath);
-      const [current, previous] = history;
-      if (!current) return null;
-      const toMarkdown = await reader.getRevisionMarkdown(
-        filePath,
-        current.hash
-      );
-      if (toMarkdown === null) return null;
-      const fromMarkdown = previous ? await reader.getRevisionMarkdown(filePath, previous.hash) : null;
-      return buildPostDiff({
-        from: previous ?? null,
-        fromMarkdown,
-        to: current,
-        toMarkdown
-      });
-    },
-    compareRevisions: async (input) => {
-      const history = await reader.getHistory(input.filePath);
-      const from = history.find((revision) => revision.hash === input.fromHash);
-      const to = history.find((revision) => revision.hash === input.toHash);
-      if (!to) return null;
-      const [fromMarkdown, toMarkdown] = await Promise.all([
-        input.fromHash ? reader.getRevisionMarkdown(input.filePath, input.fromHash) : Promise.resolve(null),
-        reader.getRevisionMarkdown(input.filePath, input.toHash)
-      ]);
-      if (toMarkdown === null) return null;
-      return buildPostDiff({
-        from: from ?? null,
-        fromMarkdown,
-        to,
-        toMarkdown
-      });
-    }
-  };
-}
-async function getMarkdownRevisions(api, filePath, history) {
-  const revisions = await Promise.all(
-    history.map(async (revision) => ({
-      revision,
-      markdown: await api.getRevisionMarkdown(filePath, revision.hash)
-    }))
-  );
-  return revisions.flatMap(
-    ({ revision, markdown }) => markdown === null ? [] : [{ ...revision, markdown }]
-  );
-}
 function resolvePostFilePath(context) {
   const indexedPath = context.contentIndex.get(context.slug.toLowerCase());
   const contentPath = `${indexedPath ?? context.slug}.md`;
   return contentPath;
 }
-function buildPostDiff(input) {
-  return {
-    from: input.from,
-    to: input.to,
-    lines: createLineDiff(input.fromMarkdown ?? "", input.toMarkdown)
-  };
-}
 export {
+  ArticlePostDiffView,
   GitMarkdownHistoryReader,
   post_diff_default as PostDiffView,
   createLineDiff,

package/dist/src/api.d.ts

@@ -0,0 +1,11 @@
+import { GitMarkdownHistoryReader } from "./git/history_reader.js";
+import type { DiffRevision, GitHistoryReaderOptions, MarkdownRevision, PostDiff, RevisionComparisonInput } from "./types.js";
+export type PostDiffApi = {
+    getHistory(filePath: string): Promise<DiffRevision[]>;
+    getRevisionMarkdown(filePath: string, hash: string): Promise<string | null>;
+    getCurrentDiff(filePath: string): Promise<PostDiff | null>;
+    compareRevisions(input: RevisionComparisonInput): Promise<PostDiff | null>;
+};
+export declare function createPostDiffApi(options?: GitHistoryReaderOptions): PostDiffApi;
+export declare function createPostDiffApiFromReader(reader: GitMarkdownHistoryReader): PostDiffApi;
+export declare function getMarkdownRevisions(api: PostDiffApi, filePath: string, history: DiffRevision[]): Promise<MarkdownRevision[]>;

package/dist/src/components/diff-history.d.ts

@@ -1,7 +1,8 @@
 import type { MarkdownRevision, PostDiff } from "../types.js";
-export type DiffHistoryProps = {
+type DiffHistoryProps = {
     revisions: MarkdownRevision[];
     selected: PostDiff | null;
     payloadPath?: string;
 };
 export declare function renderDiffHistory(input: DiffHistoryProps): string;
+export {};

package/dist/src/components/diff-line.d.ts

@@ -1,6 +1,7 @@
 import type { PostDiff } from "../types.js";
-export type DiffLineProps = {
+type DiffLineProps = {
     line: PostDiff["lines"][number];
 };
 export declare function renderDiffLine({ line }: DiffLineProps): string;
 export declare function escapeHtml(value: string): string;
+export {};

package/dist/src/components/diff-viewer.d.ts

@@ -1,7 +1,8 @@
 import type { DiffRevision, PostDiff } from "../types.js";
-export type DiffViewerProps = {
+type DiffViewerProps = {
     history: DiffRevision[];
     selected: PostDiff;
 };
 export declare function renderDiffViewer({ history, selected, }: DiffViewerProps): string;
 export declare function renderDiffPanel(diff: PostDiff): string;
+export {};

package/dist/src/types.d.ts

@@ -38,3 +38,6 @@ export type DiffPluginUiOptions = {
     enabled?: boolean;
     maxRevisions?: number;
 };
+export type DiffPluginOptions = GitHistoryReaderOptions & {
+    ui?: DiffPluginUiOptions;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@riebeckite/plugin-diff",
-  "version": "0.0.32",
+  "version": "0.0.33",
   "license": "Apache-2.0",
   "type": "module",
   "main": "./dist/index.js",
@@ -27,13 +27,15 @@
     "./style.css": "./style.css"
   },
   "dependencies": {
-    "hono": "^4.12.25",
-    "@riebeckite/core": "0.0.32"
+    "@riebeckite/core": "0.0.33",
+    "@riebeckite/git-history": "0.0.33",
+    "@riebeckite/ui": "0.0.33",
+    "hono": "^4.12.25"
   },
   "devDependencies": {
+    "@riebeckite/test": "0.0.33",
     "@types/node": "^24.5.2",
-    "tsx": "^4.22.4",
-    "@riebeckite/test": "0.0.32"
+    "tsx": "^4.22.4"
   },
   "publishConfig": {
     "access": "public"

package/dist/src/git/repo_paths.d.ts

@@ -1,76 +0,0 @@
-/**
- * The paths that locate a content directory inside a Git work tree.
- *
- * Every field is a POSIX-separated path (`git` prints and accepts those on every
- * platform, including Windows).
- */
-export type GitRepositoryPaths = {
-    /** Work tree root reported by `git rev-parse --show-toplevel`. */
-    repositoryRoot: string;
-    /** Absolute path of the content directory. */
-    contentRoot: string;
-    /**
-     * Content directory relative to `repositoryRoot`, without a trailing slash.
-     * Empty when the content directory is the work tree root itself.
-     */
-    contentPrefix: string;
-};
-/**
- * Why Git history cannot be read for a content directory.
- *
- * The reason is modelled explicitly so a plugin can report an actionable
- * diagnostic instead of quietly rendering nothing.
- */
-export type RepositoryPathsResolution = {
-    kind: "resolved";
-    paths: GitRepositoryPaths;
-}
-/** Git is not installed, or could not be started. */
- | {
-    kind: "git-unavailable";
-    detail: string;
-}
-/** Git ran, but the content directory does not live in a work tree. */
- | {
-    kind: "content-outside-repository";
-    detail: string;
-};
-/**
- * Locates the Git work tree that owns `contentRoot`.
- *
- * Both the work tree root and the content prefix come from Git itself, so their
- * casing and symlink resolution always agree with the paths `git log` prints —
- * the reason content-relative paths can be translated without guessing.
- *
- * The work tree is resolved through `git -C <contentRoot>` rather than by
- * running Git in `contentRoot`, so a missing directory surfaces as a Git
- * failure instead of an indistinguishable spawn failure.
- */
-export declare function resolveRepositoryPaths(contentRoot: string): Promise<RepositoryPathsResolution>;
-/**
- * Translates a content-relative path into the work tree-relative path that
- * `git log` pathspecs and `git show <rev>:<path>` expect.
- */
-export declare function toRepositoryPath(paths: GitRepositoryPaths, contentRelativePath: string): string;
-/**
- * Translates a work tree-relative path printed by `git` back into a
- * content-relative path, or returns `null` when the path lies outside the
- * content directory.
- */
-export declare function toContentPath(paths: GitRepositoryPaths, repositoryRelativePath: string): string | null;
-/** Normalizes a path to the POSIX form used for content and work tree paths. */
-export declare function normalizeContentPath(value: string): string;
-/**
- * True when the content directory has a usable work tree. Narrows the
- * resolution so callers can read `paths`.
- */
-export declare function isResolvedRepository(resolution: RepositoryPathsResolution): resolution is Extract<RepositoryPathsResolution, {
-    kind: "resolved";
-}>;
-/**
- * True when history cannot be read and a reason is available. Narrows the
- * resolution so callers can read `detail`.
- */
-export declare function isRepositoryUnavailable(resolution: RepositoryPathsResolution): resolution is Exclude<RepositoryPathsResolution, {
-    kind: "resolved";
-}>;

package/dist/src/git/run_git.d.ts

@@ -1,43 +0,0 @@
-/**
- * Result of a `git` invocation.
- *
- * Failures are returned instead of thrown: a site whose Git history cannot be
- * read must still build, so every caller decides what an unavailable repository
- * means for its own output.
- */
-export type GitCommandResult = {
-    ok: true;
-    stdout: string;
-}
-/**
- * `spawnError` separates "Git could not be started" (missing or unexecutable
- * binary) from "Git ran and rejected the command" (not a work tree, unknown
- * revision, unreadable path). The distinction drives which diagnostic a
- * plugin reports.
- */
- | {
-    ok: false;
-    spawnError: boolean;
-    detail: string;
-};
-/**
- * Narrows a failed command so its failure fields can be read.
- *
- * Type predicates are used instead of `result.ok` checks throughout this
- * package because the build type-checks without `strictNullChecks`, where
- * discriminant narrowing of an inline condition does not apply.
- */
-export declare function isGitCommandFailure(result: GitCommandResult): result is Extract<GitCommandResult, {
-    ok: false;
-}>;
-/**
- * Runs `git` with `args`.
- *
- * `core.quotePath=false` keeps non-ASCII paths verbatim so the printed paths
- * match the ones the content index reports; Git otherwise escapes them into
- * octal sequences that no path lookup can resolve.
- *
- * @param cwd Directory Git runs in. Omit when the command carries its own
- *   `-C <dir>` argument.
- */
-export declare function runGit(args: readonly string[], cwd?: string): Promise<GitCommandResult>;