Milestone 0.4: history graph webview with per-change actions, file history diffs between versions, inline blame aligned to unsaved edits with a Myers line diff ab81294a9ba9

// Inline blame (spec §5.8): each line's introducing change, author and age

// at the end of the line, computed on the base version and aligned to the

// editor's current text so unsaved edits show as unattributed.

import * as vscode from "vscode";

import { basename } from "node:path";

import { alignLines } from "./diffutil";

import { BlameLine } from "./oxy";

import { Repository } from "./repository";

import { timeAgo } from "./operations";

export class BlameController implements vscode.Disposable {

  private enabled: boolean;

  private readonly decoration: vscode.TextEditorDecorationType;

  private readonly disposables: vscode.Disposable[] = [];

  private cache = new Map<string, { base: string; lines: BlameLine[] }>();

  private timer: NodeJS.Timeout | undefined;

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

    this.enabled = vscode.workspace.getConfiguration("oxygen").get<boolean>("inlineBlame", false);

    this.decoration = vscode.window.createTextEditorDecorationType({

      after: { margin: "0 0 0 3em", color: new vscode.ThemeColor("editorCodeLens.foreground"), fontStyle: "italic" },

      rangeBehavior: vscode.DecorationRangeBehavior.ClosedOpen,

    });

    this.disposables.push(

      this.decoration,

      vscode.window.onDidChangeActiveTextEditor(() => this.schedule()),

      vscode.workspace.onDidChangeTextDocument((e) => e.document === vscode.window.activeTextEditor?.document && this.schedule()),

      vscode.workspace.onDidSaveTextDocument(() => this.schedule()),

      vscode.workspace.onDidChangeConfiguration((e) => {

        if (e.affectsConfiguration("oxygen.inlineBlame")) {

          this.enabled = vscode.workspace.getConfiguration("oxygen").get<boolean>("inlineBlame", false);

          this.schedule();

        }

      }),

    );

    this.schedule();

  }

  toggle(): void {

    this.enabled = !this.enabled;

    void vscode.workspace.getConfiguration("oxygen").update("inlineBlame", this.enabled, vscode.ConfigurationTarget.Global);

    this.schedule();

  }

  /** Forget cached blame for a repository (after any operation). */

  invalidate(root: string): void {

    for (const key of [...this.cache.keys()]) {

      if (key.startsWith(root + "\0")) {

        this.cache.delete(key);

      }

    }

    this.schedule();

  }

  private schedule(): void {

    if (this.timer) {

      clearTimeout(this.timer);

    }

    this.timer = setTimeout(() => void this.apply(), 200);

  }

  private async apply(): Promise<void> {

    const editor = vscode.window.activeTextEditor;

    if (!editor) {

      return;

    }

    if (!this.enabled) {

      editor.setDecorations(this.decoration, []);

      return;

    }

    const repo = this.repositories().find((r) => r.relativePath(editor.document.uri) !== undefined);

    const rel = repo?.relativePath(editor.document.uri);

    if (!repo || !rel) {

      editor.setDecorations(this.decoration, []);

      return;

    }

    const key = repo.root + "\0" + rel;

    let entry = this.cache.get(key);

    if (!entry) {

      try {

        const [base, lines] = await Promise.all([repo.oxy.cat(repo.root, rel), repo.oxy.blame(repo.root, rel)]);

        entry = { base: base.toString("utf8"), lines };

        this.cache.set(key, entry);

      } catch {

        editor.setDecorations(this.decoration, []);

        return;

      }

    }

    if (vscode.window.activeTextEditor !== editor) {

      return;

    }

    const baseLines = splitLines(entry.base);

    const nowLines = splitLines(editor.document.getText());

    const map = alignLines(baseLines, nowLines);

    const byLine = new Map(entry.lines.map((l) => [l.line - 1, l]));

    const decorations: vscode.DecorationOptions[] = [];

    for (let i = 0; i < editor.document.lineCount; i++) {

      const baseIndex = map[i];

      const blame = baseIndex >= 0 ? byLine.get(baseIndex) : undefined;

      const text = blame ? `${blame.change_id.slice(0, 8)} · ${blame.author} · ${timeAgo(blame.when_ms)}` : i < nowLines.length && nowLines[i].length > 0 ? "uncommitted" : "";

      if (!text) {

        continue;

      }

      const line = editor.document.lineAt(i);

      decorations.push({

        range: new vscode.Range(line.range.end, line.range.end),

        renderOptions: { after: { contentText: text } },

        hoverMessage: blame ? new vscode.MarkdownString(`**${blame.author}** · ${new Date(blame.when_ms).toLocaleString()}\n\nChange \`${blame.change_id}\`\n\n[Show change](command:oxygen.showChange?${encodeURIComponent(JSON.stringify([repo.root, blame.hash]))})`, true) : undefined,

      });

    }

    for (const d of decorations) {

      if (d.hoverMessage instanceof vscode.MarkdownString) {

        d.hoverMessage.isTrusted = true;

      }

    }

    editor.setDecorations(this.decoration, decorations);

  }

  dispose(): void {

    if (this.timer) {

      clearTimeout(this.timer);

    }

    for (const d of this.disposables) {

      d.dispose();

    }

  }

}

