M4.8: merge conflicts with a three-pane resolve view

Backend (crates/vcs/src/merge.rs, cmd/git_merge.rs via start_with):
git.merge {branch} -> {result: merged|upToDate|conflicts, conflicts},
git.mergeAbort, git.conflictVersions {path} -> {base?, ours, theirs,
binary, tooLarge} from the index stages :1:/:2:/:3:, git.markResolved
{paths}. Repo::lock becomes pub(crate) so merge and abort hold the
mutation lock.

UI (ui/src/components/vcs/merge/): merge dialog with branch picker,
conflicts list from the shared status store, a three-pane resolve view
(ours / editable result / theirs) with accept left/right per chunk,
accept all, previous/next conflict, Apply through the file's buffer then
mark resolved, keep-a-side for modify/delete, abort after confirmation.
Own three-way line merge on @codemirror/merge's diff. UI commands
vcs.merge, vcs.resolveConflicts, vcs.abortMerge (no default shortcuts);
the Changes window opens conflicted rows in the resolve view.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
danny 2026-10-29 17:48:24 +01:00
parent 74c674ed12
commit d82e57b3ac
26 changed files with 3872 additions and 16 deletions

View file

@ -0,0 +1,513 @@
/**
* The three editors of the resolve view (M4.8): ours (left, read-only),
* the result (middle, editable) and theirs (right, read-only).
*
* - **Blocks:** built by `merge3` (`diff3.ts`). Non-conflicting changes are
* in the result from the start; each conflict is a chunk whose range in
* the result starts as the base's lines.
* - **Chunks in the result:** a state field keeps each chunk's range,
* mapped through every edit (the start sticks before text inserted at it,
* the end after, so typing at a chunk's edge extends it). Its state comes
* from its text: open while it is the base's, taken from ours or theirs
* while it equals that side, edited by hand otherwise.
* - **Accepting:** {@link ResolveView.accept} replaces a chunk's range with
* that side's lines; it is one undoable change of the result, and undo
* opens the chunk again. The side
* panes show a button in the gutter at the first line of every open
* chunk ("»" left, "«" right); a click accepts it.
* - **Colours:** only `--lt-*` tokens: open conflicts tinted with
* `--lt-vcs-conflicted`, accepted chunks and non-conflicting changes with
* `--lt-vcs-modified`.
* - **Navigation:** {@link ResolveView.go} moves to the next or previous
* open chunk (wrapping), selects it in the result and scrolls all three
* editors to it.
*/
import { EditorState, RangeSetBuilder, StateEffect, StateField, type Extension, type Text } from "@codemirror/state";
import { Decoration, EditorView, GutterMarker, gutter, type DecorationSet } from "@codemirror/view";
import { basicSetup } from "codemirror";
import { lutraEditorTheme } from "../../editor/extensions";
import { languageExtensions } from "../../editor/language";
import { merge3, resultUnits, splitUnits, type MergeBlock } from "./diff3";
/** Which side a chunk was taken from, or how else it was settled. */
export type ChunkState = "open" | "ours" | "theirs" | "edited";
/** A conflict chunk: its text on each side and its place in each document. */
export interface Chunk {
/** Our text. */
ours: string;
/** Their text. */
theirs: string;
/** Range in the ours document. */
oursFrom: number;
/** End in the ours document. */
oursTo: number;
/** Range in the theirs document. */
theirsFrom: number;
/** End in the theirs document. */
theirsTo: number;
}
/** A chunk's live range in the result. */
interface Range {
/** Start in the result. */
from: number;
/** End in the result. */
to: number;
}
/** A chunk's live range and state in the result. */
export interface Live extends Range {
/** Its state, read from the text in its range. */
state: ChunkState;
}
/** A highlighted range of a side document. */
interface Marked {
/** Start. */
from: number;
/** End. */
to: number;
/** A conflict (else a non-conflicting change). */
conflict: boolean;
}
/** The laid-out merge: documents, chunks and highlights. */
export interface Layout {
/** The ours document. */
ours: string;
/** The theirs document. */
theirs: string;
/** The initial result. */
result: string;
/** The conflict chunks in order. */
chunks: Chunk[];
/** Initial result range of each chunk. */
resultRanges: { from: number; to: number }[];
/** Highlights of the ours document. */
oursMarks: Marked[];
/** Highlights of the theirs document. */
theirsMarks: Marked[];
}
/**
* Lays out a merge of the three texts.
*
* @param base - the base text, null when there is none.
* @param ours - our text.
* @param theirs - their text.
*/
export function layout(base: string | null, ours: string, theirs: string): Layout {
const blocks: MergeBlock[] = merge3(base === null ? null : splitUnits(base), splitUnits(ours), splitUnits(theirs));
const out: Layout = { ours: "", theirs: "", result: "", chunks: [], resultRanges: [], oursMarks: [], theirsMarks: [] };
for (const block of blocks) {
const oursText = block.ours.join("");
const theirsText = block.theirs.join("");
const resultText = resultUnits(block).join("");
const oursFrom = out.ours.length;
const theirsFrom = out.theirs.length;
const resultFrom = out.result.length;
out.ours += oursText;
out.theirs += theirsText;
out.result += resultText;
if (block.kind === "conflict") {
out.chunks.push({
ours: oursText,
theirs: theirsText,
oursFrom,
oursTo: out.ours.length,
theirsFrom,
theirsTo: out.theirs.length,
});
out.resultRanges.push({ from: resultFrom, to: out.result.length });
}
if (block.kind === "conflict" || block.kind === "ours" || block.kind === "both") {
out.oursMarks.push({ from: oursFrom, to: out.ours.length, conflict: block.kind === "conflict" });
}
if (block.kind === "conflict" || block.kind === "theirs" || block.kind === "both") {
out.theirsMarks.push({ from: theirsFrom, to: out.theirs.length, conflict: block.kind === "conflict" });
}
}
return out;
}
/** Marks the chunks resolved in a side pane (`true` = open). */
const setOpen = StateEffect.define<boolean[]>();
/** Line decorations by class. */
const lineDecos = {
conflict: Decoration.line({ class: "lt-merge-conflict" }),
change: Decoration.line({ class: "lt-merge-change" }),
resolved: Decoration.line({ class: "lt-merge-resolved" }),
};
/**
* Adds line decorations for the lines a range covers (one line for an
* empty range).
*
* @param doc - the document.
* @param from - start of the range.
* @param to - end of the range.
* @param add - receives each line start.
*/
function eachLine(doc: Text, from: number, to: number, add: (lineStart: number) => void): void {
const first = doc.lineAt(Math.min(from, doc.length));
const last = to > from ? doc.lineAt(Math.min(Math.max(to - 1, from), doc.length)) : first;
for (let n = first.number; n <= last.number; n += 1) {
add(doc.line(n).from);
}
}
/**
* Builds line decorations from ranges.
*
* @param doc - the document.
* @param ranges - ranges with their decoration, in document order.
*/
function lineSet(doc: Text, ranges: { from: number; to: number; deco: Decoration }[]): DecorationSet {
const builder = new RangeSetBuilder<Decoration>();
let last = -1;
for (const range of ranges) {
eachLine(doc, range.from, range.to, (start) => {
if (start > last) {
builder.add(start, start, range.deco);
last = start;
}
});
}
return builder.finish();
}
/** The accept button in a side pane's gutter. */
class AcceptMarker extends GutterMarker {
/**
* @param glyph - `»` or `«`.
* @param label - its accessible name.
*/
constructor(
readonly glyph: string,
readonly label: string,
) {
super();
}
/** @param other - another marker. */
override eq(other: GutterMarker): boolean {
return other instanceof AcceptMarker && other.glyph === this.glyph && other.label === this.label;
}
/** The button. */
override toDOM(): Node {
const button = document.createElement("button");
button.type = "button";
button.className = "lt-merge-accept";
button.textContent = this.glyph;
button.title = this.label;
button.setAttribute("aria-label", this.label);
button.tabIndex = -1;
return button;
}
}
/** Colours of the three editors, from tokens only. */
export const resolveTheme: Extension = EditorView.theme({
".lt-merge-conflict": { backgroundColor: "color-mix(in srgb, var(--lt-vcs-conflicted) 18%, var(--lt-editor-bg))" },
".lt-merge-change": { backgroundColor: "color-mix(in srgb, var(--lt-vcs-modified) 12%, var(--lt-editor-bg))" },
".lt-merge-resolved": { backgroundColor: "color-mix(in srgb, var(--lt-vcs-modified) 18%, var(--lt-editor-bg))" },
".lt-merge-accept": {
font: "inherit",
lineHeight: "1",
padding: "0 4px",
border: "1px solid var(--lt-border)",
borderRadius: "3px",
color: "var(--lt-fg)",
background: "var(--lt-bg)",
cursor: "pointer",
},
".lt-merge-accept:hover": { background: "color-mix(in srgb, var(--lt-accent) 25%, var(--lt-bg))" },
});
/** Labels of the gutter buttons. */
export interface ResolveLabels {
/** The ours pane's button. */
acceptOurs: string;
/** The theirs pane's button. */
acceptTheirs: string;
}
/** Where the three editors go and what they report. */
export interface ResolveOptions {
/** The file's path, for its language. */
path: string;
/** The base text, null when there is none. */
base: string | null;
/** Our text. */
ours: string;
/** Their text. */
theirs: string;
/** Element of the ours editor. */
oursHost: HTMLElement;
/** Element of the result editor. */
resultHost: HTMLElement;
/** Element of the theirs editor. */
theirsHost: HTMLElement;
/** Gutter button labels. */
labels: ResolveLabels;
/** Called after every change of a chunk's state, with the open count. */
onChange: (open: number) => void;
}
/** The three editors of one file. */
export class ResolveView {
/** The ours editor. */
readonly oursView: EditorView;
/** The result editor. */
readonly resultView: EditorView;
/** The theirs editor. */
readonly theirsView: EditorView;
/** The laid-out merge. */
readonly layout: Layout;
/** The chunk navigated to last; -1 before any. */
current = -1;
/** Reports changes. */
private readonly onChange: (open: number) => void;
/** The chunks' field in the result. */
private readonly field: StateField<Range[]>;
/** Each chunk's initial text in the result (the base's lines). */
private readonly bases: string[];
/** The open flags' field of the side panes. */
private readonly openField: StateField<boolean[]>;
/** @param options - hosts, texts and callbacks. */
constructor(options: ResolveOptions) {
this.onChange = options.onChange;
const lay = layout(options.base, options.ours, options.theirs);
this.layout = lay;
const base = lay.resultRanges.map((r) => lay.result.slice(r.from, r.to));
this.bases = base;
const field = StateField.define<Range[]>({
create: () => lay.resultRanges.map((r) => ({ ...r })),
update(ranges, tr) {
if (!tr.docChanged) {
return ranges;
}
return ranges.map((range) => {
const from = tr.changes.mapPos(range.from, -1);
return { from, to: Math.max(from, tr.changes.mapPos(range.to, 1)) };
});
},
provide: (f) =>
EditorView.decorations.from(f, (ranges) => (view: EditorView) =>
lineSet(
view.state.doc,
ranges.map((r, i) => ({
from: r.from,
to: r.to,
deco: view.state.doc.sliceString(r.from, r.to) === base[i] ? lineDecos.conflict : lineDecos.resolved,
})),
),
),
});
this.field = field;
const openField = StateField.define<boolean[]>({
create: () => lay.chunks.map(() => true),
update(flags, tr) {
for (const effect of tr.effects) {
if (effect.is(setOpen)) {
return effect.value;
}
}
return flags;
},
});
this.openField = openField;
const language = languageExtensions(options.path);
const readOnly = [EditorState.readOnly.of(true), EditorView.editable.of(false)];
const side = (which: "ours" | "theirs"): Extension => {
const marks = which === "ours" ? lay.oursMarks : lay.theirsMarks;
const marker = new AcceptMarker(which === "ours" ? "»" : "«", which === "ours" ? options.labels.acceptOurs : options.labels.acceptTheirs);
const starts = lay.chunks.map((c) => (which === "ours" ? c.oursFrom : c.theirsFrom));
return [
basicSetup,
lutraEditorTheme,
language,
resolveTheme,
readOnly,
openField,
StateField.define<DecorationSet>({
create: (state) =>
lineSet(
state.doc,
marks.map((m) => ({ from: m.from, to: m.to, deco: m.conflict ? lineDecos.conflict : lineDecos.change })),
),
update: (set) => set,
provide: (f) => EditorView.decorations.from(f),
}),
gutter({
class: "lt-merge-gutter",
lineMarker: (view, line) => {
const flags = view.state.field(openField);
const index = starts.findIndex(
(start, i) => flags[i] === true && view.state.doc.lineAt(Math.min(start, view.state.doc.length)).from === line.from,
);
return index >= 0 ? marker : null;
},
lineMarkerChange: (update) => update.transactions.some((tr) => tr.effects.some((e) => e.is(setOpen))),
domEventHandlers: {
mousedown: (view, line) => {
const flags = view.state.field(openField);
const index = starts.findIndex(
(start, i) => flags[i] === true && view.state.doc.lineAt(Math.min(start, view.state.doc.length)).from === line.from,
);
if (index < 0) {
return false;
}
this.accept(index, which);
return true;
},
},
}),
];
};
this.oursView = new EditorView({ parent: options.oursHost, state: EditorState.create({ doc: lay.ours, extensions: side("ours") }) });
this.theirsView = new EditorView({ parent: options.theirsHost, state: EditorState.create({ doc: lay.theirs, extensions: side("theirs") }) });
this.resultView = new EditorView({
parent: options.resultHost,
state: EditorState.create({
doc: lay.result,
extensions: [
basicSetup,
lutraEditorTheme,
language,
resolveTheme,
field,
EditorView.updateListener.of((update) => {
if (update.docChanged) {
this.report();
}
}),
],
}),
});
}
/**
* The chunks' live ranges and states. A chunk is open while its text is
* still the base's, taken from a side while it equals that side's, and
* edited otherwise; so undo and redo need no bookkeeping.
*/
get chunks(): readonly Live[] {
const state = this.resultView.state;
return state.field(this.field).map((range, i) => {
const text = state.doc.sliceString(range.from, range.to);
const chunk = this.layout.chunks[i];
const kind: ChunkState =
text === this.bases[i] ? "open" : text === chunk?.ours ? "ours" : text === chunk?.theirs ? "theirs" : "edited";
return { ...range, state: kind };
});
}
/** How many chunks are still open. */
get open(): number {
return this.chunks.filter((c) => c.state === "open").length;
}
/** The result text. */
get result(): string {
return this.resultView.state.doc.toString();
}
/** Tells the side panes which chunks are open and reports the count. */
private report(): void {
const flags = this.chunks.map((c) => c.state === "open");
for (const view of [this.oursView, this.theirsView]) {
const before = view.state.field(this.openField);
if (before.length !== flags.length || before.some((f, i) => f !== flags[i])) {
view.dispatch({ effects: setOpen.of(flags) });
}
}
this.onChange(this.open);
}
/**
* Takes one side's text for a chunk.
*
* @param index - the chunk.
* @param side - which side.
*/
accept(index: number, side: "ours" | "theirs"): void {
const live = this.chunks[index];
const chunk = this.layout.chunks[index];
if (!live || !chunk) {
return;
}
const insert = side === "ours" ? chunk.ours : chunk.theirs;
this.resultView.dispatch({
changes: { from: live.from, to: live.to, insert },
userEvent: "input.merge",
});
this.current = index;
}
/**
* Takes one side's text for every open chunk, last first so earlier
* ranges stay valid.
*
* @param side - which side.
*/
acceptAll(side: "ours" | "theirs"): void {
const open = this.chunks.map((c, i) => ({ c, i })).filter(({ c }) => c.state === "open");
for (const { i } of open.reverse()) {
this.accept(i, side);
}
}
/**
* Takes one side for the chunk navigated to last, else the first open one.
*
* @param side - which side.
*/
acceptCurrent(side: "ours" | "theirs"): void {
const chunks = this.chunks;
const index = chunks[this.current]?.state === "open" ? this.current : chunks.findIndex((c) => c.state === "open");
if (index >= 0) {
this.accept(index, side);
}
}
/**
* Moves to the next or previous open chunk, wrapping.
*
* @param direction - 1 or -1.
* @returns whether there was one.
*/
go(direction: 1 | -1): boolean {
const chunks = this.chunks;
const count = chunks.length;
for (let step = 1; step <= count; step += 1) {
const index = (((this.current < 0 && direction < 0 ? 0 : this.current) + direction * step) % count + count) % count;
const live = chunks[index];
const chunk = this.layout.chunks[index];
if (live?.state === "open" && chunk) {
this.current = index;
this.resultView.dispatch({
selection: { anchor: live.from, head: live.to },
effects: EditorView.scrollIntoView(live.from, { y: "center" }),
});
this.oursView.dispatch({ effects: EditorView.scrollIntoView(Math.min(chunk.oursFrom, this.oursView.state.doc.length), { y: "center" }) });
this.theirsView.dispatch({
effects: EditorView.scrollIntoView(Math.min(chunk.theirsFrom, this.theirsView.state.doc.length), { y: "center" }),
});
return true;
}
}
return false;
}
/** Destroys the three editors. */
destroy(): void {
this.oursView.destroy();
this.resultView.destroy();
this.theirsView.destroy();
}
}