Commit box: amend mode, previous messages, signing indicator, and a warning before committing conflict markers; 0.9.0 44bfd5adfc9a

// The commit box's logic (spec §5.1), kept free of the vscode module so it

// can be tested: signing state from `oxy identity show`, the placeholder

// that shows it, message history, and conflict marker detection.

export interface SigningInfo {

  /** `Name <email>`, or empty without an identity. */

  who: string;

  /** Whether the secret key is in the key directory. */

  secret: boolean;

  /** `change`: every commit is signed; `seal`: changes are sealed at push. */

  mode: "change" | "seal";

}

/** Parse `oxy --plain identity show`; `null` when no identity is configured. */

export function parseIdentityShow(text: string): SigningInfo | null {

  const head = text.match(/^#\s*identity\s+(.+)$/m);

  if (!head) {

    return null;

  }

  const secretLine = text.match(/^\s*secret\s+(.+)$/m)?.[1] ?? "";

  const signingLine = text.match(/^\s*signing\s+(.+)$/m)?.[1] ?? "";

  return {

    who: head[1].trim(),

    secret: /available/.test(secretLine),

    mode: /core\.sign\s*=\s*change/.test(signingLine) ? "change" : "seal",

  };

}

/** A short name for the placeholder: the name without the address. */

function shortName(who: string): string {

  return who.replace(/\s*<[^>]*>\s*$/, "").trim() || who;

}

/** How the next commit will be authenticated, for the commit box. */

export function signingLabel(info: SigningInfo | null | undefined): string {

  if (info === undefined) {

    return "";

  }

  if (info === null) {

    return "⚠ unsigned: no identity (oxy identity create)";

  }

  if (!info.secret) {

    return `⚠ unsigned: the key for ${shortName(info.who)} is missing`;

  }

  return info.mode === "change" ? `✔ signed as ${shortName(info.who)}` : `◈ sealed at push as ${shortName(info.who)}`;

}

/** The commit box placeholder for the current mode. */

export function placeholder(opts: { amend: boolean; resolution: boolean; signing: string }): string {

  const what = opts.amend ? "Amend the last change: new message, or empty to keep it" : opts.resolution ? "Describe the resolution" : "Message";

  const key = opts.amend ? "Ctrl+Enter to amend" : "Ctrl+Enter to commit";

  return `${what} (${key})${opts.signing ? ` · ${opts.signing}` : ""}`;

}

/** Recent commit messages, newest first, without duplicates. */

export class MessageHistory {

  static readonly LIMIT = 30;

  private items: string[];

  constructor(items: readonly string[] = []) {

    this.items = items.filter((m) => m.trim()).slice(0, MessageHistory.LIMIT);

  }

  add(message: string): void {

    const m = message.trim();

    if (!m) {

      return;

    }

    this.items = [m, ...this.items.filter((x) => x !== m)].slice(0, MessageHistory.LIMIT);

  }

  get entries(): readonly string[] {

    return this.items;

  }

}

/**

 * Line numbers (1-based) that open or close a conflict: Oxygen's markers

 * (`<<<<<<< oxy conflict …`) and Git's alike, since both begin with seven

 * angle brackets.

 */

export function conflictMarkerLines(text: string): number[] {

  const out: number[] = [];

  text.split("\n").forEach((l, i) => {

    if (/^(<{7}|>{7})( |\r?$)/.test(l)) {

      out.push(i + 1);

    }

  });

  return out;

}

import { test } from "node:test";

import assert from "node:assert/strict";

import { MessageHistory, conflictMarkerLines, parseIdentityShow, placeholder, signingLabel } from "../out/commitbox.mjs";

const SIGNED = `# identity Andy McCall <[email protected]>

  key      f1add784

  created  2026-09-26 18:12:11Z (2 days ago)

  secret   * available

  signing  every change (core.sign = change)

`;

test("signing state from oxy identity show", () => {

  const s = parseIdentityShow(SIGNED);

  assert.deepEqual(s, { who: "Andy McCall <[email protected]>", secret: true, mode: "change" });

  assert.equal(signingLabel(s), "✔ signed as Andy McCall");

  const sealed = parseIdentityShow(SIGNED.replace("every change (core.sign = change)", "at push via seals (core.sign = seal)"));

  assert.equal(signingLabel(sealed), "◈ sealed at push as Andy McCall");

  const keyless = parseIdentityShow(SIGNED.replace("* available", "x not found in the key directory"));

  assert.match(signingLabel(keyless), /unsigned: the key for Andy McCall is missing/);

  assert.equal(parseIdentityShow("No identity configured; run `oxy identity create`."), null);

  assert.match(signingLabel(null), /unsigned: no identity/);

  assert.equal(signingLabel(undefined), "", "not known yet");

});

test("placeholder follows the mode", () => {

  assert.equal(placeholder({ amend: false, resolution: false, signing: "✔ signed as A" }), "Message (Ctrl+Enter to commit) · ✔ signed as A");

  assert.match(placeholder({ amend: true, resolution: false, signing: "" }), /^Amend the last change.*Ctrl\+Enter to amend\)$/);

  assert.match(placeholder({ amend: false, resolution: true, signing: "" }), /^Describe the resolution/);

});

