Milestone 0.5: conflict editor CodeLens over oxy markers, keep-this-candidate for tree conflicts, mark resolved, commit resolution label 25103dddd993

// The conflict editor (spec §5.7): CodeLens actions over each conflict

// region, keep-this-candidate for tree conflicts, and mark-resolved.

import * as vscode from "vscode";

import { basename, dirname, join } from "node:path";

import { promises as fs } from "node:fs";

import { ConflictRegion, candidateBase, parseConflicts, resolveRegion } from "./markers";

import { Repository } from "./repository";

export class ConflictCodeLensProvider implements vscode.CodeLensProvider {

  private readonly emitter = new vscode.EventEmitter<void>();

  readonly onDidChangeCodeLenses = this.emitter.event;

  constructor(private readonly repositories: () => Repository[]) {}

  refresh(): void {

    this.emitter.fire();

  }

  provideCodeLenses(document: vscode.TextDocument): vscode.CodeLens[] {

    if (document.uri.scheme !== "file" || !this.repositories().some((r) => r.relativePath(document.uri) !== undefined)) {

      return [];

    }

    const text = document.getText();

    if (!text.includes("<<<<<<< oxy conflict")) {

      return [];

    }

    const regions = parseConflicts(text.split(/\r?\n/));

    const lenses: vscode.CodeLens[] = [];

    regions.forEach((region, index) => {

      const range = new vscode.Range(region.start, 0, region.start, 0);

      for (const side of region.sides) {

        const title = side.deleted ? `Accept deletion (${side.label.replace("deleted by change ", "")})` : `Accept side ${side.number} (${side.label})`;

        lenses.push(new vscode.CodeLens(range, { title, command: "oxygen.acceptSides", arguments: [document.uri, index, [side.number]] }));

      }

      if (region.sides.length > 1 && !region.sides.every((s) => s.deleted)) {

        lenses.push(new vscode.CodeLens(range, { title: "Accept all sides", command: "oxygen.acceptSides", arguments: [document.uri, index, region.sides.map((s) => s.number)] }));

      }

      lenses.push(new vscode.CodeLens(range, { title: `Conflict ${region.number} of ${region.total}`, command: "" }));

    });

    return lenses;

  }

}

/** Replace conflict region `index` of the document with the kept sides. */

export async function acceptSides(uri: vscode.Uri, index: number, keep: number[]): Promise<void> {

  const document = await vscode.workspace.openTextDocument(uri);

  const lines = document.getText().split(/\r?\n/);

  const regions = parseConflicts(lines);

  const region: ConflictRegion | undefined = regions[index];

  if (!region) {

    return;

  }

  const replacement = resolveRegion(lines, region, keep);

  const edit = new vscode.WorkspaceEdit();

  const eol = document.eol === vscode.EndOfLine.CRLF ? "\r\n" : "\n";

  const range = new vscode.Range(region.start, 0, region.end + 1, 0);

  edit.replace(uri, range, replacement.length ? replacement.join(eol) + eol : "");

  await vscode.workspace.applyEdit(edit);

  await document.save();

}

/** Keep one `.oxy-conflict-N` candidate under the real name; the others go. */

export async function keepCandidate(repo: Repository, candidatePath: string): Promise<void> {

  const base = candidateBase(candidatePath);

  if (!base) {

    return;

  }

  const dir = join(repo.root, dirname(candidatePath));

  const name = basename(base);

  const entries = await fs.readdir(dir);

  for (const e of entries) {

    if (e !== basename(candidatePath) && candidateBase(e) === name) {

      await fs.rm(join(dir, e), { recursive: true, force: true });

    }

  }

  await fs.rename(join(repo.root, candidatePath), join(repo.root, base));

  await repo.refresh();

}

export async function markResolved(repo: Repository): Promise<void> {

  const r = await repo.oxy.run(repo.root, ["resolve", "--json"]);

  await repo.refresh();

  const status = repo.status;

  if (!status || !status.conflicted) {

    void vscode.window.showInformationMessage("Oxygen: no conflicts remain.");

    return;

  }

  const unresolved = status.conflicts.filter((c) => c.resolved !== true);

  if (unresolved.length === 0) {

    void vscode.window.showInformationMessage("Oxygen: every conflict is resolved; commit to record the resolution.");

  } else {

    const names = unresolved.map((c) => `${c.path ?? c.kind}${c.resolved === "markers" ? " (markers remain)" : ""}`).join(", ");

    void vscode.window.showWarningMessage(`Oxygen: still to resolve: ${names}`);

  }

  void r;

}

// Parser for oxy conflict markers (spec §9.5). No vscode imports, so it is

// tested with plain Node.

//

//   <<<<<<< oxy conflict 1 of 2, side 1 of 2: change k7m2p9 "Add retry loop"