function splitLines(text: string): string[] {

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

  if (lines.length > 0 && lines[lines.length - 1] === "") {

    lines.pop();

  }

  return lines;

}

export function blameTitle(path: string): string {

  return `Blame: ${basename(path)}`;

}

// A line diff (Myers, O(ND)) used to align blame computed on the base

// version of a file with the lines of the editor's current text.

/** For each line of `after`, the index of the matching line in `before`, or -1 when new. */

export function alignLines(before: string[], after: string[]): number[] {

  const n = before.length;

  const m = after.length;

  const result = new Array<number>(m).fill(-1);

  if (n === 0 || m === 0) {

    return result;

  }

  // Trim common prefix and suffix first; they dominate real edits.

  let start = 0;

  while (start < n && start < m && before[start] === after[start]) {

    result[start] = start;

    start++;

  }

  let endB = n;

  let endA = m;

  while (endB > start && endA > start && before[endB - 1] === after[endA - 1]) {

    endB--;

    endA--;

    result[endA] = endB;

  }

  const a = before.slice(start, endB);

  const b = after.slice(start, endA);

  if (a.length === 0 || b.length === 0) {

    return result;

  }

  // Bail out to positional matching on huge middles to bound memory.

  if (a.length * b.length > 25_000_000) {

    for (let i = 0; i < Math.min(a.length, b.length); i++) {

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

        result[start + i] = start + i;

      }

    }

    return result;

  }

  for (const [i, j] of myers(a, b)) {

    result[start + j] = start + i;

  }

  return result;

}

/** Pairs (i, j) of equal lines a[i] === b[j] along a shortest edit script. */

function myers(a: string[], b: string[]): [number, number][] {

  const n = a.length;

  const m = b.length;

  const max = n + m;

  const offset = max;

  const trace: Int32Array[] = [];

  let v = new Int32Array(2 * max + 2);

  v[offset + 1] = 0;

  outer: for (let d = 0; d <= max; d++) {

    const snapshot = v.slice();

    trace.push(snapshot);

    for (let k = -d; k <= d; k += 2) {

      let x: number;

      if (k === -d || (k !== d && v[offset + k - 1] < v[offset + k + 1])) {

        x = v[offset + k + 1];

      } else {

        x = v[offset + k - 1] + 1;

      }

      let y = x - k;

      while (x < n && y < m && a[x] === b[y]) {

        x++;

        y++;

      }

      v[offset + k] = x;

      if (x >= n && y >= m) {

        break outer;

      }

    }

  }

  // Backtrack.

  const pairs: [number, number][] = [];

  let x = n;

  let y = m;

  for (let d = trace.length - 1; d >= 0; d--) {

    const vd = trace[d];

    const k = x - y;

    let prevK: number;

    if (k === -d || (k !== d && vd[offset + k - 1] < vd[offset + k + 1])) {

      prevK = k + 1;

    } else {

      prevK = k - 1;

    }

    const prevX = vd[offset + prevK];

    const prevY = prevX - prevK;

    while (x > prevX && y > prevY) {

      x--;

      y--;

      pairs.push([x, y]);

    }

    if (d > 0) {

      x = prevX;

      y = prevY;

    }

  }

  return pairs.reverse();

}