test("message history is newest first, unique and bounded", () => {

  const h = new MessageHistory(["b", "", "a"]);

  h.add("  c  ");

  h.add("a");

  h.add("");

  assert.deepEqual(h.entries, ["a", "c", "b"]);

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

    h.add(`m${i}`);

  }

  assert.equal(h.entries.length, MessageHistory.LIMIT);

  assert.equal(h.entries[0], "m39");

});

test("conflict markers: Oxygen's and Git's, not look-alikes", () => {

  const oxy = ['a', '<<<<<<< oxy conflict 1 of 1, side 1 of 2: change k7m2p9 "x"', "one", '======= oxy conflict 1 of 1, side 2 of 2: change q3x8w1 "y"', "two", ">>>>>>> oxy conflict 1 of 1 end", ""].join("\n");

  assert.deepEqual(conflictMarkerLines(oxy), [2, 6]);

  assert.deepEqual(conflictMarkerLines("x\n<<<<<<< HEAD\ny\n=======\nz\n>>>>>>> feature\r\n"), [2, 6]);

  assert.deepEqual(conflictMarkerLines("<<<<<<<< eight\n  <<<<<<< indented\na <<<<<<< b\n"), []);

});

## 0.9.0

- **Amend mode** (the pencil in the Source Control title bar): Ctrl+Enter amends the last change, and the box starts from its message.

- **Previous Commit Messages…** puts a recent message back in the box. Messages are remembered per repository as you commit.

- **Signing indicator**: the box says whether the next commit will be signed, sealed at push, or unsigned (no identity, or its key missing).

- **Conflict marker warning**: committing or amending files that still hold conflict markers (Oxygen's or Git's) asks first, and can open the first one.

- **Commit box**: amend mode, previous messages, a note of whether the next

  commit is signed, sealed at push or unsigned, and a warning before

  committing leftover conflict markers.

  "version": "0.9.0",

      },

      {

        "command": "oxygen.amendMode",

        "title": "Amend Mode",

        "category": "Oxygen",

        "icon": "$(edit)"

      },

      {

        "command": "oxygen.leaveAmendMode",

        "title": "Leave Amend Mode",

        "category": "Oxygen",

        "icon": "$(close)"

      },

      {

        "command": "oxygen.messageHistory",

        "title": "Previous Commit Messages\u2026",

        "category": "Oxygen",

        "icon": "$(history)"

        },

        {

          "command": "oxygen.amendMode",

          "group": "navigation@4",

          "when": "scmProvider == oxygen && !oxygen.amending"

        },

        {

          "command": "oxygen.leaveAmendMode",

          "group": "navigation@4",

          "when": "scmProvider == oxygen && oxygen.amending"

        },

        {

          "command": "oxygen.messageHistory",

          "group": "2_commit@4",

          "when": "scmProvider == oxygen"

    "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 && esbuild src/api.ts --bundle --platform=node --format=esm --outfile=out/api.mjs && esbuild src/commitbox.ts --bundle --platform=node --format=esm --outfile=out/commitbox.mjs",

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

import { MessageHistory, conflictMarkerLines, placeholder, signingLabel } from "./commitbox";

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

  extensionContext = context;

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

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

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

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

        void refreshSigning(repo);

        updateBox(repo);

    return;

  }

  if (box(repo).amend) {

    await amend(repo);

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

    return;

  }

    remember(repo, message);

    return;

  }

  if (!(await markersOk(repo, states.map((s) => s.path)))) {

    remember(repo, message);

    remember(repo, message);

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

    return;

  }

    remember(repo, message);

    setAmend(repo, false);

}

// ------------------------------------------------------ commit box (V7)

interface BoxState {

  amend: boolean;

  resolution: boolean;

  signing: string;

  checkedMs: number;

}

const boxes = new Map<string, BoxState>();

let extensionContext: vscode.ExtensionContext | undefined;

function box(repo: Repository): BoxState {

  let b = boxes.get(repo.root);

  if (!b) {

    b = { amend: false, resolution: false, signing: "", checkedMs: 0 };

    boxes.set(repo.root, b);

  }

  return b;

}

/** Placeholder and the Ctrl+Enter action follow amend mode, resolution and signing. */

function updateBox(repo: Repository): void {

  const b = box(repo);

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

  repo.sourceControl.inputBox.placeholder = placeholder(b);

}

/** Re-read how commits will be signed, at most every 30 seconds. */

