Withdraw tags, verify the transparency log, shallow clones, keep a side or both sides of a conflict, commit and amend by paths, merge remote bookmarks (closes #11) dac6876e4d08

// Settling conflicts with oxy's one-command answers (spec §5.7): keep one

// side of a binary file's or subrepo pin's replace conflict (oxygen#140),

// and keep every side of two changes adding lines at the same place

// (oxygen#121). The choices and the words live here, apart from VS Code,

// so they are tested.

import { ConflictInfo, KeptBoth } from "./oxy";

import { candidateBase } from "./markers";

/** One way to settle a conflict, as the quick pick offers it. */

export interface SettleChoice {

  label: string;

  description?: string;

  detail?: string;

  /** keep-side: write that side's version and settle; keep-current: settle with the working copy; open-subrepo: move the subrepo first. */

  action: "keep-side" | "keep-current" | "open-subrepo";

  /** The side's ChangeId, for keep-side. */

  change?: string;

}

/** Whether a conflict is a replace conflict: a binary file or subrepo pin changed two ways, with no markers to edit. */

export function isReplaceConflict(c: ConflictInfo): boolean {

  return c.kind === "replace" && !!c.path;

}

/**

 * The choices for a replace conflict. A file offers each side (the version

 * the side's change made); a subrepo pin offers the pin the nested

 * repository holds now, since oxy settles a pin with what the working copy

 * holds there, or opening it to move it first. `subjects` maps a side's

 * ChangeId to its subject line, where known.

 */

export function replaceChoices(c: ConflictInfo, subrepo: boolean, subjects: Map<string, string> = new Map()): SettleChoice[] {

  if (subrepo) {

    return [

      { label: "$(check) Keep the pin the subrepo holds now", description: c.path, detail: "Settles the pin conflict with the nested repository's current state (oxy resolve)", action: "keep-current" },

      { label: "$(folder-opened) Open the subrepo to move it first", detail: "Check out the side you want inside it, then come back and keep that pin", action: "open-subrepo" },

    ];

  }

  const sides: SettleChoice[] = (c.changes ?? []).map((id, i) => ({

    label: `$(check) Keep side ${i + 1}`,

    description: `${id.slice(0, 8)}${subjects.get(id) ? ` "${subjects.get(id)}"` : ""}`,

    detail: `The version change ${id.slice(0, 8)} made replaces every other`,

    action: "keep-side",

    change: id,

  }));

  return [

    ...sides,

    { label: "$(edit) Keep what the working copy holds now", description: c.path, detail: "Settles with the file as it is on disk; its .oxy-conflict-N candidates are removed (oxy resolve)", action: "keep-current" },

  ];

}

/** The `.oxy-conflict-N` candidates of `path` among a directory's entries (names, not paths). */

export function candidatesOf(name: string, entries: string[]): string[] {

  return entries.filter((e) => candidateBase(e) === name);

}

/** The modal question before withdrawing a tag. */

export function withdrawQuestion(tag: string): { message: string; detail: string } {

  return {

    message: `Withdraw tag ${tag}?`,

    detail:

      "The withdrawal is signed with your key and kept beside the tag's creation, and oxy push sends it to remotes that have the tag. It is logged, not erased, and the name can never be used again.",

  };

}

/** One line saying what `oxy resolve --both` did. */

export function keptBothSummary(r: KeptBoth): { message: string; settled: boolean; warn: boolean } {

  const kept = r.kept.reduce((n, k) => n + k.conflicts.length, 0);

  const files = new Set(r.kept.map((k) => k.path)).size;

  const parts: string[] = [];

  if (kept > 0) {

    parts.push(`kept every side of ${kept} conflict${kept === 1 ? "" : "s"} in ${files} file${files === 1 ? "" : "s"}`);

  }

  for (const l of r.left) {

    parts.push(`${l.path} conflict ${l.conflict} keeps its markers: ${l.why}`);

  }

  if (parts.length === 0) {

    return { message: "no conflict where two changes only add lines at the same place", settled: false, warn: true };

  }

  return { message: parts.join("; "), settled: kept > 0, warn: r.left.length > 0 };

}

// The transparency log's lines in the Trust view (spec §5.12): what

// `oxy tlog verify --json` proved, who cosigned it, or why it failed. No

// vscode imports, so it is tested with plain Node.

import { TlogInfo } from "./oxy";

/** The last check of a repository's hub log: its result or its error. */

export type TlogCheck = { info: TlogInfo; when_ms: number } | { error: string; when_ms: number };

export interface TlogLine {

  label: string;

  description?: string;

  tooltip?: string;

  icon: string;

}

/** The Trust view's lines for a log check; `ago` words a time (milliseconds since the epoch). */

export function tlogLines(check: TlogCheck | undefined, ago: (ms: number) => string): TlogLine[] {

  if (!check) {

    return [{ label: "Transparency log not checked", description: "click to verify the hub's log", icon: "shield", tooltip: "Runs oxy tlog verify: checks that the hub shows everyone the same history." }];

  }

  if ("error" in check) {

    const first = check.error.trim().split("\n")[0] || "oxy tlog verify failed";

    return [{ label: "Transparency log NOT verified", description: first, icon: "error", tooltip: check.error.trim() }];

  }

  const { info } = check;

  const mine = info.entries.length;

  const lines: TlogLine[] = [

    {

      label: `Transparency log verified up to checkpoint ${info.size}`,

      description: `${info.origin} · ${mine} entr${mine === 1 ? "y" : "ies"} for this repository · ${ago(check.when_ms)}`,

      icon: "verified",

      tooltip: `${info.hub}\nRoot ${info.root}\nEvery entry checks against the root its log key signed, and the log extends what you saw before.`,

    },

  ];

  if (info.witnesses.length === 0) {

    lines.push({ label: "Cosigned by no witness you trust", icon: "warning", tooltip: "Without a witness, only your own past checks show the hub has not forked its log." });

  } else {

    for (const w of info.witnesses) {

      lines.push({ label: `Cosigned by ${w.name}`, description: ago(w.time_ms), icon: "key" });

    }

  }

  return lines;

}

// Settling conflicts with oxy's one-command answers: the choices offered for

// a binary file's or subrepo pin's conflict, the candidates removed, and the

// words for a withdrawal and for oxy resolve --both.

import { test } from "node:test";

import assert from "node:assert/strict";

import { candidatesOf, isReplaceConflict, keptBothSummary, replaceChoices, withdrawQuestion } from "../out/settle.mjs";

const replace = { kind: "replace", path: "img/logo.png", changes: ["4189430d989317c02de6b3c12f1c433f", "9c0c8ef6b612ef990bc72f812ff732cc"], resolved: false };

test("a binary file's conflict offers each side, then the working copy's version", () => {

  assert.equal(isReplaceConflict(replace), true);

  assert.equal(isReplaceConflict({ kind: "text", path: "a.txt" }), false);

  const choices = replaceChoices(replace, false, new Map([["9c0c8ef6b612ef990bc72f812ff732cc", "New logo"]]));

  assert.deepEqual(

    choices.map((c) => [c.action, c.change, c.label, c.description]),

    [

      ["keep-side", "4189430d989317c02de6b3c12f1c433f", "$(check) Keep side 1", "4189430d"],

      ["keep-side", "9c0c8ef6b612ef990bc72f812ff732cc", "$(check) Keep side 2", '9c0c8ef6 "New logo"'],

      ["keep-current", undefined, "$(edit) Keep what the working copy holds now", "img/logo.png"],

    ],

  );

});

test("a subrepo pin's conflict keeps the pin the subrepo holds, or opens it to move it", () => {

  const choices = replaceChoices({ ...replace, path: "libs/lib" }, true);

  assert.deepEqual(choices.map((c) => c.action), ["keep-current", "open-subrepo"]);

  assert.match(choices[0].label, /Keep the pin the subrepo holds now/);

});

test("only the file's own candidates are removed", () => {

  assert.deepEqual(candidatesOf("logo.png", ["logo.png", "logo.png.oxy-conflict-2", "logo.png.oxy-conflict-3", "other.png.oxy-conflict-2", "logo.png.bak"]), ["logo.png.oxy-conflict-2", "logo.png.oxy-conflict-3"]);

  assert.deepEqual(candidatesOf("a", []), []);

});

test("withdrawing a tag says it is signed, kept and logged", () => {

  const q = withdrawQuestion("v1.2");

  assert.equal(q.message, "Withdraw tag v1.2?");

  assert.match(q.detail, /signed/);

  assert.match(q.detail, /kept/);

  assert.match(q.detail, /logged/);

  assert.match(q.detail, /never be used again/);

});

test("oxy resolve --both's result in one line", () => {

  assert.deepEqual(keptBothSummary({ kept: [{ path: "a.txt", conflicts: [1, 2] }, { path: "b.txt", conflicts: [1] }], left: [] }), {

    message: "kept every side of 3 conflicts in 2 files",

    settled: true,

    warn: false,

  });

  const mixed = keptBothSummary({ kept: [{ path: "a.txt", conflicts: [1] }], left: [{ path: "a.txt", conflict: 2, why: "both sides changed these lines; edit the markers" }] });

  assert.equal(mixed.settled, true);

  assert.equal(mixed.warn, true);

  assert.match(mixed.message, /a\.txt conflict 2 keeps its markers: both sides changed these lines/);

  assert.deepEqual(keptBothSummary({ kept: [], left: [] }).settled, false);

});

// The Trust view's transparency log lines, from `oxy tlog verify --json`.

import { test } from "node:test";

import assert from "node:assert/strict";

import { tlogLines } from "../out/tlog.mjs";

const ago = (ms) => `at ${ms}`;

const info = {

  hub: "https://oxygenhub.io",

  origin: "oxygenhub.io/log",

  size: 15553,

  root: "6f8b13148d40652127b016ec332166f45cd47c5aa2b51fe5fa8fb12f54d978a5",

  witnesses: [

    { name: "plex.witness", time_ms: 1793297007000 },

    { name: "narvi.witness", time_ms: 1793297007000 },

  ],

  entries: [{ index: 19, kind: "ref", repo: "3ad24d80c177396edd83fe470e431ec6", object: "ff04", signers: ["5506"], received_ms: 1792280811530 }],

};

test("not checked yet: one line offering the check", () => {

  const [line, ...rest] = tlogLines(undefined, ago);

  assert.equal(rest.length, 0);

  assert.equal(line.label, "Transparency log not checked");

  assert.equal(line.icon, "shield");

});

test("verified: the checkpoint, this repository's entries, and each witness", () => {

  const lines = tlogLines({ info, when_ms: 5 }, ago);

  assert.deepEqual(

    lines.map((l) => [l.label, l.description, l.icon]),

    [

      ["Transparency log verified up to checkpoint 15553", "oxygenhub.io/log · 1 entry for this repository · at 5", "verified"],

      ["Cosigned by plex.witness", "at 1793297007000", "key"],

      ["Cosigned by narvi.witness", "at 1793297007000", "key"],

    ],

  );

});

test("no witness is a warning, and a failure shows oxy's error", () => {

  const lines = tlogLines({ info: { ...info, witnesses: [], entries: [] }, when_ms: 5 }, ago);

  assert.match(lines[0].description, /0 entries/);

  assert.deepEqual([lines[1].label, lines[1].icon], ["Cosigned by no witness you trust", "warning"]);

  const [failed] = tlogLines({ error: "the checkpoint does not extend the one seen before\nmore", when_ms: 5 }, ago);

  assert.deepEqual([failed.label, failed.description, failed.icon], ["Transparency log NOT verified", "the checkpoint does not extend the one seen before", "error"]);

});

- **Fix up the last change with only some files:** right-click them and choose **Amend Selected Paths**.

   - A binary file or subrepo pin changed two ways has no markers: **Keep a Side…** on it keeps one side's version.

   - Where two changes only added lines at the same place, **Keep Both Sides…** keeps every side, earliest change first. Oxygen leaves the markers where the sides changed the same lines and says so.

   - **Commit Resolution of Selected Paths** commits what you have resolved so far and leaves the rest for later.

- **Merge Bookmark…** also lists remotes' bookmarks, such as `origin/develop`, as last fetched.

- **Clone Repository…** offers a **Shallow** clone (latest state only) for big repositories.

The **Oxygen Trust** view shows the repository's trust policy and each change's signature. **Verify Signatures** checks them all. **Verify Transparency Log** checks that your hub shows everyone the same history. The view then shows the checkpoint it verified and the witnesses who cosigned it.

**Withdraw Tag…**, also in **Tags…**, withdraws a tag. The withdrawal is signed and kept, and push sends it on. The tag's name can't be used again.

| Branch picker in the status bar | **Bookmark** picker: switch, create, merge (a remote's bookmark too) | `oxy bookmark`, `oxy merge REMOTE/BOOKMARK` |

| Merge conflict editor (Accept current / incoming / both) | **Conflict editor** over `oxy` markers with the same CodeLens actions, plus "Mark resolved" that runs `oxy resolve`, "Keep a Side" for binary files and subrepo pins, and "Keep Both Sides" for lines added at the same place | Markers name the contributing changes |

| — | Trust panel: signature status per change, policy summary, the hub's transparency log | `oxy verify --json`, `oxy policy show --json`, `oxy tlog verify --json` |

| `oxy commit -m M PATH..`, `oxy amend PATH..` | Commit or amend only these paths, a conflict's resolution included; the rest stays uncommitted (oxy 0.5.0) |

| `oxy bookmark list --all --json` | Also remotes' bookmarks with no local one, named `REMOTE/NAME`; `oxy merge REMOTE/NAME` merges one as last fetched (oxygen#117) |

| `oxy resolve PATH..` | Settle a binary file's or subrepo pin's replace conflict with what the working copy holds there (oxygen#140) |

| `oxy resolve --both [--reverse] [PATH..]` | Keep every side of each adjacent insertion, earliest change first; reports what keeps its markers and why (oxygen#121, oxy 0.8.0) |

| `oxy tag delete NAME -r REASON` | Withdraw a tag: a signed withdrawal kept beside its creation; the name is never reused |

| `oxy tlog verify --json [HUB]` | The hub's transparency log checked: checkpoint size, root, witnesses' cosignatures, this repository's entries |

| `oxy clone --depth 0 URL DIR` | A shallow clone from the remote's checkpoint: the latest state only |

- Entry actions: Open file, Open changes, Discard changes (confirm), Commit only this path, Amend selected paths.

- Multi-select commit: selecting entries and choosing "Commit selected" runs `oxy commit PATH..`; "Amend Selected Paths" runs `oxy amend PATH..`, folding only those into the head the working copy sits on.

- The message box supports multi-line messages; `Ctrl+Enter` commits everything, the dropdown offers **Commit selected paths**, **Commit hunks…** (opens a quick pick of hunks from `oxy hunks --json`), **Amend**, **Amend selected paths** (`oxy amend PATH..`), **Amend into…** (quick pick of changes), and **Commit and push**.

- **Merge bookmark…** lists the other local bookmarks, then remotes' bookmarks that have no local one (`oxy bookmark list --all --json`, shown as `origin/develop`, "as last fetched"); picking one runs `oxy merge` with that name.

- **Tags…** lists tags to check out, plus **Create tag…** and **Withdraw a tag…**. **Withdraw Tag…** asks for the tag and a reason, confirms in a modal that the withdrawal is signed with your key, kept beside the tag's creation and logged (pushed to remotes that have the tag), and that the name is never used again, then runs `oxy tag delete NAME -r REASON`.

- A binary file's or subrepo pin's conflict (a replace conflict, no markers to edit) shows **Keep a Side…**. For a file it offers each side, labelled with the side's change, plus the version on disk: keeping a side writes that change's version of the file (`oxy cat PATH -r CHANGE`), removes the `.oxy-conflict-N` candidates, and runs `oxy resolve PATH`, which settles the conflict with what the working copy holds. For a subrepo pin it offers the pin the nested repository holds now, or opening the subrepo to move it first (oxygen#140).

- A text conflict, and the Conflicts group, offer **Keep Both Sides (Lines Added at the Same Place)…**: `oxy resolve --both [PATH..]`, earliest change first or (`--reverse`) latest first. Where the sides changed the same lines the markers stay, and oxy's reason is shown (oxygen#121; needs oxy 0.8.0).

- **Commit Resolution of Selected Paths**, on entries of the Conflicts group, commits only those paths' resolution (`oxy commit -m M PATH..`) while other conflicts stay for later; it asks first if a chosen path is not resolved yet.

- The Trust view's last line is the hub's **transparency log**. It is checked on request, not on refresh, since it asks the hub: **Verify Transparency Log** (the view's title button, the line itself, or the command) runs `oxy tlog verify --json` against the checkout's remote and shows "verified up to checkpoint N" with the log's origin and this repository's entry count, then one line per witness that cosigned the checkpoint (or a warning that none you trust did), or the error when the check fails.

- **Clone Repository…** asks for the URL and the parent folder, then offers **Full history** or **Shallow** (latest state only, fast for big repositories), which runs `oxy clone --depth 0 URL DIR`.

Commit, Commit Selected Paths, Commit Resolution of Selected Paths, Commit Hunks…, Amend, Amend Selected Paths, Amend Into…, Discard Changes, Refresh, Fetch, Pull, Push, Push Bookmark…, Sync, Switch Bookmark…, Create Bookmark…, Merge Bookmark…, Delete Bookmark…, Open History, Open Operation Log, Undo Last Operation, Toggle Inline Blame, Show Blame, Resolve Conflicts, Mark Resolved, Keep a Side…, Keep Both Sides (Lines Added at the Same Place)…, Checkout Change…, Describe Change…, Abandon Change…, Squash Into…, Rebase Onto…, Tags…, Create Tag…, Withdraw Tag…, Add Workspace…, Update Subrepos, Bisect Start/Good/Bad/Skip/Run/Reset, Verify Signatures, Verify Transparency Log, Show Policy, Open Output, Clone Repository…, Initialize Repository.

## 8b. Implementation notes (2026-10-29): oxy 0.5 to 0.9

- Brought up to oxy 0.9 (oxygen-vscode#11): tag withdrawal, the transparency log in the Trust view, shallow clone, keep-a-side and keep-both-sides settling, commit and amend by paths, and merging a remote's bookmark, each through the commands in §4.

- The CLI names a withdrawal `oxy tag delete NAME -r REASON` (help: "Withdraw a tag"); there is no `tag withdraw` subcommand.

- `oxy resolve PATH` settles a replace conflict with whatever the working copy holds; there is no per-side flag, so the extension writes the chosen side's version first. `oxy status --json` does not say which text conflicts are adjacent insertions (only the human output does), so **Keep Both Sides** is offered on every text conflict and reports oxy's refusals.

- `oxy resolve --both` needs oxy 0.8.0; the tests that use it are skipped on older oxy.

- `bookmark list --all --json` marks no field for a remote's bookmark; the extension recognises one by its `REMOTE/` name prefix, `remote` field and null ahead/behind counts.

        "command": "oxygen.commitResolution",

        "title": "Commit Resolution of Selected Paths",

        "category": "Oxygen",

        "icon": "$(check)"

      },

      {

      },

      {

        "command": "oxygen.amendSelected",

        "title": "Amend Selected Paths",

        "category": "Oxygen",

        "icon": "$(edit)"

        "command": "oxygen.keepSide",

        "title": "Keep a Side\u2026",

        "category": "Oxygen",

        "icon": "$(check)"

      },

      {

        "command": "oxygen.keepBothSides",

        "title": "Keep Both Sides (Lines Added at the Same Place)\u2026",

        "category": "Oxygen",

        "icon": "$(list-flat)"

      },

      {

        "command": "oxygen.verifyTlog",

        "title": "Verify Transparency Log",

        "category": "Oxygen",

        "icon": "$(verified)"

      },

      {

      },

      {

        "command": "oxygen.withdrawTag",

        "title": "Withdraw Tag\u2026",

        "category": "Oxygen",

        "icon": "$(circle-slash)"

          "command": "oxygen.withdrawTag",

          "command": "oxygen.addWorkspace",

          "command": "oxygen.updateSubrepos",

          "command": "oxygen.verify",

          "group": "6_more@6",

          "when": "scmProvider == oxygen"

        },

        {

          "command": "oxygen.verifyTlog",

          "group": "6_more@7",

          "when": "scmProvider == oxygen"

        },

        {

        },

        {

          "command": "oxygen.amendSelected",

          "group": "1_modification@3",

          "when": "scmProvider == oxygen && scmResourceGroup == changes"

        },

        {

          "command": "oxygen.keepSide",

          "group": "inline@0",

          "when": "scmProvider == oxygen && scmResourceState == replace"

        },

        {

          "command": "oxygen.keepSide",

          "group": "0_conflict@1",

          "when": "scmProvider == oxygen && scmResourceState == replace"

        },

        {

          "command": "oxygen.keepBothSides",

          "group": "0_conflict@2",

          "when": "scmProvider == oxygen && scmResourceGroup == conflicts && scmResourceState == markers"

        },

        {

          "command": "oxygen.commitResolution",

          "group": "0_conflict@3",

          "when": "scmProvider == oxygen && scmResourceGroup == conflicts"

          "when": "scmProvider == oxygen && scmResourceGroup == conflicts"

        },

        {

          "command": "oxygen.keepBothSides",

          "group": "1_conflict@1",

          "group": "navigation",

          "when": "view == oxygen.trust"

        },

        {

          "command": "oxygen.verifyTlog",

          "when": "false"

        },

        {

          "command": "oxygen.amendSelected",

          "when": "false"

        },

        {

          "command": "oxygen.commitResolution",

          "when": "false"

        },

        {

          "command": "oxygen.keepSide",

    "pretest": "esbuild src/oxy.ts --bundle --platform=node --format=esm --sourcemap --outfile=out/oxy.mjs && esbuild src/diffutil.ts --bundle --platform=node --format=esm --sourcemap --outfile=out/diffutil.mjs && esbuild src/markers.ts --bundle --platform=node --format=esm --sourcemap --outfile=out/markers.mjs && esbuild src/api.ts --bundle --platform=node --format=esm --sourcemap --outfile=out/api.mjs && esbuild src/commitbox.ts --bundle --platform=node --format=esm --sourcemap --outfile=out/commitbox.mjs && esbuild src/handoff.ts --bundle --platform=node --format=esm --sourcemap --outfile=out/handoff.mjs && esbuild src/paths.ts --bundle --platform=node --format=esm --sourcemap --outfile=out/paths.mjs && esbuild src/looks.ts --bundle --platform=node --format=esm --sourcemap --outfile=out/looks.mjs && esbuild src/settle.ts --bundle --platform=node --format=esm --sourcemap --outfile=out/settle.mjs && esbuild src/tlog.ts --bundle --platform=node --format=esm --sourcemap --outfile=out/tlog.mjs",

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

import { Oxy, OxyError, ShowInfo, findBinary, mergeChoices } from "./oxy";

import { readFile, readdir, rm, stat, writeFile } from "node:fs/promises";

import { candidatesOf, keptBothSummary, replaceChoices, withdrawQuestion } from "./settle";

    vscode.commands.registerCommand("oxygen.amendSelected", (state?: OxyResourceState, states?: OxyResourceState[]) => amendSelected(states?.length ? states : state ? [state] : [])),

    vscode.commands.registerCommand("oxygen.commitResolution", (state?: OxyResourceState, states?: OxyResourceState[]) => commitResolution(states?.length ? states : state ? [state] : [])),

    vscode.commands.registerCommand("oxygen.keepSide", (state?: OxyResourceState) => state && keepSide(state)),

    vscode.commands.registerCommand("oxygen.keepBothSides", (arg?: OxyResourceState | Repository | vscode.SourceControlResourceGroup, states?: OxyResourceState[]) => {

      const picked = states?.length ? states : arg instanceof OxyResourceState ? [arg] : [];

      return keepBothSides(picked.length ? picked[0].repository : repositoryFor(arg instanceof Repository ? arg : undefined), picked.map((s) => s.path));

    }),

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

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

    await repo.refresh();

  } catch (e) {

    showError(e);

  }

}

/** Fold only the chosen paths into the head the working copy sits on; the rest stays uncommitted (oxy amend PATH…). */

async function amendSelected(states: OxyResourceState[]): Promise<void> {

  if (states.length === 0) {

    return;

  }

  const repo = states[0].repository;

  const paths = states.map((s) => s.path);

  if (!(await markersOk(repo, paths))) {

    return;

  }

  const message = repo.sourceControl.inputBox.value.trim();

  try {

    await vscode.window.withProgress({ location: vscode.ProgressLocation.SourceControl, title: "Amending" }, () => repo.oxy.amend(repo.root, message || undefined, paths));

    if (message) {

      remember(repo, message);

      repo.sourceControl.inputBox.value = "";

    }

    await repo.refresh();

    vscode.window.setStatusBarMessage(`$(edit) Amended ${paths.length === 1 ? basename(paths[0]) : `${paths.length} paths`} into the last change`, 4000);

  } catch (e) {

    showError(e);

  }

}

/**

 * Commit the resolution of the chosen conflicted paths only (oxy commit

 * PATH… while other conflicts remain): their settled content becomes a

 * resolution change, and the rest stays conflicted for later.

 */

async function commitResolution(states: OxyResourceState[]): Promise<void> {

  if (states.length === 0) {

    return;

  }

  const repo = states[0].repository;

  const paths = states.map((s) => s.path);

  const unresolved = (repo.status?.conflicts ?? []).filter((c) => c.path && paths.includes(c.path) && c.resolved !== true);

  if (unresolved.length > 0) {

    const go = await vscode.window.showWarningMessage(

      `${unresolved.map((c) => c.path).join(", ")} ${unresolved.length === 1 ? "is" : "are"} not resolved yet. Commit anyway?`,

      { modal: true, detail: "Committing records the file as it is; any marker lines become ordinary text." },

      "Commit anyway",

    );

    if (go !== "Commit anyway") {

      return;

    }

  }

  const names = paths.length === 1 ? basename(paths[0]) : `${paths.length} paths`;

  const fromBox = repo.sourceControl.inputBox.value.trim();

  const message = fromBox || (await vscode.window.showInputBox({ prompt: `Describe the resolution of ${names}`, value: `Resolve the conflict in ${paths.join(", ")}` }))?.trim();

  if (!message) {

    return;

  }

  try {

    await vscode.window.withProgress({ location: vscode.ProgressLocation.SourceControl, title: "Committing resolution" }, () => repo.oxy.commit(repo.root, message, paths));

    remember(repo, message);

    repo.sourceControl.inputBox.value = "";

    await repo.refresh();

    const left = repo.status?.conflicts.length ?? 0;

    vscode.window.setStatusBarMessage(`$(check) Committed the resolution of ${names}${left ? `; ${left} conflict${left === 1 ? "" : "s"} remain` : ""}`, 5000);

  } catch (e) {

    showError(e);

  }

}

/**

 * Keep one side of a binary file's or subrepo pin's conflict (oxygen#140):

 * put that side's version in place, remove the other candidates, and run

 * `oxy resolve PATH`, which settles it with what the working copy holds.

 */

async function keepSide(state: OxyResourceState): Promise<void> {

  const repo = state.repository;

  const conflict = repo.status?.conflicts.find((c) => c.path === state.path && c.kind === "replace");

  if (!conflict) {

    void vscode.window.showInformationMessage(`Oxygen: ${state.path} has no binary or subrepo conflict to settle.`);

    return;

  }

  const subrepo = repo.subrepos.some((s) => s.path === state.path);

  const subjects = new Map<string, string>();

  if (!subrepo) {

    await Promise.all(

      (conflict.changes ?? []).map(async (id) => {

        const info = await repo.oxy.show(repo.root, id).catch(() => undefined);

        if (info) {

          subjects.set(id, info.message.split("\n")[0]);

        }

      }),

    );

  }

  const pick = await vscode.window.showQuickPick(replaceChoices(conflict, subrepo, subjects), {

    title: `Settle ${state.path}`,

    placeHolder: subrepo ? "A subrepo pin moved two ways: keep one pin" : "A binary file changed two ways: keep one version",

  });

  if (!pick) {

    return;

  }

  try {

    if (pick.action === "open-subrepo") {

      await vscode.commands.executeCommand("vscode.openFolder", vscode.Uri.file(join(repo.root, state.path)), { forceNewWindow: true });

      return;

    }

    if (!subrepo) {

      // The kept version under the real name; the other candidates would otherwise be committed as new files.

      const file = join(repo.root, state.path);

      if (pick.action === "keep-side" && pick.change) {

        await writeFile(file, await repo.oxy.cat(repo.root, state.path, pick.change));

      }

      const dir = dirname(file);

      for (const c of candidatesOf(basename(file), await readdir(dir))) {

        await rm(join(dir, c), { recursive: true, force: true });

      }

    }

    const status = await repo.oxy.resolvePaths(repo.root, [state.path]);

    await repo.refresh();

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

    vscode.window.setStatusBarMessage(`$(check) Settled ${state.path}; commit to record the resolution${left ? ` (${left} conflict${left === 1 ? "" : "s"} still to resolve)` : ""}`, 6000);

  } catch (e) {

    showError(e);

  }

}

/**

 * Settle adjacent insertions, two changes adding lines at the same place,

 * by keeping every side (oxy resolve --both, oxygen#121). No paths: every

 * conflicted text file. Conflicts whose sides changed the same lines keep

 * their markers, and oxy says why.

 */

async function keepBothSides(repo: Repository | undefined, paths: string[]): Promise<void> {

  if (!repo) {

    return;

  }

  const order = await vscode.window.showQuickPick(

    [

      { label: "$(arrow-down) Earliest change first", description: "oxy resolve --both", reverse: false },

      { label: "$(arrow-up) Latest change first", description: "oxy resolve --both --reverse", reverse: true },

    ],

    { title: `Keep every side where two changes only add lines at the same place${paths.length ? `: ${paths.join(", ")}` : ""}`, placeHolder: "Order of the kept sides" },

  );

  if (!order) {

    return;

  }

  try {

    const result = await repo.oxy.resolveBoth(repo.root, paths, order.reverse);

    const summary = keptBothSummary(result);

    if (summary.warn) {

      void vscode.window.showWarningMessage(`Oxygen: ${summary.message}`);

    } else {

      vscode.window.setStatusBarMessage(`$(check) ${summary.message[0].toUpperCase()}${summary.message.slice(1)}; commit to record the resolution`, 6000);

    }

  } catch (e) {

    showError(e);

  }

}

/** Audit the hub's transparency log (oxy tlog verify) and show the result in the Trust view. */

async function verifyTlog(arg: Repository | vscode.SourceControl | undefined): Promise<void> {

  const repo = repositoryFor(arg);

  if (!repo) {

    return;

  }

  try {

    const info = await vscode.window.withProgress({ location: vscode.ProgressLocation.Notification, title: "Oxygen: verifying the transparency log" }, () => repo.oxy.tlogVerify(repo.root));

    trustView.setTlog(repo.root, { info, when_ms: Date.now() });

    const witnesses = info.witnesses.length ? `cosigned by ${info.witnesses.map((w) => w.name).join(", ")}` : "cosigned by no witness you trust";

    vscode.window.setStatusBarMessage(`$(verified) Transparency log verified up to checkpoint ${info.size}, ${witnesses}`, 6000);

    const message = e instanceof OxyError ? e.message : String(e);

    trustView.setTlog(repo.root, { error: message, when_ms: Date.now() });

      [

        ...list.map((t) => ({ label: `$(tag) ${t.name}`, description: `${t.heads.length} head${t.heads.length === 1 ? "" : "s"}${t.signer ? ` · signed by ${t.signer}` : ""}`, detail: t.message || undefined, tag: t })),

        { label: "$(add) Create tag…", alwaysShow: true, action: "create" as const },

        { label: "$(circle-slash) Withdraw a tag…", alwaysShow: true, action: "withdraw" as const },

      ],

    if ("action" in pick) {

      return pick.action === "create" ? createTag(repo) : withdrawTag(repo);

    }

  } catch (e) {

    showError(e);

  }

}

/** Withdraw a tag (oxy tag delete): signed, kept and logged, never erased; the name is not used again. */

async function withdrawTag(arg: Repository | vscode.SourceControl | undefined): Promise<void> {

  const repo = repositoryFor(arg);

  if (!repo) {

    return;

  }

  try {

    const list = await repo.oxy.tags(repo.root);

    if (list.length === 0) {

      void vscode.window.showInformationMessage("Oxygen: no tags to withdraw.");

      return;

    }

    const pick = await vscode.window.showQuickPick(

      list.map((t) => ({ label: `$(tag) ${t.name}`, description: t.signer ? `signed by ${t.signer}` : "", detail: t.message || undefined, name: t.name })),

      { placeHolder: "Withdraw which tag?" },

    );

    if (!pick) {

      return;

    }

    const reason = await vscode.window.showInputBox({ prompt: `Why is ${pick.name} withdrawn? Recorded with the withdrawal.`, placeHolder: "Built from the wrong state", ignoreFocusOut: true });

    if (reason === undefined) {

      return;

    }

    const q = withdrawQuestion(pick.name);

    if ((await vscode.window.showWarningMessage(q.message, { modal: true, detail: q.detail }, "Withdraw")) !== "Withdraw") {

      return;

    }

    const out = await repo.oxy.tagWithdraw(repo.root, pick.name, reason.trim());

    await repo.refresh();

    vscode.window.setStatusBarMessage(`$(circle-slash) ${out || `Withdrew ${pick.name}`}; push to send the withdrawal`, 6000);

    return;

  }

  const history = await vscode.window.showQuickPick(

    [

      { label: "$(history) Full history", description: "every change", depth: undefined },

      { label: "$(zap) Shallow", description: "latest state only, fast for big repositories", detail: "oxy clone --depth 0: the remote's checkpoint; oxy deepen fetches more later", depth: 0 },

    ],

    { placeHolder: "How much history to clone" },

  );

  if (!history) {

    await vscode.window.withProgress({ location: vscode.ProgressLocation.Notification, title: `Oxygen: cloning ${name}${history.depth === 0 ? " (shallow)" : ""}` }, () =>

      oxy.clone(parent[0].fsPath, url.trim(), dest.fsPath, history.depth),

    );

    // Remotes' bookmarks too, as last fetched (oxy merge origin/develop, oxygen#117).

    const choices = mergeChoices(await repo.oxy.bookmarks(repo.root, true));

    if (choices.length === 0) {

      void vscode.window.showInformationMessage("Oxygen: no other bookmarks, here or on a remote. Fetch to see a remote's.");

      return;

    }

    const picked = await vscode.window.showQuickPick(

      choices.map((c) => ({

        label: `${c.remote ? "$(cloud)" : "$(bookmark)"} ${c.name}`,

        description: `${c.heads} head${c.heads === 1 ? "" : "s"}${c.remote ? ` · on ${c.remote}, as last fetched` : ""}`,

        name: c.name,

      })),

      { placeHolder: `Merge into ${repo.currentBookmark?.name ?? "the current bookmark"}`, matchOnDescription: true },

    );

    const name = picked?.name;

  /** The local bookmarks; with `all`, remotes' bookmarks with no local one too, named `REMOTE/NAME`. */

  bookmarks(root: string, all = false): Promise<BookmarkInfo[]> {

    return this.json<BookmarkInfo[]>(root, ["bookmark", "list", ...(all ? ["--all"] : [])]);

  /** Fold the working copy into the head it sits on; with `paths`, only those (the rest stays uncommitted). */

  amend(root: string, message?: string, paths: string[] = []): Promise<void> {

    return this.check(root, [...args, ...paths]).then(() => undefined);

  /** Union a bookmark's heads into the current one: a local bookmark, or a remote's (`origin/develop`) as last fetched. */

  /** Clone `url` into `dest`; `depth` makes it shallow (0: the latest state only, from the remote's checkpoint). */

  clone(cwd: string, url: string, dest: string, depth?: number): Promise<void> {

    return this.check(cwd, ["clone", ...(depth !== undefined ? ["--depth", String(depth)] : []), url, dest]).then(() => undefined);

  }

  /**

   * Withdraw a tag (`oxy tag delete`): a signed withdrawal kept beside the

   * tag's creation, which push sends on; the name is never used again.

   * Returns oxy's summary line.

   */

  tagWithdraw(root: string, name: string, reason: string): Promise<string> {

    return this.check(root, ["tag", "delete", name, "-r", reason]).then((r) => r.stdout.toString("utf8").trim().split("\n")[0].replace(/^\* /, ""));

  // ---------------------------------------------------------------- settling conflicts

  /**

   * Settle the replace conflicts (binary files, subrepo pins) at `paths`

   * with what the working copy holds there (oxygen#140); the next commit

   * records the resolution. Returns the status after it.

   */

  resolvePaths(root: string, paths: string[]): Promise<StatusInfo> {

    return this.json<StatusInfo>(root, ["resolve", ...paths], [0, 2]);

  }

  /**

   * Settle adjacent insertions (two changes adding lines at the same place)

   * by keeping every side, earliest change first, or latest with `reverse`

   * (oxygen#121). No paths: every conflicted text file. What was kept and

   * what keeps its markers, and why.

   */

  resolveBoth(root: string, paths: string[] = [], reverse = false): Promise<KeptBoth> {

    return this.check(root, ["resolve", "--both", ...(reverse ? ["--reverse"] : []), ...paths], [0, 2]).then((r) => parseKeptBoth(r.stdout.toString("utf8")));

  }

  // ---------------------------------------------------------------- transparency log

  /**

   * Audit a hub's whole transparency log (`oxy tlog verify`): its checkpoint

   * against the log key and the last one seen, and every entry against the

   * root; then this repository's entries. `hub` defaults to the remote.

   */

  tlogVerify(root: string, hub?: string): Promise<TlogInfo> {

    return this.json<TlogInfo>(root, ["tlog", "verify", ...(hub ? [hub] : [])]);

  }

}

/** What `oxy resolve --both` did: the conflicts kept on every side, and those left with markers. */

export interface KeptBoth {

  kept: { path: string; conflicts: number[] }[];

  left: { path: string; conflict: number; why: string }[];

}

/** Read `oxy resolve --both`'s report lines (`kept both  PATH: conflict 1, 2`, `markers    PATH: conflict 3: why`). */

export function parseKeptBoth(text: string): KeptBoth {

  const out: KeptBoth = { kept: [], left: [] };

  for (const line of text.split(/\r?\n/)) {

    const kept = /^kept both\s+(.+): conflicts? ([\d, ]+)$/.exec(line);

    if (kept) {

      out.kept.push({ path: kept[1], conflicts: kept[2].split(",").map((n) => Number(n.trim())).filter((n) => n > 0) });

      continue;

    }

    const left = /^markers\s+(.+): conflict (\d+): (.+)$/.exec(line);

    if (left) {

      out.left.push({ path: left[1], conflict: Number(left[2]), why: left[3] });

    }

  }

  return out;

}

/** `oxy tlog verify --json`: the checkpoint verified, who cosigned it, and the entries listed. */

export interface TlogInfo {

  hub: string;

  origin: string;

  /** Entries in the log the checkpoint covers. */

  size: number;

  root: string;

  witnesses: { name: string; time_ms: number }[];

  entries: { index: number; kind: string; repo: string; object: string; signers: string[]; received_ms: number }[];

}

/**

 * A remote's bookmark that `bookmark list --all` adds because there is no

 * local bookmark of that name: named `REMOTE/NAME`, never current, with no

 * ahead or behind counts. `oxy merge` takes the name as it is.

 */

export function isRemoteBookmark(b: BookmarkInfo): boolean {

  return !!b.remote && b.name.startsWith(`${b.remote}/`) && !b.current && b.ahead === null && b.behind === null;

}

/** What Merge Bookmark offers: the other local bookmarks first, then remotes' bookmarks. */

export function mergeChoices(bookmarks: BookmarkInfo[]): { name: string; remote: string | null; heads: number }[] {

  const local = bookmarks.filter((b) => !b.current && !isRemoteBookmark(b)).map((b) => ({ name: b.name, remote: null, heads: b.heads.length }));

  const remote = bookmarks.filter(isRemoteBookmark).map((b) => ({ name: b.name, remote: b.remote ?? null, heads: b.heads.length }));

  return [...local, ...remote];

  /** The remote it tracks, or for a remote's bookmark (`--all`) the remote it is on. */

  remote?: string | null;

// `oxy bisect status --json`, `oxy policy show --json`, `oxy verify --json`

// and, when asked, `oxy tlog verify --json`.

import { TlogCheck, tlogLines } from "./tlog";

import { timeAgo } from "./operations";

  /** The last transparency log check per repository root; the log is checked on request, not on every refresh (it asks the hub). */

  private readonly tlogChecks = new Map<string, TlogCheck>();

  setTlog(root: string, check: TlogCheck): void {

    this.tlogChecks.set(root, check);

    this.refresh();

  }

    for (const l of tlogLines(this.tlogChecks.get(repo.root), timeAgo)) {

      items.push(new Line(l.label, { icon: l.icon, description: l.description, tooltip: l.tooltip, command: { title: "Verify transparency log", command: "oxygen.verifyTlog", arguments: [repo] } }));

    }

      // A binary file's or subrepo pin's conflict has no markers: it offers Keep Side instead.

      const replace = new Set(status.conflicts.filter((c) => c.kind === "replace" && c.resolved !== true && c.path).map((c) => c.path as string));

      for (const state of conflicts) {

        if (replace.has(state.path) && state.status !== "Resolved") {

          state.contextValue = "replace";

        }

      }

import { mkdtempSync, writeFileSync, mkdirSync, readFileSync, readdirSync, rmSync } from "node:fs";

import { Oxy, findBinary, isRemoteBookmark, mergeChoices, parseKeptBoth } from "../out/oxy.mjs";

/** Whether the oxy under test is at least `min` (a feature newer than the oldest oxy the tests run with). */

const oxyVersion = (await oxy.version()).version;

function atLeast(min) {

  const [a, b] = [oxyVersion, min].map((v) => v.split(/[.-]/).slice(0, 3).map(Number));

  for (let i = 0; i < 3; i++) {

    if (a[i] !== b[i]) {

      return a[i] > b[i];

    }

  }

  return true;

}

});

// ---------------------------------------------------------------- oxy 0.5 to 0.9 (oxygen-vscode#11)

test("oxy resolve --both's report is read", () => {

  const text = [

    "kept both  CHANGELOG.md: conflict 1, 3",

    "markers    CHANGELOG.md: conflict 2: both sides changed these lines; edit the markers",

    "resolved   CHANGELOG.md",

    "markers    src/a.rs",

    "All conflicts are resolved; `oxy commit` will record the resolution.",

  ].join("\n");

  assert.deepEqual(parseKeptBoth(text), {

    kept: [{ path: "CHANGELOG.md", conflicts: [1, 3] }],

    left: [{ path: "CHANGELOG.md", conflict: 2, why: "both sides changed these lines; edit the markers" }],

  });

  assert.deepEqual(parseKeptBoth(""), { kept: [], left: [] });

});

test("Merge Bookmark offers the other local bookmarks, then remotes' bookmarks", () => {

  const list = [

    { name: "main", heads: ["a"], current: true, ahead: 0, behind: 0, remote: "origin" },

    { name: "feature/x", heads: ["b"], current: false, ahead: null, behind: null, remote: null },

    { name: "origin/develop", heads: ["c", "d"], current: false, ahead: null, behind: null, remote: "origin" },

  ];

  assert.deepEqual(list.map(isRemoteBookmark), [false, false, true]);

  assert.deepEqual(mergeChoices(list), [

    { name: "feature/x", remote: null, heads: 1 },

    { name: "origin/develop", remote: "origin", heads: 2 },

  ]);

});

test("tags are withdrawn, signed and never reused", async () => {

  const dir = mkdtempSync(join(tmpdir(), "oxy-vscode-tag-"));

  const home = join(dir, "home");

  mkdirSync(home);

  process.env.OXY_HOME = home;

  await oxy.check(dir, ["init", "repo"]);

  const root = join(dir, "repo");

  await oxy.check(root, ["identity", "create", "--name", "Test", "--email", "[email protected]"]);

  writeFileSync(join(root, "a.txt"), "a\n");

  await oxy.commit(root, "one");

  await oxy.tagCreate(root, "v1", [], "first");

  assert.match(await oxy.tagWithdraw(root, "v1", "built from the wrong state"), /Withdrew v1/);

  assert.deepEqual(await oxy.tags(root), [], "a withdrawn tag is not listed");

  await assert.rejects(oxy.tagCreate(root, "v1", [], "again"), /withdrawn/);

  // No remote, so no hub whose transparency log to check: oxy says so.

  await assert.rejects(oxy.tlogVerify(root), /hub/);

});

test("shallow clone, remote bookmarks merged, amend and commit by paths", async () => {

  const dir = mkdtempSync(join(tmpdir(), "oxy-vscode-paths-"));

  const home = join(dir, "home");

  mkdirSync(home);

  process.env.OXY_HOME = home;

  await oxy.check(dir, ["init", "origin"]);

  const origin = join(dir, "origin");

  await oxy.check(origin, ["identity", "create", "--name", "Test", "--email", "[email protected]"]);

  writeFileSync(join(origin, "a.txt"), "a\n");

  await oxy.commit(origin, "one");

  await oxy.clone(dir, origin, join(dir, "work"), 0);

  const root = join(dir, "work");

  assert.equal(readFileSync(join(root, "a.txt"), "utf8"), "a\n", "the shallow clone has the latest state");

  // Amend only one path: the other stays uncommitted work.

  writeFileSync(join(root, "a.txt"), "a\nmore\n");

  await oxy.commit(root, "more");

  writeFileSync(join(root, "a.txt"), "a\nmore\nagain\n");

  writeFileSync(join(root, "c.txt"), "c\n");

  await oxy.amend(root, undefined, ["a.txt"]);

  const status = await oxy.status(root);

  assert.deepEqual(status.paths.map((p) => p.path), ["c.txt"], "c.txt was not folded in");

  assert.equal((await oxy.cat(root, "a.txt")).toString(), "a\nmore\nagain\n");

  rmSync(join(root, "c.txt"));

  // A bookmark made on the origin is merged here as origin/feat, without a local bookmark.

  await oxy.bookmarkCreate(origin, "feat");

  await oxy.bookmarkSwitch(origin, "feat");

  writeFileSync(join(origin, "f.txt"), "f\n");

  await oxy.commit(origin, "feat work");

  await oxy.fetch(root);

  const all = await oxy.bookmarks(root, true);

  assert.deepEqual(mergeChoices(all).map((c) => [c.name, c.remote]), [["origin/feat", "origin"]]);

  assert.deepEqual((await oxy.bookmarks(root)).map((b) => b.name), ["main"], "without --all, local bookmarks only");

  assert.match(await oxy.merge(root, "origin/feat"), /Merged/);

  assert.equal(readFileSync(join(root, "f.txt"), "utf8"), "f\n");

});

/** A repository whose main and other bookmarks changed `t.txt` (inserting after the same line) and `bin.dat` two ways, merged. */

async function conflicted(prefix, text) {

  const dir = mkdtempSync(join(tmpdir(), prefix));

  const home = join(dir, "home");

  mkdirSync(home);

  process.env.OXY_HOME = home;

  await oxy.check(dir, ["init", "repo"]);

  const root = join(dir, "repo");

  await oxy.check(root, ["identity", "create", "--name", "Test", "--email", "[email protected]"]);

  writeFileSync(join(root, "t.txt"), "a\nb\n");

  writeFileSync(join(root, "u.txt"), "a\nb\n");

  writeFileSync(join(root, "bin.dat"), Buffer.from([0, 1, 2, 3]));

  await oxy.commit(root, "base");

  await oxy.bookmarkCreate(root, "other");

  writeFileSync(join(root, "t.txt"), text("X"));

  writeFileSync(join(root, "u.txt"), "a\nX\n");

  writeFileSync(join(root, "bin.dat"), Buffer.from([0, 1, 2, 4]));

  await oxy.commit(root, "main side");

  await oxy.bookmarkSwitch(root, "other");

  writeFileSync(join(root, "t.txt"), text("Y"));

  writeFileSync(join(root, "u.txt"), "a\nY\n");

  writeFileSync(join(root, "bin.dat"), Buffer.from([0, 1, 2, 5]));

  await oxy.commit(root, "other side");

  await oxy.bookmarkSwitch(root, "main");