// The history view (spec §5.6): a webview drawing the bookmark's changes

// as a graph of dependencies, newest first, heads highlighted, with no

// fake merge nodes. Clicking a change asks the extension to show it.

import * as vscode from "vscode";

import { LogEntry } from "./oxy";

import { Repository } from "./repository";

import { timeAgo } from "./operations";

export class HistoryPanel {

  private static panels = new Map<string, HistoryPanel>();

  private readonly panel: vscode.WebviewPanel;

  private disposed = false;

  static show(repo: Repository, onOpen: (hash: string) => void): void {

    const existing = HistoryPanel.panels.get(repo.root);

    if (existing && !existing.disposed) {

      existing.panel.reveal();

      void existing.render();

      return;

    }

    HistoryPanel.panels.set(repo.root, new HistoryPanel(repo, onOpen));

  }

  static refresh(root: string): void {

    const p = HistoryPanel.panels.get(root);

    if (p && !p.disposed) {

      void p.render();

    }

  }

  private constructor(

    private readonly repo: Repository,

    onOpen: (hash: string) => void,

  ) {

    this.panel = vscode.window.createWebviewPanel("oxygen.history", `History: ${repo.root.split("/").pop()}`, vscode.ViewColumn.Active, { enableScripts: true, retainContextWhenHidden: true });

    this.panel.iconPath = new vscode.ThemeIcon("git-commit");

    this.panel.webview.onDidReceiveMessage((m: { type: string; hash?: string }) => {

      if (m.type === "open" && m.hash) {

        onOpen(m.hash);

      } else if (m.type === "refresh") {

        void this.render();

      }

    });

    this.panel.onDidDispose(() => {

      this.disposed = true;

      HistoryPanel.panels.delete(repo.root);

    });

    void this.render();

  }

  private async render(): Promise<void> {

    let log;

    try {

      log = await this.repo.oxy.log(this.repo.root, 300);

    } catch (e) {

      this.panel.webview.html = `<p>${escape(String(e))}</p>`;

      return;

    }

    const changes = log.changes;

    const lanes = layout(changes);

    this.panel.webview.html = html(this.repo, log.bookmark, changes, lanes);

  }

}

/** Assign each change a lane so that dependency edges flow downward. */

function layout(changes: LogEntry[]): Map<string, number> {

  const lanes = new Map<string, number>();

  const active: (string | undefined)[] = [];

  for (const c of changes) {

    let lane = active.indexOf(c.hash);

    if (lane < 0) {

      lane = active.indexOf(undefined);

      if (lane < 0) {

        lane = active.length;

        active.push(undefined);

      }

    }

    lanes.set(c.hash, lane);

    // The first dependency continues this lane; others take free lanes.

    const deps = c.deps.filter((d) => changes.some((x) => x.hash === d));

    active[lane] = deps[0];

    for (const d of deps.slice(1)) {

      if (!active.includes(d)) {

        const free = active.indexOf(undefined, lane + 1);

        if (free >= 0) {

          active[free] = d;

        } else {

          active.push(d);

        }

      }

    }

    // Lanes whose expected change has appeared elsewhere are free again.

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

      if (active[i] !== undefined && lanes.has(active[i]!)) {

        active[i] = undefined;

      }

    }

  }

  return lanes;

}

