@riebeckite/plugin-diff 0.0.1

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright Rerurate_514
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,90 @@
+# @riebeckite/plugin-diff
+
+Git-backed diff and revision history for Markdown notes: read commit history,
+retrieve past revisions, and compute line-level diffs between them.
+
+[日本語](./README_ja.md)
+
+## Overview
+
+`createPostDiffApi()` wraps a local Git repository and exposes revision
+history plus line diffs for any Markdown file, even when the note was renamed
+or moved (`git log --follow`). `createLineDiff()` is the pure diff engine used
+by the API and is also exported for standalone use.
+
+The `diff()` plugin registers a `diff` entry in the plugin list; the
+programmatic API is the primary interface.
+
+## Usage (plugin)
+
+```ts
+import { defineConfig } from "@riebeckite/core";
+import { diff } from "@riebeckite/plugin-diff";
+
+export default defineConfig({
+  // ...
+  plugins: [diff({ cwd: "./content" })],
+});
+```
+
+`diff(options?)` accepts the same `GitHistoryReaderOptions` as the API.
+
+## Programmatic API
+
+```ts
+import { createPostDiffApi } from "@riebeckite/plugin-diff";
+
+const api = createPostDiffApi({ cwd: "./content" });
+
+const history = await api.getHistory("notes/hello.md");
+const previous = await api.getRevisionMarkdown("notes/hello.md", history[1].hash);
+const current = await api.getCurrentDiff("notes/hello.md");
+const compare = await api.compareRevisions({
+  filePath: "notes/hello.md",
+  fromHash: history[1].hash,
+  toHash: history[0].hash,
+});
+```
+
+- `getHistory(filePath)` — commit history for the file (newest first) as
+  `DiffRevision[]`
+- `getRevisionMarkdown(filePath, hash)` — Markdown source at a given revision,
+  or `null`
+- `getCurrentDiff(filePath)` — line diff between the latest revision and its
+  predecessor (or from an empty source when there is no predecessor)
+- `compareRevisions({ filePath, fromHash, toHash })` — line diff between two
+  revisions; `fromHash: null` diffs from an empty source
+
+## Options
+
+`createPostDiffApi(options?)` accepts `GitHistoryReaderOptions`:
+
+| Option | Type | Default | Description |
+| ------ | ---- | ------- | ----------- |
+| `cwd` | `string` | `process.cwd()` | Working directory for Git commands |
+
+When `cwd` is not inside a Git repository, API calls resolve to empty results
+(`[]` / `null`) instead of throwing.
+
+## Types
+
+| Type | Description |
+| ---- | ----------- |
+| `DiffRevision` | Commit metadata: `hash`, `shortHash`, `date`, `message`, `author` |
+| `MarkdownRevision` | `DiffRevision` with the Markdown source |
+| `PostDiff` | `from`, `to`, and `lines` |
+| `DiffLine` | A single diff line: `{ type, content }` |
+| `DiffLineType` | `"context" \| "added" \| "removed"` |
+| `RevisionComparisonInput` | `{ filePath, fromHash: string \| null, toHash }` |
+
+## Exports
+
+- `diff(options?)` — plugin factory
+- `createPostDiffApi(options?)` — programmatic API factory
+- `createLineDiff(from, to)` — LCS-based line diff
+- `GitMarkdownHistoryReader` — Git-backed history reader class
+- Types listed above
+
+## See also
+
+- [Plugin guide](../../docs/plugins_en.md)

package/README_ja.md