async function refreshSigning(repo: Repository, force = false): Promise<void> {

  const b = box(repo);

  if (!force && Date.now() - b.checkedMs < 30_000) {

    return;

  }

  b.checkedMs = Date.now();

  try {

    b.signing = signingLabel(await repo.oxy.identity(repo.root));

  } catch {

    b.signing = "";

  }

  updateBox(repo);

}

function setAmend(repo: Repository, on: boolean): void {

  box(repo).amend = on;

  void vscode.commands.executeCommand("setContext", "oxygen.amending", [...boxes.values()].some((b) => b.amend));

  updateBox(repo);

}

async function toggleAmend(arg: Repository | vscode.SourceControl | undefined, on: boolean): Promise<void> {

  const repo = repositoryFor(arg);

  if (!repo) {

    return;

  }

  setAmend(repo, on);

  if (on && !repo.sourceControl.inputBox.value.trim()) {

    // Start from the message being amended.

    try {

      const last = (await repo.oxy.log(repo.root, 2)).changes.find((c) => !c.working_copy);

      if (last) {

        repo.sourceControl.inputBox.value = last.message;

      }

    } catch {

      // An empty box keeps the message anyway.

    }

  }

}

function historyOf(repo: Repository): MessageHistory {

  return new MessageHistory(extensionContext?.workspaceState.get<string[]>(`oxygen.messages:${repo.root}`) ?? []);

}

function remember(repo: Repository, message: string): void {

  const h = historyOf(repo);

  h.add(message);

  void extensionContext?.workspaceState.update(`oxygen.messages:${repo.root}`, h.entries);

}

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

  const repo = repositoryFor(arg);

  if (!repo) {

    return;

  }

  const entries = historyOf(repo).entries;

  if (entries.length === 0) {

    void vscode.window.showInformationMessage("Oxygen: no messages yet; they are remembered as you commit.");

    return;

  }

  const pick = await vscode.window.showQuickPick(

    entries.map((m) => ({ label: m.split("\n")[0], detail: m.includes("\n") ? m.split("\n").slice(1).join(" ").trim().slice(0, 160) : undefined, message: m })),

    { title: "Previous commit messages", placeHolder: "Put one back in the commit box", matchOnDetail: true },

  );

  if (pick) {

    repo.sourceControl.inputBox.value = pick.message;

  }

}

/**

 * Warn before committing files that still hold conflict markers: those oxy

 * reports (markers left in a conflicted file) and any text file whose lines

 * open or close a conflict. `paths` limits the check to what is committed.

 */

async function markersOk(repo: Repository, paths?: string[]): Promise<boolean> {

  const status = repo.status;

  if (!status) {

    return true;

  }

  const found: { path: string; line?: number }[] = [];

  for (const p of status.paths) {

    if (p.status === "Removed" || (paths && !paths.includes(p.path))) {

      continue;

    }

    if (p.status === "ConflictEdited") {

      found.push({ path: p.path });

      continue;

    }

    try {

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

      if ((await stat(file)).size > 4 * 1024 * 1024) {

        continue;

      }

      const text = (await readFile(file)).toString("utf8");

      const lines = conflictMarkerLines(text);

      if (lines.length > 0) {

        found.push({ path: p.path, line: lines[0] });

      }

    } catch {

      // Unreadable or gone: nothing to check.

    }

  }

  if (found.length === 0) {

    return true;

  }

  const list = found.slice(0, 5).map((f) => (f.line ? `${f.path} (line ${f.line})` : f.path)).join(", ") + (found.length > 5 ? ` and ${found.length - 5} more` : "");

  const pick = await vscode.window.showWarningMessage(

    `Conflict markers remain in ${list}. Commit anyway?`,

    { modal: true, detail: "Committing records the marker lines as ordinary text." },

    "Commit anyway",

    `Open ${basename(found[0].path)}`,

  );

  if (pick?.startsWith("Open ")) {

    const doc = await vscode.workspace.openTextDocument(vscode.Uri.file(join(repo.root, found[0].path)));

    const line = Math.max(0, (found[0].line ?? 1) - 1);

    await vscode.window.showTextDocument(doc, { selection: new vscode.Range(line, 0, line, 0) });

    return false;

  }

  return pick === "Commit anyway";

import { SigningInfo, parseIdentityShow } from "./commitbox";

  }

  /** The configured identity and how commits are signed; `null` without one. */

  identity(root: string): Promise<SigningInfo | null> {

    return this.check(root, ["identity", "show"]).then((r) => parseIdentityShow(r.stdout.toString("utf8")));

test("identity reports how commits are signed", async () => {

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

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

  mkdirSync(home);

  process.env.OXY_HOME = home;

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

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

  assert.equal(await oxy.identity(root), null, "none yet");

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

  const id = await oxy.identity(root);

  assert.equal(id?.who, "Test <[email protected]>");

  assert.equal(id?.secret, true);

  assert.ok(id?.mode === "change" || id?.mode === "seal");

});