function html(repo: Repository, bookmark: string, changes: LogEntry[], lanes: Map<string, number>): string {

  const rowH = 30;

  const laneW = 18;

  const maxLane = Math.max(0, ...lanes.values());

  const graphW = (maxLane + 1) * laneW + 10;

  const index = new Map(changes.map((c, i) => [c.hash, i]));

  const edges: string[] = [];

  const nodes: string[] = [];

  changes.forEach((c, i) => {

    const x = lanes.get(c.hash)! * laneW + 10;

    const y = i * rowH + rowH / 2;

    for (const d of c.deps) {

      const j = index.get(d);

      if (j === undefined) {

        continue;

      }

      const x2 = lanes.get(d)! * laneW + 10;

      const y2 = j * rowH + rowH / 2;

      edges.push(`<path d="M${x},${y} C${x},${y + rowH / 2} ${x2},${y2 - rowH / 2} ${x2},${y2}" />`);

    }

    const cls = c.working_copy ? "wc" : c.head ? "head" : "node";

    nodes.push(`<circle class="${cls}" cx="${x}" cy="${y}" r="5" />`);

  });

  const rows = changes

    .map((c, i) => {

      const subject = c.message.split("\n")[0] || (c.working_copy ? "(working copy)" : "(no description)");

      const sig = c.working_copy ? "" : c.signature?.status === "signed" || c.signature?.status === "sealed" ? (c.signature.revoked ? "⚠" : "✔") : c.signature?.status === "invalid" ? "✖" : "·";

      return `<div class="row${c.working_copy ? " wc" : ""}" style="top:${i * rowH}px" data-hash="${c.hash}" title="${escape(c.message)}">

        <span class="id">${c.change_id.slice(0, 8)}</span>

        <span class="subject">${escape(subject)}</span>

        <span class="meta">${escape(c.author)} · ${timeAgo(c.when_ms)} <span class="sig" title="${escape(c.signature?.status ?? "")}">${sig}</span></span>

      </div>`;

    })

    .join("");

  return `<!DOCTYPE html>

<html><head><meta charset="utf-8">

<style>

  body { font-family: var(--vscode-font-family); color: var(--vscode-foreground); margin: 0; padding: 8px 12px; }

  h2 { font-size: 13px; font-weight: 600; margin: 0 0 8px; display: flex; gap: 12px; align-items: center; }

  h2 button { background: var(--vscode-button-secondaryBackground); color: var(--vscode-button-secondaryForeground); border: none; padding: 2px 8px; cursor: pointer; }

  .wrap { position: relative; }

  svg { position: absolute; left: 0; top: 0; }

  svg path { fill: none; stroke: var(--vscode-editorCodeLens-foreground); stroke-width: 1.5; }

  svg circle.node { fill: var(--vscode-editorCodeLens-foreground); }

  svg circle.head { fill: var(--vscode-charts-green); }

  svg circle.wc { fill: var(--vscode-charts-blue); stroke: var(--vscode-charts-blue); stroke-width: 2; fill-opacity: .3; }

  .rows { position: relative; margin-left: ${graphW}px; height: ${changes.length * rowH}px; }

  .row { position: absolute; left: 0; right: 0; height: ${rowH}px; line-height: ${rowH}px; display: flex; gap: 10px; cursor: pointer; white-space: nowrap; overflow: hidden; }

  .row:hover { background: var(--vscode-list-hoverBackground); }

  .row.wc { color: var(--vscode-descriptionForeground); font-style: italic; cursor: default; }

  .id { color: var(--vscode-charts-blue); font-family: var(--vscode-editor-font-family); }

  .subject { flex: 1; overflow: hidden; text-overflow: ellipsis; }

  .meta { color: var(--vscode-descriptionForeground); font-size: 12px; }

  .sig { margin-left: 4px; }

</style></head>

<body>

<h2>${escape(bookmark)} <span class="meta">${changes.length - 1} changes</span> <button id="refresh">Refresh</button></h2>

<div class="wrap">

  <svg width="${graphW}" height="${changes.length * rowH}">${edges.join("")}${nodes.join("")}</svg>

  <div class="rows">${rows}</div>

</div>

<script>

  const vscode = acquireVsCodeApi();

  document.querySelectorAll('.row:not(.wc)').forEach(r => r.addEventListener('click', () => vscode.postMessage({ type: 'open', hash: r.dataset.hash })));

  document.getElementById('refresh').addEventListener('click', () => vscode.postMessage({ type: 'refresh' }));

</script>

</body></html>`;

}

