@aparte/plugin-diff 0.0.0-stage → 1.7.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 aparté
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,131 @@
-# Temporary Holding Version
+# @aparte/plugin-diff
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A diff view for [aparté](https://github.com/apartejs/aparte): a file change as hunks with old and new line
+numbers, in the reply or beside it, with comments on a line or a range.
+
+```bash
+npm install @aparte/plugin-diff @aparte/core
+```
+
+## The element
+
+`<aparte-diff>` (`AparteDiff`) shows each file under a header with its path and its counts (`+3 −1`), each line
+with its old and new numbers and a `+` or `−`, and the unchanged runs between hunks folded. Importing the
+package defines it.
+
+```html
+<aparte-diff></aparte-diff>
+<script type="module">
+  import '@aparte/plugin-diff';
+
+  const view = document.querySelector('aparte-diff');
+  view.diff = { path: 'src/parse.ts', before: oldText, after: newText };
+</script>
+```
+
+`diff` takes three shapes (`AparteDiffInput`):
+
+- a unified diff's text, as `git diff` prints it — several files, new, deleted, renamed and binary ones included;
+- a file's two texts, `{ path, before, after }` (`AparteDiffSource`, with `oldPath` for a rename): every
+  unchanged line can then be shown, with a "Show 24 unchanged lines" button over each folded run. A side that
+  does not exist is `null` — `before: null` for a file created, `after: null` for one deleted — while `''` is a
+  file that exists and is empty;
+- a list of files, each either of the above as data (`AparteDiffFile`) or two texts.
+
+The lines are coloured by the chat's highlighter when one is installed (`@aparte/plugin-shiki`), in the
+language the path's extension names; without one they are plain text. The code reads left to right in a
+right-to-left page. A screen reader hears each `+` and `−` as "added" and "removed", and each file's counts in
+words.
+
+## Comments on a line
+
+With `commentable`, a reader picks a line or a range and writes a comment on it. A click on a line number opens
+a field under the line; Shift+click stretches the selection. From the keyboard, the numbers of a file are one tab
+stop: the arrows move, Shift+arrows stretch, Enter or Space open the field, Escape lets go, Ctrl+Enter sends.
+Without `commentable` nothing is clickable.
+
+Sending fires `aparte-diff-comment` with `{ path, side, startLine, endLine, text, code }`
+(`AparteDiffCommentEventDetail`; `side` is `'old'` for a removed line, `'new'` for the rest — `AparteDiffSide`).
+The element keeps nothing: hand the comments back through `comments` (`AparteDiffComment`) and it shows them
+under their lines, with their state.
+
+```ts
+const view = document.querySelector('aparte-diff')!;
+view.commentable = true;
+const review: AparteDiffComment[] = [];
+view.addEventListener('aparte-diff-comment', (event) => {
+  review.push({ ...event.detail, id: crypto.randomUUID(), state: 'pending' });
+  view.comments = review;
+});
+
+// Later, all at once, as one message to the agent:
+sendToAgent(review.map((c) => `${c.path}:${c.startLine}: ${c.text}`).join('\n'));
+view.comments = review.map((c) => ({ ...c, state: 'sent' }));
+```
+
+Cancel the event (`event.preventDefault()`) to keep the field open with its text.
+
+## A tool's result, in the reply
+
+`setupDiff` shows an edit tool's result as a diff under the tool's line, opened. The row stays core's — the
+label and summary you gave the tool, its states — and the diff takes the place of the raw Input and Output.
+
+```ts
+import { setupDiff } from '@aparte/plugin-diff';
+
+const stop = setupDiff({
+  tool: 'edit_file',
+  map: (result, input) => ({ path: String(input.path), before: result.before, after: result.after }),
+});
+```
+
+`DiffSetupOptions`: `tool` (a name, a pattern, or a list), `map` (the change from the tool's result and input;
+without it the result must already be a diff), `commentable`, and `open` (`false` keeps it behind the line). The
+config comes second, the global one by default. The call returns the function that takes it off.
+
+## The computation
+
+Plain functions with no DOM, in the browser and on a server:
+
+```ts
+import { diffTexts, formatUnifiedDiff, parseUnifiedDiff } from '@aparte/plugin-diff';
+
+const before = 'let total = 0;\ntotal += parseInt(amount, 10);\n';
+const after = 'let total = 0;\ntotal += Number(amount);\n';
+const file = diffTexts(before, after, { path: 'src/parse.ts', context: 3 }); // AparteDiffFile
+const text = formatUnifiedDiff(file);   // what `git apply` takes
+const files = parseUnifiedDiff(text);   // AparteDiffFile[]
+```
+
+`diffTexts` (`DiffTextsOptions`: `context`, `path`, `oldPath`) is a line diff written here — Myers' algorithm, the
+fewest added and removed lines — with no dependency. Lines are compared without their endings, so a file saved
+with Windows line endings reads the same; a last line that gains or loses its newline shows as changed. A side
+given as `null` is a file created (`diffTexts(null, text)`, `added`) or deleted (`diffTexts(text, null)`,
+`deleted`); `''` is an empty file. A large file is first cut at the lines it holds once on each side, in the
+same order (patience anchoring, as `git diff --patience`), and each gap between them is diffed on its own: a
+200,000-line file changed in a thousand places still gives a thousand small hunks, in well under a second. A
+gap with thousands of changes and little in common is shown as removed then added, which stays a true account of
+the change without being the shortest one.
+
+`formatUnifiedDiff` writes what `git apply` takes: git's `new file mode` and `deleted file mode` headers for a
+file created or deleted, `rename from` / `rename to` for a rename. `parseUnifiedDiff` reads a rename only where
+git says one (`rename from` / `rename to`, or a `similarity index`): a plain `diff -u x.c.orig x.c` is a change
+to `x.c`, and `diff -ru old new` keeps its trees' names.
+
+An `AparteDiffFile` is `{ path, oldPath?, status?, added, removed, hunks, binary? }` (`AparteDiffFileStatus`:
+`modified`, `added`, `deleted`, `renamed`); each `AparteDiffHunk` has `oldStart`, `oldCount`, `newStart`,
+`newCount`, an optional `section` (the function a hunk is in), and its `lines` (`AparteDiffLine`: `kind` —
+`AparteDiffLineKind`, `context`, `add` or `del` — `text`, `oldLine`, `newLine`, `noNewline`).
+
+## Words and theme
+
+Its words are in the ten languages `@aparte/locales` ships, in the chat's language; change one with
+`extendLocale({ diffCommentSubmit: 'Send' })`. The tints are tokens that fall back to core's:
+`--aparte-diff-added-bg` (`--aparte-success-surface`), `--aparte-diff-removed-bg` (`--aparte-error-surface`),
+`--aparte-diff-added-ink`, `--aparte-diff-removed-ink` and `--aparte-diff-selected-bg`.
+
+Documentation: [apartejs.dev/components/diff](https://apartejs.dev/components/diff/).
+
+## License
+
+MIT

package/dist/aparte-diff.d.ts

@@ -0,0 +1,140 @@
+import type { AparteDiffComment, AparteDiffInput } from './types.js';
+/** Importable where there is no DOM: the class then extends nothing and is never defined. */
+declare const ElementBase: typeof HTMLElement;
+/**
+ * A change, as a reviewer reads it: each file under a header with its path and its counts
+ * (`+3 −1`), each line with its old and new numbers and a `+` or `−` (said as a word to a
+ * screen reader), the unchanged runs between hunks folded behind "Show 24 unchanged lines".
+ * Set `diff` to a unified diff's text, to a file's two texts (`{ path, before, after }`: every
+ * unchanged line can then be shown), or to a list of files.
+ *
+ * With `commentable`, a reader comments on a line or a range: a click on a line number (Shift+click
+ * to stretch it), or from the keyboard — the numbers of a file are one tab stop, the arrows move,
+ * Shift+arrows stretch, Enter or Space open the field, Escape lets go. Sending it fires
+ * `aparte-diff-comment`; keeping the comments and sending them on is the app's, and the ones it
+ * hands back through `comments` are shown under their lines with where each stands.
+ *
+ * The lines are coloured by the chat's highlighter when one is installed (`@aparte/plugin-shiki`),
+ * in the language the path's extension names. The code reads left to right in a right-to-left page.
+ *
+ * @element aparte-diff
+ *
+ * @attr {boolean} commentable - Let the reader pick a line or a range and write a comment on it. Off by default: without it nothing is clickable.
+ *
+ * @fires {CustomEvent<AparteDiffCommentEventDetail>} aparte-diff-comment - A comment was written and sent: `{ path, side, startLine, endLine, text, code }`. Bubbles out of the chat; cancel it to keep the field open with its text.
+ *
+ * @cssprop [--aparte-diff-added-bg=var(--aparte-success-surface)] - The background of an added line.
+ * @cssprop [--aparte-diff-removed-bg=var(--aparte-error-surface)] - The background of a removed line.
+ * @cssprop [--aparte-diff-added-ink=var(--aparte-success-ink)] - The `+` of an added line, and the count of added lines.
+ * @cssprop [--aparte-diff-removed-ink=var(--aparte-error-ink)] - The `−` of a removed line, and the count of removed lines.
+ * @cssprop [--aparte-diff-selected-bg=var(--aparte-surface-hover)] - The background of the lines picked for a comment.
+ *
+ * @example A file's two texts, open to comments
+ * ```html
+ * <aparte-diff commentable></aparte-diff>
+ * <script type="module">
+ *   import '@aparte/plugin-diff';
+ *
+ *   const diff = document.querySelector('aparte-diff');
+ *   diff.diff = { path: 'src/parse.ts', before: oldText, after: newText };
+ *   const comments = [];
+ *   diff.addEventListener('aparte-diff-comment', (event) => {
+ *     comments.push({ ...event.detail, state: 'pending' });
+ *     diff.comments = comments;
+ *   });
+ * </script>
+ * ```
+ */
+export declare class AparteDiff extends ElementBase {
+    static get observedAttributes(): string[];
+    private _input;
+    private _shown;
+    /** Each file's element, as last drawn. */
+    private _files;
+    private _comments;
+    private readonly _id;
+    private _generation;
+    private _stopConfig;
+    private _selection;
+    private _form;
+    /** Whether the reader opened the field (it then follows the selection through a redraw). */
+    private _writing;
+    /** Each line row's line. */
+    private readonly _lineOf;
+    /** The change to show: a unified diff's text, `{ path, before, after }`, or a list of files (`AparteDiffFile` or texts). */
+    get diff(): AparteDiffInput | null;
+    set diff(value: AparteDiffInput | null);
+    /** The comments to show under their lines, with their state. The element only shows them. */
+    get comments(): AparteDiffComment[];
+    set comments(value: AparteDiffComment[]);
+    /** Whether a reader can comment on a line. Reflects the `commentable` attribute. */
+    get commentable(): boolean;
+    set commentable(value: boolean);
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, previous: string | null, value: string | null): void;
+    private get _config();
+    private _word;
+    private _onConfigChange;
+    /** Draw every file again from the state, the reader's selection, field and focus kept. */
+    private _render;
+    private _renderFile;
+    private _message;
+    /** The rows of file `index`, its comments under their lines. */
+    private _fillLines;
+    private _gapRow;
+    private _lineRow;
+    /** Put the highlighter's colours in a line's code, with its block's classes; `false` when it has none for it. */
+    private _colour;
+    private _number;
+    private _htmlOf;
+    /** The comments the app handed back, each under the line it ends on, or at the end of its file when that line is folded. */
+    private _placeComments;
+    private _commentNode;
+    /** "Line 12", "Lines 12–14", "Removed line 5". */
+    private _rangeWords;
+    /**
+     * Colour each file not coloured yet — or, `again`, every file — each side as one text, and
+     * put the colours in the lines on screen. A file is coloured only once its highlighter
+     * answered: one that failed (still loading its grammars) leaves it plain, to be tried again.
+     */
+    private _highlight;
+    private _paintColours;
+    private _linesOf;
+    /** The line row of file `index` with the key `key`, if it is drawn. */
+    private _rowOf;
+    private readonly _onClick;
+    private readonly _onKeydown;
+    /** A button acts on Space's keyup: the keydown already did. */
+    private readonly _onKeyup;
+    /** The line rows of the file `row` is in. */
+    private _rowsAround;
+    private _fileOf;
+    /** Move the file's tab stop to `row`'s number, and the focus with it. */
+    private _focusRow;
+    /** Shift+arrow: the selection runs from where it started (or from `from`) to `to`. */
+    private _stretch;
+    /** A click (or Enter, Space) on a line number: that line, or the selection stretched to it; then the field. */
+    private _pick;
+    private _selectedRows;
+    private _paintSelection;
+    /** What the selection covers: its side, its first and last line there, and those lines' text. */
+    private _range;
+    /** The field, under the selection's last line, named for what it covers. */
+    private _placeForm;
+    private _buildForm;
+    private _send;
+    /** Close the field and drop the selection; the focus goes back to the line it ended on. */
+    private _letGo;
+    /** Show the unchanged run `gap` of file `index`, and carry on from its first line. */
+    private _expand;
+    private _focusKey;
+    private _restoreFocus;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'aparte-diff': AparteDiff;
+    }
+}
+export {};
+//# sourceMappingURL=aparte-diff.d.ts.map