//   ...

//   ======= oxy conflict 1 of 2, side 2 of 2: change q3x8w1 "Refactor client"

//   ...

//   >>>>>>> oxy conflict 1 of 2 end

//

// A delete/insert conflict's first side reads `deleted by change X` and is

// followed by a `-------` line and the deleted context.

export interface ConflictSide {

  /** 1-based side number. */

  number: number;

  /** `k7m2p9 "Add retry loop"` or `deleted by change k7m2p9`. */

  label: string;

  deleted: boolean;

  /** Line index of the side's header. */

  header: number;

  /** Content lines (exclusive end). */

  start: number;

  end: number;

}

export interface ConflictRegion {

  number: number;

  total: number;

  /** Line index of `<<<<<<<`. */

  start: number;

  /** Line index of `>>>>>>>`. */

  end: number;

  sides: ConflictSide[];

}

const OPEN = /^<<<<<<< oxy conflict (\d+) of (\d+), side (\d+) of (\d+): (.*)$/;

const NEXT = /^======= oxy conflict (\d+) of (\d+), side (\d+) of (\d+): (.*)$/;

const CLOSE = /^>>>>>>> oxy conflict (\d+) of (\d+) end$/;

export function parseConflicts(lines: string[]): ConflictRegion[] {

  const regions: ConflictRegion[] = [];

  let current: ConflictRegion | undefined;

  let side: ConflictSide | undefined;

  for (let i = 0; i < lines.length; i++) {

    const line = lines[i];

    const open = OPEN.exec(line);

    if (open && !current) {

      current = { number: Number(open[1]), total: Number(open[2]), start: i, end: -1, sides: [] };

      side = newSide(Number(open[3]), open[5], i);

      if (side.deleted && lines[i + 1] === "-------") {

        side.start = i + 2;

        i += 1;

      }

      current.sides.push(side);

      continue;

    }

    const next = current ? NEXT.exec(line) : null;

    if (next && current && side) {

      side.end = i;

      side = newSide(Number(next[3]), next[5], i);

      current.sides.push(side);

      continue;

    }

    const close = current ? CLOSE.exec(line) : null;

    if (close && current && side) {

      side.end = i;

      current.end = i;

      regions.push(current);

      current = undefined;

      side = undefined;

    }

  }

  return regions;

}

function newSide(number: number, label: string, header: number): ConflictSide {

  const deleted = label.startsWith("deleted by change ");

  return { number, label: deleted ? label : label.replace(/^change /, ""), deleted, header, start: header + 1, end: header + 1 };

}

/** The lines that replace a region when `keep` (side numbers) are kept, in order. */

export function resolveRegion(lines: string[], region: ConflictRegion, keep: number[]): string[] {

  const out: string[] = [];

  for (const n of keep) {

    const side = region.sides.find((s) => s.number === n);

    if (!side || side.deleted) {

      continue;

    }

    out.push(...lines.slice(side.start, side.end));

  }

  return out;

}

/** A conflict candidate file's real name, or undefined. */

export function candidateBase(path: string): string | undefined {

  const m = /^(.*)\.oxy-conflict-\d+$/.exec(path);

  return m ? m[1] : undefined;

}

import { test } from "node:test";

import assert from "node:assert/strict";

import { parseConflicts, resolveRegion, candidateBase } from "../out/markers.mjs";

test("parses order conflicts with several sides", () => {

  const lines = [

    "a",

    '<<<<<<< oxy conflict 1 of 2, side 1 of 3: change 872724ae "Doing"',

    "How are you doing?",

    '======= oxy conflict 1 of 2, side 2 of 3: change 194a1869 "Today"',

    "How are you today?",

    '======= oxy conflict 1 of 2, side 3 of 3: change 55555555 "Third"',

    "third",

    "more third",

    ">>>>>>> oxy conflict 1 of 2 end",

    "z",

  ];

  const regions = parseConflicts(lines);

  assert.equal(regions.length, 1);

  const r = regions[0];

  assert.deepEqual([r.number, r.total, r.start, r.end], [1, 2, 1, 8]);

  assert.deepEqual(r.sides.map((s) => [s.number, s.label, s.start, s.end]), [

    [1, '872724ae "Doing"', 2, 3],

    [2, '194a1869 "Today"', 4, 5],

    [3, '55555555 "Third"', 6, 8],

  ]);

  assert.deepEqual(resolveRegion(lines, r, [2]), ["How are you today?"]);

  assert.deepEqual(resolveRegion(lines, r, [1, 3]), ["How are you doing?", "third", "more third"]);

});