function escape(s: string): string {

  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");

}

export function repositoryLabel(repo: Repository): string {

  return repo.root.split("/").pop() ?? repo.root;

}

import { test } from "node:test";

import assert from "node:assert/strict";

import { alignLines } from "../out/diffutil.mjs";

test("alignLines maps unchanged lines through insertions and deletions", () => {

  const before = ["a", "b", "c", "d", "e"];

  const after = ["a", "x", "b", "d", "e", "f"];

  assert.deepEqual(alignLines(before, after), [0, -1, 1, 3, 4, -1]);

  assert.deepEqual(alignLines([], ["a"]), [-1]);

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

  assert.deepEqual(alignLines(["same", "same"], ["same", "same"]), [0, 1]);

  const moved = alignLines(["1", "2", "3", "4"], ["3", "4", "1", "2"]);

  assert.equal(moved.filter((i) => i >= 0).length, 2, "one block matches, the other reads as moved");

});

## 0.4.0 (2026-09-27)

Milestone 0.4: a history graph webview (heads, dependencies, signature marks) with per-change actions (diff, check out, describe, tag, abandon), File History with diffs between versions, and inline blame aligned to unsaved edits.

  "version": "0.4.0",

      { "command": "oxygen.sync", "title": "Sync", "category": "Oxygen", "icon": "$(sync)" },

      { "command": "oxygen.showHistory", "title": "Show History", "category": "Oxygen", "icon": "$(git-commit)" },

      { "command": "oxygen.fileHistory", "title": "File History…", "category": "Oxygen", "icon": "$(history)" },

      { "command": "oxygen.toggleBlame", "title": "Toggle Inline Blame", "category": "Oxygen" },

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

        { "command": "oxygen.showHistory", "group": "1_view@1", "when": "scmProvider == oxygen" },

        { "command": "oxygen.showLog", "group": "1_view@2", "when": "scmProvider == oxygen" },

        { "command": "oxygen.showOutput", "group": "1_view@3", "when": "scmProvider == oxygen" }

      ],

      "editor/title": [

        { "command": "oxygen.fileHistory", "group": "navigation@9", "when": "oxygen.hasRepository && resourceScheme == file" }

      "editor/context": [

        { "command": "oxygen.toggleBlame", "group": "oxygen@1", "when": "oxygen.hasRepository && resourceScheme == file" },

        { "command": "oxygen.fileHistory", "group": "oxygen@2", "when": "oxygen.hasRepository && resourceScheme == file" }

      ],

      "explorer/context": [

        { "command": "oxygen.fileHistory", "group": "7_modification@9", "when": "oxygen.hasRepository && !explorerResourceIsFolder" }

      ],

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

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

        "oxygen.inlineBlame": {

          "type": "boolean",

          "default": false,

          "description": "Show each line's introducing change, author and age at the end of the line."

        },

    "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",

import { OxyContentProvider, SCHEME, baseUri, oxyUri } from "./contentProvider";

import { OperationItem, OperationsProvider, timeAgo } from "./operations";

import { BlameController } from "./blame";

import { HistoryPanel } from "./history";

let blame: BlameController;

  blame = new BlameController(() => [...repositories.values()]);

  context.subscriptions.push(blame);

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

      const repo = repositoryFor(arg);

      if (repo) {

        HistoryPanel.show(repo, (hash) => void showChange(repo.root, hash));

      }

    }),

    vscode.commands.registerCommand("oxygen.fileHistory", (uri?: vscode.Uri) => fileHistory(uri ?? vscode.window.activeTextEditor?.document.uri)),

    vscode.commands.registerCommand("oxygen.toggleBlame", () => blame.toggle()),

    vscode.commands.registerCommand("oxygen.showChange", (root?: string, hash?: string) => root && hash && showChange(root, hash)),

        blame.invalidate(root);

        HistoryPanel.refresh(root);

// ---------------------------------------------------------------- history