@@ -0,0 +1,41 @@
+# @riebeckite/plugin-diff
+
+ローカル Git リポジトリから、Markdown ノートの履歴と行単位の差分を取得するプラグインです。
+
+[English](./README.md)
+
+## できること
+
+中心となる API は `createPostDiffApi()` です。リネームや移動後のファイルも `git log --follow` で追跡し、履歴、指定リビジョンの本文、任意の二つのリビジョン間の差分を返します。`createLineDiff()` は単独でも使える純粋な差分関数です。
+
+## 設定と利用例
+
+```ts
+import { defineConfig } from "@riebeckite/core";
+import { createPostDiffApi, diff } from "@riebeckite/plugin-diff";
+
+export default defineConfig({ plugins: [diff({ cwd: "./content" })] });
+
+const api = createPostDiffApi({ cwd: "./content" });
+const history = await api.getHistory("notes/hello.md");
+const current = await api.getCurrentDiff("notes/hello.md");
+```
+
+| API | 返す内容 |
+| --- | --- |
+| `getHistory(filePath)` | 新しい順の `DiffRevision[]` |
+| `getRevisionMarkdown(filePath, hash)` | その時点の Markdown。なければ `null` |
+| `getCurrentDiff(filePath)` | 最新と一つ前のリビジョンの差分 |
+| `compareRevisions(input)` | 指定した二つのリビジョンの差分 |
+
+`cwd` は Git コマンドを実行するディレクトリで、既定値は `process.cwd()` です。Git リポジトリ外を指定しても例外は投げず、空の結果を返します。
+
+## 公開 API
+
+- `diff(options?)`、`createPostDiffApi(options?)`
+- `createLineDiff(from, to)`、`GitMarkdownHistoryReader`
+- `DiffRevision`、`MarkdownRevision`、`PostDiff`、`DiffLine`、`DiffLineType`、`RevisionComparisonInput`
+
+## 関連資料
+
+- [プラグインシステム](../../../docs/ja/plugin-system.md)

package/dist/client/diff-viewer.d.ts

@@ -0,0 +1 @@
+export declare function initDiffHistory(): void;

package/dist/client.d.ts

@@ -0,0 +1 @@
+export { initDiffHistory } from "./client/diff-viewer.js";

package/dist/client.js