test("parses delete versus insert conflicts", () => {

  const lines = [

    "<<<<<<< oxy conflict 1 of 1, side 1 of 2: deleted by change 0101",

    "-------",

    "a",

    "======= oxy conflict 1 of 1, side 2 of 2: change 0202",

    "after-a",

    ">>>>>>> oxy conflict 1 of 1 end",

  ];

  const [r] = parseConflicts(lines);

  assert.equal(r.sides[0].deleted, true);

  assert.deepEqual([r.sides[0].start, r.sides[0].end], [2, 3]);

  assert.deepEqual(resolveRegion(lines, r, [1]), [], "accepting the deletion keeps nothing");

  assert.deepEqual(resolveRegion(lines, r, [2]), ["after-a"]);

  assert.deepEqual(parseConflicts(["plain", "text"]), []);

});

test("candidate names", () => {

  assert.equal(candidateBase("dir/a.txt.oxy-conflict-2"), "dir/a.txt");

  assert.equal(candidateBase("a.txt"), undefined);

});

## 0.5.0 (2026-09-27)

Milestone 0.5: conflict editor CodeLens over oxy markers (accept a side, all sides, or a deletion), keep-this-candidate for tree conflicts, Mark Resolved, and the commit action reads "Commit resolution" once every conflict is resolved.

  "version": "0.5.0",

      { "command": "oxygen.showChange", "title": "Show Change", "category": "Oxygen" },

      { "command": "oxygen.acceptSides", "title": "Accept Conflict Sides", "category": "Oxygen" },

      { "command": "oxygen.keepCandidate", "title": "Keep This Candidate", "category": "Oxygen", "icon": "$(check)" },

      { "command": "oxygen.markResolved", "title": "Mark Resolved", "category": "Oxygen", "icon": "$(check-all)" },

      { "command": "oxygen.openConflict", "title": "Open Conflict", "category": "Oxygen" }

        { "command": "oxygen.markResolved", "group": "2_commit@3", "when": "scmProvider == oxygen" },

        { "command": "oxygen.discard", "group": "1_modification@2", "when": "scmProvider == oxygen" },

        { "command": "oxygen.keepCandidate", "group": "inline@0", "when": "scmProvider == oxygen && scmResourceState == candidate" },

        { "command": "oxygen.keepCandidate", "group": "0_conflict", "when": "scmProvider == oxygen && scmResourceState == candidate" }

      ],

      "scm/resourceGroup/context": [

        { "command": "oxygen.markResolved", "group": "inline", "when": "scmProvider == oxygen && scmResourceGroup == conflicts" }

        { "command": "oxygen.showChange", "when": "false" },

        { "command": "oxygen.acceptSides", "when": "false" },

        { "command": "oxygen.keepCandidate", "when": "false" },

        { "command": "oxygen.openConflict", "when": "false" }

    "pretest": "esbuild src/oxy.ts --bundle --platform=node --format=esm --outfile=out/oxy.mjs && esbuild src/diffutil.ts --bundle --platform=node --format=esm --outfile=out/diffutil.mjs && esbuild src/markers.ts --bundle --platform=node --format=esm --outfile=out/markers.mjs",

import { ConflictCodeLensProvider, acceptSides, keepCandidate, markResolved } from "./conflicts";

let conflictLenses: ConflictCodeLensProvider;

  conflictLenses = new ConflictCodeLensProvider(() => [...repositories.values()]);

  context.subscriptions.push(vscode.languages.registerCodeLensProvider({ scheme: "file" }, conflictLenses));

    vscode.commands.registerCommand("oxygen.acceptSides", (uri: vscode.Uri, index: number, keep: number[]) => acceptSides(uri, index, keep).catch(showError)),

    vscode.commands.registerCommand("oxygen.keepCandidate", (state?: OxyResourceState) => state && keepCandidate(state.repository, state.path).catch(showError)),

    vscode.commands.registerCommand("oxygen.markResolved", (arg?: Repository | vscode.SourceControl) => {

      const repo = repositoryFor(arg);

      return repo && markResolved(repo).catch(showError);

    }),

    vscode.commands.registerCommand("oxygen.openConflict", (state?: OxyResourceState) => state && vscode.commands.executeCommand("vscode.open", state.resourceUri)),

      repo.onDidChangeStatus((status) => {

        conflictLenses.refresh();

        // The commit action reads as a resolution while conflicts are resolved but uncommitted.

        const resolved = status.conflicted && status.conflicts.length > 0 && status.conflicts.every((c) => c.resolved === true);

        repo.sourceControl.acceptInputCommand = { command: "oxygen.commit", title: resolved ? "Commit resolution" : "Commit", arguments: [repo] };

        repo.sourceControl.inputBox.placeholder = resolved ? "Describe the resolution (Ctrl+Enter to commit)" : "Message (Ctrl+Enter to commit)";

    this.contextValue = /\.oxy-conflict-\d+$/.test(path) ? "candidate" : status === "ConflictEdited" ? "markers" : status;

  contextValue: string;