async function showChange(root: string, hash: string): Promise<void> {

  const repo = repositories.get(root);

  if (!repo) {

    return;

  }

  let info;

  try {

    info = await repo.oxy.show(repo.root, `#${hash.slice(0, 12)}`);

  } catch (e) {

    showError(e);

    return;

  }

  const subject = info.message.split("\n")[0];

  type Item = vscode.QuickPickItem & { action: string; path?: string };

  const items: Item[] = [

    { label: "$(diff) Show diff", description: `${info.files.length} file${info.files.length === 1 ? "" : "s"}`, action: "diff" },

    { label: "$(arrow-right) Check out this state", description: "the change and its dependencies", action: "checkout" },

    { label: "$(edit) Describe…", description: "change the message", action: "describe" },

    { label: "$(tag) Tag…", action: "tag" },

    { label: "$(trash) Abandon", description: "drop the change; its content stays on disk if the working copy sat on it", action: "abandon" },

    { label: "$(copy) Copy ChangeId", action: "copy" },

    ...info.files.map((f) => ({ label: `$(file) ${f.path}`, description: `${f.kind}${f.from ? ` from ${f.from}` : ""}`, action: "file", path: f.path })),

  ];

  const pick = await vscode.window.showQuickPick(items, {

    title: `${info.change_id.slice(0, 8)}  ${subject}`,

    placeHolder: `${info.author} · ${timeAgo(info.when_ms)} · ${info.signature?.status ?? "unsigned"}${info.signature?.revoked ? " (key revoked)" : ""} · ${info.deps.length} dependenc${info.deps.length === 1 ? "y" : "ies"}`,

    matchOnDescription: true,

  });

  if (!pick) {

    return;

  }

  try {

    switch (pick.action) {

      case "diff":

      case "file": {

        const text = await repo.oxy.diffText(repo.root, `#${hash.slice(0, 12)}`);

        const body = `# ${info.change_id.slice(0, 8)} ${subject}\n# ${info.author} · ${new Date(info.when_ms).toLocaleString()}\n\n${text}`;

        const doc = await vscode.workspace.openTextDocument({ content: body, language: "diff" });

        await vscode.window.showTextDocument(doc, { preview: true });

        return;

      }

      case "checkout":

        await repo.oxy.checkout(repo.root, [`#${hash.slice(0, 12)}`]);

        break;

      case "describe": {

        const message = await vscode.window.showInputBox({ prompt: "New message", value: info.message });

        if (!message?.trim()) {

          return;

        }

        await repo.oxy.describe(repo.root, `#${hash.slice(0, 12)}`, message.trim());

        break;

      }

      case "tag": {

        const name = await vscode.window.showInputBox({ prompt: "Tag name" });

        if (!name?.trim()) {

          return;

        }

        await repo.oxy.tagCreate(repo.root, name.trim(), [`#${hash.slice(0, 12)}`]);

        break;

      }

      case "abandon": {

        const confirm = await vscode.window.showWarningMessage(`Abandon "${subject}"?`, { modal: true }, "Abandon");

        if (confirm !== "Abandon") {

          return;

        }

        const out = await repo.oxy.abandon(repo.root, `#${hash.slice(0, 12)}`);

        vscode.window.setStatusBarMessage(`$(trash) ${out.split("\n")[0]}`, 5000);

        break;

      }

      case "copy":

        await vscode.env.clipboard.writeText(info.change_id);

        return;

    }

    await repo.refresh();

  } catch (e) {

    if (e instanceof OxyError && e.message.includes("has changes")) {

      const confirm = await vscode.window.showWarningMessage("The working copy has uncommitted changes. Discard them and check out?", { modal: true }, "Discard and check out");

      if (confirm) {

        try {

          await repo.oxy.checkout(repo.root, [`#${hash.slice(0, 12)}`], true);

          await repo.refresh();

        } catch (e2) {

          showError(e2);

        }

      }

      return;

    }

    showError(e);

  }

}