@@ -0,0 +1,89 @@
+// src/components/diff-line.tsx
+function escapeHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+
+// client/diff-viewer.ts
+function initDiffHistory() {
+  for (const root of document.querySelectorAll(
+    "[data-rr-diff-history]"
+  )) {
+    initDiffHistoryRoot(root);
+  }
+}
+function initDiffHistoryRoot(root) {
+  const payload = readPayload(root);
+  if (!payload || payload.diffs.length === 0) return;
+  const fromSelect = root.querySelector(
+    "[data-rr-diff-from]"
+  );
+  const toSelect = root.querySelector("[data-rr-diff-to]");
+  const panel = root.querySelector("[data-rr-diff-panel]");
+  if (!fromSelect || !toSelect || !panel) return;
+  for (const button of root.querySelectorAll(
+    "[data-rr-diff-select]"
+  )) {
+    button.addEventListener("click", () => {
+      const toHash = button.dataset.rrDiffSelect;
+      const diff = payload.diffs.find((entry) => entry.to.hash === toHash);
+      if (!diff) return;
+      fromSelect.value = diff.from?.hash ?? "";
+      toSelect.value = diff.to.hash;
+      updateSelectedCommit(root, diff.to.hash);
+      renderPanel(panel, diff);
+    });
+  }
+  const updateFromSelects = () => {
+    const diff = payload.diffs.find(
+      (entry) => (entry.from?.hash ?? "") === fromSelect.value && entry.to.hash === toSelect.value
+    );
+    if (!diff) return;
+    updateSelectedCommit(root, diff.to.hash);
+    renderPanel(panel, diff);
+  };
+  fromSelect.addEventListener("change", updateFromSelects);
+  toSelect.addEventListener("change", updateFromSelects);
+}
+function readPayload(root) {
+  const script = root.querySelector(
+    "[data-rr-diff-history-data]"
+  );
+  if (!script?.textContent) return null;
+  try {
+    return JSON.parse(script.textContent);
+  } catch {
+    return null;
+  }
+}
+function updateSelectedCommit(root, hash) {
+  for (const button of root.querySelectorAll(
+    "[data-rr-diff-select]"
+  )) {
+    button.setAttribute(
+      "aria-pressed",
+      String(button.dataset.rrDiffSelect === hash)
+    );
+  }
+}
+function renderPanel(panel, diff) {
+  const fromLabel = diff.from?.shortHash ?? "Beginning";
+  panel.innerHTML = `<div class="rr-diff-history__diff" data-rr-diff-rendered>
+    <div class="rr-diff-history__diff-head">${escapeHtml(fromLabel)} → ${escapeHtml(diff.to.shortHash)}</div>
+    <div class="rr-diff-history__table-wrap">
+      <table class="rr-diff-history__table">
+        <tbody>${diff.lines.map(renderLine).join("")}</tbody>
+      </table>
+    </div>
+  </div>`;
+}
+function renderLine(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>`;
+}
+export {
+  initDiffHistory
+};

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+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";
+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 declare function diff(options?: DiffPluginOptions): import("@riebeckite/core").RiebeckitePlugin<DiffPluginOptions>;
+export declare function createPostDiffApi(options?: GitHistoryReaderOptions): PostDiffApi;

package/dist/index.js

@@ -0,0 +1,394 @@
+// index.ts
+import {
+  createClientEntry,
+  createStyleAsset,
+  definePlugin
+} from "@riebeckite/core";
+
+// 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/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) {
+  const fromLabel = diff2.from?.shortHash ?? "Beginning";
+  return `<div class="rr-diff-history__diff" data-rr-diff-rendered>
+    <div class="rr-diff-history__diff-head">${escapeHtml(fromLabel)} → ${escapeHtml(diff2.to.shortHash)}</div>
+    <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(formatDate(revision.date))}</option>`
+  ).join("")}</select>`;
+}
+function formatDate(value) {
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) return value;
+  return date.toLocaleDateString("en", { month: "short", day: "numeric" });
+}
+
+// src/components/diff-history.tsx
+function renderDiffHistory(input) {
+  const selected = input.diffs[0] ?? null;
+  const payload = JSON.stringify(input).replace(/</g, "\\u003c");
+  return `<section class="rr-diff-history" data-rr-diff-history>
+  <div class="rr-diff-history__header">
+    <h2 class="rr-diff-history__title">History</h2>
+    <span class="rr-diff-history__count">${input.history.length} changes</span>
+  </div>
+  ${input.history.length === 0 || !selected ? renderEmptyState() : renderContent(input, selected)}
+  <script type="application/json" data-rr-diff-history-data>${payload}</script>
+</section>`;
+}
+function renderContent(input, selected) {
+  return `<div class="rr-diff-history__layout">
+    <ol class="rr-diff-history__list" aria-label="Commit history">
+      ${input.history.map((revision, index) => renderRevisionButton(revision, index === 0)).join("")}
+    </ol>
+    ${renderDiffViewer({ history: input.history, selected })}
+  </div>`;
+}
+function renderEmptyState() {
+  return `<p class="rr-diff-history__empty">No Git history is available for this article.</p>`;
+}
+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(formatDate2(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>`;
+}
+function formatDate2(value) {
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) return value;
+  return date.toLocaleDateString("en", { month: "short", day: "numeric" });
+}
+
+// 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 { execFile } from "node:child_process";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+var fieldSeparator = "";
+var recordSeparator = "";
+var GitMarkdownHistoryReader = class {
+  #cwd;
+  #historyCache = /* @__PURE__ */ new Map();
+  #markdownCache = /* @__PURE__ */ new Map();
+  #revisionPathCache = /* @__PURE__ */ new Map();
+  #repositoryAvailable;
+  constructor(options = {}) {
+    this.#cwd = options.cwd ?? process.cwd();
+  }
+  getHistory(filePath) {
+    const normalizedPath = normalizeGitPath(filePath);
+    const cached = this.#historyCache.get(normalizedPath);
+    if (cached) return cached;
+    const history = this.#readHistory(normalizedPath);
+    this.#historyCache.set(normalizedPath, history);
+    return history;
+  }
+  getRevisionMarkdown(filePath, hash) {
+    const normalizedPath = normalizeGitPath(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) {
+    if (!await this.#isRepositoryAvailable()) return [];
+    const format = ["%H", "%h", "%cI", "%s", "%an"].join(fieldSeparator);
+    const result = await runGit(this.#cwd, [
+      "log",
+      "--follow",
+      "--name-status",
+      `--format=${recordSeparator}${format}`,
+      "--",
+      filePath
+    ]);
+    if (!result.ok || !result.stdout.trim()) return [];
+    const revisionPaths = /* @__PURE__ */ new Map();
+    const revisions = result.stdout.split(recordSeparator).map((record) => record.trim()).filter(Boolean).map((record) => parseRevisionRecord(record, revisionPaths, filePath)).filter((revision) => revision !== null);
+    this.#revisionPathCache.set(filePath, revisionPaths);
+    return revisions;
+  }
+  async #readRevisionMarkdown(filePath, hash) {
+    if (!await this.#isRepositoryAvailable()) return null;
+    await this.getHistory(filePath);
+    const revisionPath = this.#revisionPathCache.get(filePath)?.get(hash) ?? filePath;
+    const result = await runGit(this.#cwd, ["show", `${hash}:${revisionPath}`]);
+    return result.ok ? result.stdout : null;
+  }
+  #isRepositoryAvailable() {
+    this.#repositoryAvailable ??= runGit(this.#cwd, [
+      "rev-parse",
+      "--is-inside-work-tree"
+    ]).then((result) => result.ok && result.stdout.trim() === "true");
+    return this.#repositoryAvailable;
+  }
+};
+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 paths.at(-1) ?? fallbackPath;
+}
+function normalizeGitPath(filePath) {
+  return filePath.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+async function runGit(cwd, args) {
+  try {
+    const { stdout } = await execFileAsync("git", args, {
+      cwd,
+      maxBuffer: 1024 * 1024 * 10
+    });
+    return { ok: true, stdout };
+  } catch (error) {
+    const stdout = typeof error === "object" && error !== null && "stdout" in error && typeof error.stdout === "string" ? error.stdout : "";
+    return { ok: false, stdout };
+  }
+}
+
+// index.ts
+function diff(options = {}) {
+  const api = createPostDiffApi(options);
+  const ui = { enabled: true, maxRevisions: 20, ...options.ui };
+  return definePlugin({
+    name: "diff",
+    options,
+    assets: ui.enabled === false ? [] : [createStyleAsset("diff")],
+    clientEntries: ui.enabled === false ? [] : [createClientEntry("diff", "initDiffHistory")],
+    onPostProcessed: async (context) => {
+      if (ui.enabled === false) return;
+      const filePath = resolvePostFilePath(context);
+      const history = (await api.getHistory(filePath)).slice(
+        0,
+        ui.maxRevisions
+      );
+      const diffs = await buildRevisionDiffs(api, filePath, history);
+      context.content.html += renderDiffHistory({
+        history,
+        diffs
+      });
+    }
+  });
+}
+function createPostDiffApi(options = {}) {
+  const reader = new GitMarkdownHistoryReader(options);
+  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 getPreviousRevision(history, hash) {
+  const index = history.findIndex((revision) => revision.hash === hash);
+  return index >= 0 ? history[index + 1] ?? null : null;
+}
+async function buildRevisionDiffs(api, filePath, history) {
+  const comparisons = [];
+  for (let toIndex = 0; toIndex < history.length; toIndex += 1) {
+    const to = history[toIndex];
+    const previous = getPreviousRevision(history, to.hash);
+    comparisons.push({
+      filePath,
+      fromHash: previous?.hash ?? null,
+      toHash: to.hash
+    });
+    for (let fromIndex = toIndex + 2; fromIndex < history.length; fromIndex += 1) {
+      comparisons.push({
+        filePath,
+        fromHash: history[fromIndex].hash,
+        toHash: to.hash
+      });
+    }
+  }
+  const diffs = await Promise.all(
+    comparisons.map((comparison) => api.compareRevisions(comparison))
+  );
+  return diffs.filter((entry) => entry !== null);
+}
+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 {
+  GitMarkdownHistoryReader,
+  createLineDiff,
+  createPostDiffApi,
+  diff,
+  renderDiffHistory,
+  renderDiffLine,
+  renderDiffPanel,
+  renderDiffViewer
+};

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

@@ -0,0 +1,6 @@
+import type { DiffRevision, PostDiff } from "../types.js";
+export type DiffHistoryProps = {
+    history: DiffRevision[];
+    diffs: PostDiff[];
+};
+export declare function renderDiffHistory(input: DiffHistoryProps): string;

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

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

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

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

package/dist/src/diff/line_diff.d.ts

@@ -0,0 +1,2 @@
+import type { DiffLine } from "../types.js";
+export declare function createLineDiff(fromMarkdown: string, toMarkdown: string): DiffLine[];

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

@@ -0,0 +1,7 @@
+import type { DiffRevision, GitHistoryReaderOptions } from "../types.js";
+export declare class GitMarkdownHistoryReader {
+    #private;
+    constructor(options?: GitHistoryReaderOptions);
+    getHistory(filePath: string): Promise<DiffRevision[]>;
+    getRevisionMarkdown(filePath: string, hash: string): Promise<string | null>;
+}

package/dist/src/types.d.ts

@@ -0,0 +1,34 @@
+export type DiffLineType = "context" | "added" | "removed";
+export type DiffLine = {
+    type: DiffLineType;
+    content: string;
+    oldLineNumber: number | null;
+    newLineNumber: number | null;
+};
+export type DiffRevision = {
+    hash: string;
+    shortHash: string;
+    date: string;
+    message: string;
+    author: string;
+};
+export type MarkdownRevision = DiffRevision & {
+    markdown: string;
+};
+export type PostDiff = {
+    from: DiffRevision | null;
+    to: DiffRevision;
+    lines: DiffLine[];
+};
+export type RevisionComparisonInput = {
+    filePath: string;
+    fromHash: string | null;
+    toHash: string;
+};
+export type GitHistoryReaderOptions = {
+    cwd?: string;
+};
+export type DiffPluginUiOptions = {
+    enabled?: boolean;
+    maxRevisions?: number;
+};

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@riebeckite/plugin-diff",
+  "version": "0.0.1",
+  "license": "Apache-2.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "source": "./index.ts",
+      "default": "./dist/index.js"
+    },
+    "./client": {
+      "types": "./dist/client.d.ts",
+      "import": "./dist/client.js",
+      "source": "./client.ts",
+      "default": "./dist/client.js"
+    },
+    "./style.css": "./style.css"
+  },
+  "dependencies": {
+    "@riebeckite/core": "0.0.1"
+  },
+  "devDependencies": {
+    "@types/node": "^24.5.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "LICENSE",
+    "README.md",
+    "README_ja.md",
+    "dist",
+    "style.css"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Rerurate514/riebeckite.git",
+    "directory": "packages/plugins/diff"
+  },
+  "homepage": "https://github.com/Rerurate514/riebeckite#readme",
+  "bugs": {
+    "url": "https://github.com/Rerurate514/riebeckite/issues"
+  },
+  "description": "Git-backed note diffs and revision history for Riebeckite.",
+  "keywords": [
+    "riebeckite",
+    "plugin",
+    "git",
+    "diff"
+  ],
+  "engines": {
+    "node": "^20.19.0 || >=22.12.0"
+  },
+  "sideEffects": [
+    "./style.css"
+  ],
+  "scripts": {
+    "build": "node ../../../scripts/build_package.mjs"
+  }
+}

package/style.css

@@ -0,0 +1,229 @@
+.rr-diff-history {
+  margin-block: 4rem 2rem;
+  border-block-start: 1px solid
+    var(--rb-color-border, color-mix(in srgb, currentColor 18%, transparent));
+  padding-block-start: 1.5rem;
+  color: var(--rb-color-ink, currentColor);
+}
+
+.rr-diff-history__header {
+  display: flex;
+  align-items: baseline;
+  justify-content: space-between;
+  gap: 1rem;
+  margin-block-end: 1rem;
+}
+
+.rr-diff-history__title {
+  margin: 0;
+  font-size: 0.875rem;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+}
+
+.rr-diff-history__count,
+.rr-diff-history__date,
+.rr-diff-history__meta {
+  color: var(
+    --rb-color-muted,
+    color-mix(in srgb, currentColor 62%, transparent)
+  );
+  font-size: 0.8125rem;
+}
+
+.rr-diff-history__layout {
+  display: grid;
+  grid-template-columns: minmax(12rem, 0.36fr) minmax(0, 1fr);
+  gap: 1.5rem;
+}
+
+.rr-diff-history__list {
+  display: grid;
+  gap: 0;
+  margin: 0;
+  padding: 0;
+  list-style: none;
+}
+
+.rr-diff-history__item {
+  position: relative;
+  padding-inline-start: 1.25rem;
+}
+
+.rr-diff-history__item::before {
+  position: absolute;
+  inset-block-start: 0.7rem;
+  inset-inline-start: 0;
+  width: 0.5rem;
+  height: 0.5rem;
+  border: 1px solid var(--rb-color-ink, currentColor);
+  border-radius: 999px;
+  background: var(--rb-color-paper, Canvas);
+  content: "";
+}
+
+.rr-diff-history__item:not(:last-child)::after {
+  position: absolute;
+  inset-block: 1.25rem -0.25rem;
+  inset-inline-start: 0.25rem;
+  width: 1px;
+  background: var(
+    --rb-color-border,
+    color-mix(in srgb, currentColor 18%, transparent)
+  );
+  content: "";
+}
+
+.rr-diff-history__commit {
+  display: grid;
+  width: 100%;
+  border: 0;
+  padding: 0 0 1rem;
+  background: transparent;
+  color: inherit;
+  font: inherit;
+  text-align: start;
+  cursor: pointer;
+}
+
+.rr-diff-history__message {
+  overflow-wrap: anywhere;
+  font-size: 0.9375rem;
+  line-height: 1.45;
+}
+
+.rr-diff-history__commit:hover .rr-diff-history__message,
+.rr-diff-history__commit[aria-pressed="true"] .rr-diff-history__message {
+  color: var(--rb-color-accent, #f66620);
+}
+
+.rr-diff-history__commit:focus-visible,
+.rr-diff-history__controls select:focus-visible {
+  outline: 2px solid var(--rb-color-accent, #f66620);
+  outline-offset: 2px;
+}
+
+.rr-diff-history__viewer {
+  min-width: 0;
+}
+
+.rr-diff-history__controls {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.75rem;
+  margin-block-end: 0.75rem;
+  font-size: 0.8125rem;
+}
+
+.rr-diff-history__controls label {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.5rem;
+}
+
+.rr-diff-history__controls select {
+  border: 1px solid
+    var(--rb-color-border, color-mix(in srgb, currentColor 18%, transparent));
+  border-radius: 0;
+  padding: 0.25rem 0.5rem;
+  background: var(--rb-color-paper, Canvas);
+  color: inherit;
+  font: inherit;
+}
+
+.rr-diff-history__diff {
+  border: 1px solid
+    var(--rb-color-border, color-mix(in srgb, currentColor 18%, transparent));
+}
+
+.rr-diff-history__diff-head {
+  border-block-end: 1px solid
+    var(--rb-color-border, color-mix(in srgb, currentColor 18%, transparent));
+  padding: 0.625rem 0.75rem;
+  font-family: var(
+    --rb-font-mono,
+    ui-monospace,
+    SFMono-Regular,
+    Consolas,
+    monospace
+  );
+  font-size: 0.8125rem;
+}
+
+.rr-diff-history__table-wrap {
+  overflow-x: auto;
+}
+
+.rr-diff-history__table {
+  width: 100%;
+  min-width: 42rem;
+  border-collapse: collapse;
+  font-family: var(
+    --rb-font-mono,
+    ui-monospace,
+    SFMono-Regular,
+    Consolas,
+    monospace
+  );
+  font-size: 0.8125rem;
+  line-height: 1.55;
+}
+
+.rr-diff-history__num {
+  width: 3.25rem;
+  border-inline-end: 1px solid
+    var(--rb-color-border, color-mix(in srgb, currentColor 14%, transparent));
+  color: var(
+    --rb-color-muted,
+    color-mix(in srgb, currentColor 58%, transparent)
+  );
+  text-align: end;
+  user-select: none;
+}
+
+.rr-diff-history__num,
+.rr-diff-history__code {
+  padding: 0.125rem 0.625rem;
+  vertical-align: top;
+}
+
+.rr-diff-history__code code {
+  white-space: pre;
+}
+
+.rr-diff-history__line--added {
+  background: color-mix(in srgb, #2f9e44 16%, transparent);
+}
+
+.rr-diff-history__line--removed {
+  background: color-mix(in srgb, #e03131 14%, transparent);
+}
+
+.rr-diff-history__line--context {
+  background: color-mix(in srgb, currentColor 2%, transparent);
+}
+
+.rr-diff-history__empty {
+  margin: 0;
+  color: var(
+    --rb-color-muted,
+    color-mix(in srgb, currentColor 62%, transparent)
+  );
+  font-size: 0.9375rem;
+}
+
+@media (max-width: 720px) {
+  .rr-diff-history__layout {
+    grid-template-columns: 1fr;
+  }
+
+  .rr-diff-history__list {
+    max-height: 18rem;
+    overflow: auto;
+    padding-inline-end: 0.25rem;
+  }
+
+  .rr-diff-history__header {
+    align-items: flex-start;
+  }
+}