package/dist/aparte-diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aparte-diff.d.ts","sourceRoot":"","sources":["../src/aparte-diff.ts"],"names":[],"mappings":"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"}

package/dist/compute.d.ts

@@ -0,0 +1,62 @@
+/**
+ * The line diff, written here: Myers' O(ND) algorithm ("An O(ND) Difference Algorithm and
+ * Its Variations", 1986), the one `git diff` and GNU diff start from. It finds the fewest
+ * added and removed lines that turn one text into the other, in time proportional to the
+ * length of the texts times the number of changes — small for an agent's edit.
+ *
+ * Three steps keep a large file fast, each said where it bites:
+ *  - the lines the two texts share at their start and at their end are taken off first, so
+ *    the search only runs over the part that changed;
+ *  - a part longer than `ANCHOR_FROM` lines is first cut at the lines that appear once in
+ *    each text, in the same order (the longest such run: "patience" anchoring, as
+ *    `git diff --patience` does), and each gap between two of them is diffed on its own. A
+ *    large file changed all through still gives one small hunk per change, in little time;
+ *  - in a gap, past `MAX_COST` changes (two texts with little in common there) the search
+ *    stops, and that gap alone is shown as removed then added: still a true account of the
+ *    change, no longer the shortest one. The memory the search keeps grows with the square
+ *    of the changes, which is what the bound is for.
+ *
+ * No DOM anywhere: `diffTexts` runs on a server as well.
+ */
+import type { AparteDiffFile, AparteDiffHunk, AparteDiffLine } from './types.js';
+/** One step of the edit: a line kept, removed from the old text, or added from the new one. */
+export type Edit = 'eq' | 'del' | 'add';
+/**
+ * The edit that turns `a` into `b`, one step per line, removals before additions inside a
+ * run of changes.
+ */
+export declare function diffLines(a: readonly string[], b: readonly string[]): Edit[];
+/** A text's lines, without their endings, and whether its last line ends with one. */
+export declare function splitLines(text: string): {
+    lines: string[];
+    endsWithNewline: boolean;
+};
+/** What `diffTexts` is told besides the two texts. */
+export interface DiffTextsOptions {
+    /** Unchanged lines kept on each side of a change (3, as `git diff`). */
+    context?: number;
+    /** The file's path, as the diff names it. */
+    path?: string;
+    /** Its path before, when it was renamed. Not read for a file created or deleted (a `null` side). */
+    oldPath?: string;
+}
+/**
+ * The diff of two texts, as one file's hunks with their line numbers. Lines are compared
+ * without their endings, so a file saved with Windows line endings reads the same; a last
+ * line that gains or loses its newline is shown changed, marked `noNewline`.
+ *
+ * A side that does not exist is `null`: `before: null` is a file created (`added`),
+ * `after: null` a file deleted (`deleted`). `''` is a file that exists and is empty, so
+ * `diffTexts('', text)` is that file filled in (`modified`). `formatUnifiedDiff` writes each
+ * as git does, so the patch applies.
+ *
+ * @example
+ * const file = diffTexts(before, after, { path: 'src/parse.ts' });
+ * file.added;   // 1
+ * file.hunks;   // [{ oldStart: 12, oldCount: 7, newStart: 12, newCount: 7, lines: [...] }]
+ * diffTexts(null, 'hello\n', { path: 'notes.md' }).status; // 'added'
+ */
+export declare function diffTexts(before: string | null, after: string | null, options?: DiffTextsOptions): AparteDiffFile;
+/** The changed lines with `context` unchanged ones around them, two hunks joined when their context touches. */
+export declare function hunksOf(lines: readonly AparteDiffLine[], context: number): AparteDiffHunk[];
+//# sourceMappingURL=compute.d.ts.map

package/dist/compute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compute.d.ts","sourceRoot":"","sources":["../src/compute.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjF,+FAA+F;AAC/F,MAAM,MAAM,IAAI,GAAG,IAAI,GAAG,KAAK,GAAG,KAAK,CAAC;AAkBxC;;;GAGG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,SAAS,MAAM,EAAE,EAAE,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,EAAE,CA4C5E;AA6HD,sFAAsF;AACtF,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG;IAAE,KAAK,EAAE,MAAM,EAAE,CAAC;IAAC,eAAe,EAAE,OAAO,CAAA;CAAE,CAMtF;AAED,sDAAsD;AACtD,MAAM,WAAW,gBAAgB;IAC7B,wEAAwE;IACxE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,6CAA6C;IAC7C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,oGAAoG;IACpG,OAAO,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,EAAE,OAAO,GAAE,gBAAqB,GAAG,cAAc,CAwCrH;AAED,gHAAgH;AAChH,wBAAgB,OAAO,CAAC,KAAK,EAAE,SAAS,cAAc,EAAE,EAAE,OAAO,EAAE,MAAM,GAAG,cAAc,EAAE,CAkB3F"}