async function fileHistory(uri: vscode.Uri | undefined): Promise<void> {

  if (!uri) {

    return;

  }

  const repo = [...repositories.values()].find((r) => r.relativePath(uri) !== undefined);

  const rel = repo?.relativePath(uri);

  if (!repo || !rel) {

    void vscode.window.showInformationMessage("Oxygen: this file is not in an Oxygen repository.");

    return;

  }

  try {

    const log = await repo.oxy.log(repo.root, 200, rel);

    const changes = log.changes.filter((c) => !c.working_copy);

    if (changes.length === 0) {

      void vscode.window.showInformationMessage(`Oxygen: no committed change touches ${rel}.`);

      return;

    }

    const pick = await vscode.window.showQuickPick(

      changes.map((c, i) => ({

        label: `${c.head ? "$(circle-filled)" : "$(circle-outline)"} ${c.message.split("\n")[0]}`,

        description: `${c.change_id.slice(0, 8)} · ${c.author} · ${timeAgo(c.when_ms)}`,

        change: c,

        previous: changes[i + 1],

      })),

      { placeHolder: `${changes.length} change${changes.length === 1 ? "" : "s"} touched ${rel}; pick one to compare with the version before it`, matchOnDescription: true },

    );

    if (!pick) {

      return;

    }

    const after = oxyUriFor(repo.root, rel, pick.change.hash);

    if (pick.previous) {

      const before = oxyUriFor(repo.root, rel, pick.previous.hash);

      await vscode.commands.executeCommand("vscode.diff", before, after, `${basename(rel)} (${pick.previous.change_id.slice(0, 8)} ↔ ${pick.change.change_id.slice(0, 8)})`);

    } else {

      await vscode.commands.executeCommand("vscode.open", after);

    }

  } catch (e) {

    showError(e);

  }

}

function oxyUriFor(root: string, rel: string, hash: string): vscode.Uri {

  return oxyUri(root, rel, `#${hash.slice(0, 12)}`);

}

  // ---------------------------------------------------------------- history and blame

  blame(root: string, path: string): Promise<BlameLine[]> {

    return this.json<BlameLine[]>(root, ["blame", path]);

  }

  show(root: string, change: string): Promise<ShowInfo> {

    return this.json<ShowInfo>(root, ["show", change]);

  }

  /** The rendered diff of a change (or the working copy), as `oxy diff` prints it. */

  diffText(root: string, change?: string): Promise<string> {

    return this.check(root, ["diff", ...(change ? [change] : [])]).then((r) => r.stdout.toString("utf8"));

  }

  describe(root: string, change: string, message: string): Promise<void> {

    return this.check(root, ["describe", change, "-m", message]).then(() => undefined);

  }

  abandon(root: string, change: string): Promise<string> {

    return this.check(root, ["abandon", change]).then((r) => r.stdout.toString("utf8").trim());

  }

  checkout(root: string, changes: string[], discard = false): Promise<void> {

    return this.check(root, ["checkout", ...changes, ...(discard ? ["--discard"] : [])]).then(() => undefined);

  }

  tagCreate(root: string, name: string, changes: string[] = [], message = ""): Promise<void> {

    return this.check(root, ["tag", "create", name, ...changes, "-m", message]).then(() => undefined);

  }

}

export interface BlameLine {

  line: number;

  change_id: string;

  hash: string;

  index: number;

  author: string;

  when_ms: number;

}

export interface ShowInfo extends LogEntry {

  files: { path: string; kind: string; from: string | null }[];

  // Blame, show, diff text, and file history.

  const blame = await oxy.blame(root, "a.txt");

  assert.deepEqual(blame.map((l) => l.line), [1, 2]);

  assert.notEqual(blame[0].hash, blame[1].hash, "two changes introduced the two lines");

  const show = await oxy.show(root, `#${blame[1].hash.slice(0, 12)}`);

  assert.equal(show.message, "feature work");

  assert.deepEqual(show.files.map((f) => f.path), ["a.txt"]);

  assert.match(await oxy.diffText(root, `#${blame[1].hash.slice(0, 12)}`), /\+feature/);

  const history = await oxy.log(root, 50, "a.txt");

  assert.equal(history.changes.filter((c) => !c.working_copy).length, 2);