Milestone 0.2: discard, commit selected paths, commit chosen hunks, amend, undo, Oxygen Operations view with undo to here 35d56b5803d9

// The operation log as a tree view (spec §5.9): newest first, with

// "Undo to here" on any entry, snapshots hidden unless configured.

import * as vscode from "vscode";

import { OperationInfo } from "./oxy";

import { Repository } from "./repository";

export class OperationItem extends vscode.TreeItem {

  constructor(

    readonly repository: Repository,

    readonly op: OperationInfo,

    readonly stepsBack: number,

  ) {

    super(op.command, vscode.TreeItemCollapsibleState.None);

    this.id = `${repository.root}:${op.id}`;

    this.description = timeAgo(op.when_ms);

    this.tooltip = `${op.command}\n${new Date(op.when_ms).toLocaleString()}\n${op.id.slice(0, 12)}`;

    this.iconPath = new vscode.ThemeIcon(op.current ? "circle-filled" : op.snapshot ? "circle-small" : "circle-outline");

    this.contextValue = op.current ? "current" : "operation";

  }

}

export class OperationsProvider implements vscode.TreeDataProvider<OperationItem | RepositoryItem> {

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

  readonly onDidChangeTreeData = this.emitter.event;

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

  refresh(): void {

    this.emitter.fire();

  }

  getTreeItem(element: OperationItem | RepositoryItem): vscode.TreeItem {

    return element;

  }

  async getChildren(element?: OperationItem | RepositoryItem): Promise<(OperationItem | RepositoryItem)[]> {

    const repos = this.repositories();

    if (!element) {

      if (repos.length === 1) {

        return this.operations(repos[0]);

      }

      return repos.map((r) => new RepositoryItem(r));

    }

    if (element instanceof RepositoryItem) {

      return this.operations(element.repository);

    }

    return [];

  }

  private async operations(repo: Repository): Promise<OperationItem[]> {

    const showSnapshots = vscode.workspace.getConfiguration("oxygen").get<boolean>("showSnapshotOperations", false);

    try {

      const ops = await repo.oxy.opLog(repo.root);

      const items: OperationItem[] = [];

      // Steps back count every operation, snapshots included, since undo

      // skips snapshots itself only when they are the newest entries.

      let steps = 0;

      for (const op of ops) {

        if (showSnapshots || !op.snapshot || op.current) {

          items.push(new OperationItem(repo, op, steps));

        }

        if (!op.snapshot) {

          steps += 1;

        }

      }

      return items.slice(0, 200);

    } catch {

      return [];

    }

  }

}

export class RepositoryItem extends vscode.TreeItem {

  constructor(readonly repository: Repository) {

    super(repository.root.split("/").pop() ?? repository.root, vscode.TreeItemCollapsibleState.Expanded);

    this.iconPath = new vscode.ThemeIcon("repo");

    this.contextValue = "repository";

  }

}

export function timeAgo(ms: number): string {

  const s = Math.max(0, Math.round((Date.now() - ms) / 1000));

  if (s < 45) return "just now";

  if (s < 90) return "a minute ago";

  if (s < 2700) return `${Math.round(s / 60)} minutes ago`;

  if (s < 5400) return "an hour ago";

  if (s < 79200) return `${Math.round(s / 3600)} hours ago`;

  if (s < 129600) return "yesterday";

  if (s < 2592000) return `${Math.round(s / 86400)} days ago`;

  return new Date(ms).toLocaleDateString();

}

## 0.2.0 (2026-09-27)

Milestone 0.2: discard changes (with confirmation), commit selected paths, commit chosen hunks, amend, undo the last operation, and an Oxygen Operations view with "Undo to here".

  "version": "0.2.0",

      { "command": "oxygen.init", "title": "Initialize Repository", "category": "Oxygen" },

      { "command": "oxygen.discard", "title": "Discard Changes", "category": "Oxygen", "icon": "$(discard)" },

      { "command": "oxygen.commitSelected", "title": "Commit Selected Paths", "category": "Oxygen" },

      { "command": "oxygen.commitHunks", "title": "Commit Hunks…", "category": "Oxygen" },

      { "command": "oxygen.amend", "title": "Amend", "category": "Oxygen" },

      { "command": "oxygen.undo", "title": "Undo Last Operation", "category": "Oxygen", "icon": "$(discard)" },

      { "command": "oxygen.undoTo", "title": "Undo to Here", "category": "Oxygen", "icon": "$(discard)" },

      { "command": "oxygen.refreshOperations", "title": "Refresh Operations", "category": "Oxygen", "icon": "$(refresh)" }

    "views": {

      "scm": [

        { "id": "oxygen.operations", "name": "Oxygen Operations", "when": "oxygen.hasRepository", "icon": "assets/images/oxygen.svg", "visibility": "collapsed" }

      ]

    },

        { "command": "oxygen.commitHunks", "group": "2_commit@1", "when": "scmProvider == oxygen" },

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

        { "command": "oxygen.undo", "group": "3_undo", "when": "scmProvider == oxygen" },

        { "command": "oxygen.openFile", "group": "inline@1", "when": "scmProvider == oxygen" },

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

        { "command": "oxygen.openBaseVersion", "group": "navigation", "when": "scmProvider == oxygen" },

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

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

      "view/title": [

        { "command": "oxygen.refreshOperations", "group": "navigation", "when": "view == oxygen.operations" }

      ],

      "view/item/context": [

        { "command": "oxygen.undoTo", "group": "inline", "when": "view == oxygen.operations && viewItem == operation" }

      ],

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

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

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

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

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

        "oxygen.showSnapshotOperations": {

          "type": "boolean",

          "default": false,

          "description": "List snapshot operations in the Oxygen Operations view."

        },

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

let operations: OperationsProvider;

  operations = new OperationsProvider(() => [...repositories.values()]);

  context.subscriptions.push(vscode.window.registerTreeDataProvider("oxygen.operations", operations));

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

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

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

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

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

    vscode.commands.registerCommand("oxygen.undoTo", (item?: OperationItem) => item && undo(item.repository, item.stepsBack)),

    vscode.commands.registerCommand("oxygen.refreshOperations", () => operations.refresh()),

        operations.refresh();

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

  if (states.length === 0) {

    return;

  }

  const repo = states[0].repository;

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

  const pick = await vscode.window.showWarningMessage(`Discard changes in ${names}? This cannot be undone with oxy undo.`, { modal: true }, "Discard");

  if (pick !== "Discard") {

    return;

  }

  try {

    await repo.oxy.discard(repo.root, states.map((s) => s.path));

    await repo.refresh();

  } catch (e) {

    showError(e);

  }

}

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

  if (states.length === 0) {

    return;

  }

  const repo = states[0].repository;

  const message = await askMessage(repo, `Commit ${states.length === 1 ? basename(states[0].path) : `${states.length} files`}`);

  if (!message) {

    return;

  }

  try {

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

    repo.sourceControl.inputBox.value = "";

    await repo.refresh();

  } catch (e) {

    showError(e);

  }

}

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

  const repo = repositoryFor(arg);

  if (!repo) {

    return;

  }

  let hunks;

  try {

    hunks = await repo.oxy.hunks(repo.root);

  } catch (e) {

    showError(e);

    return;

  }

  if (hunks.length === 0) {

    void vscode.window.showInformationMessage("Oxygen: nothing to commit.");

    return;

  }

  const picks = await vscode.window.showQuickPick(

    hunks.map((h) => ({

      label: `$(diff) ${h.path}`,

      description: `#${h.index}`,

      detail: h.text.split("\n").filter((l) => l.startsWith("+") || l.startsWith("-") || l.startsWith("A ") || l.startsWith("D ") || l.startsWith("R ")).slice(0, 3).join("  ").slice(0, 160),

      hunk: h,

      picked: false,

    })),

    { canPickMany: true, placeHolder: "Choose the hunks to commit; anything a chosen hunk needs comes along" },

  );

  if (!picks || picks.length === 0) {

    return;

  }

  const message = await askMessage(repo, `Commit ${picks.length} hunk${picks.length === 1 ? "" : "s"}`);

  if (!message) {

    return;

  }

  try {

    await repo.oxy.commitHunks(repo.root, message, picks.map((p) => p.hunk.index));

    repo.sourceControl.inputBox.value = "";

    await repo.refresh();

  } catch (e) {

    showError(e);

  }

}

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

  const repo = repositoryFor(arg);

  if (!repo) {

    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));

    repo.sourceControl.inputBox.value = "";

    await repo.refresh();

  } catch (e) {

    showError(e);

  }

}

async function undo(arg: Repository | vscode.SourceControl | undefined, steps: number): Promise<void> {

  const repo = repositoryFor(arg);

  if (!repo || steps <= 0) {

    return;

  }

  if (steps > 1) {

    const pick = await vscode.window.showWarningMessage(`Undo the last ${steps} operations?`, { modal: true }, "Undo");

    if (pick !== "Undo") {

      return;

    }

  }

  try {

    let last = "";

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

      last = await repo.oxy.undo(repo.root);

    }

    await repo.refresh();

    vscode.window.setStatusBarMessage(`$(discard) ${last || "Undone"}`, 4000);

  } catch (e) {

    showError(e);

  }

}

/** The commit message from the input box, else a prompt. */

async function askMessage(repo: Repository, prompt: string): Promise<string | undefined> {

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

  if (fromBox) {

    return fromBox;

  }

  return (await vscode.window.showInputBox({ prompt, placeHolder: "Commit message" }))?.trim() || undefined;

}

  /** Restore paths to the working copy's base. */

  discard(root: string, paths: string[]): Promise<void> {

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

  }

  discardHunks(root: string, hunks: number[]): Promise<void> {

    return this.check(root, ["discard", "--hunks", hunks.join(",")]).then(() => undefined);

  }

  hunks(root: string): Promise<HunkInfo[]> {

    return this.json<HunkInfo[]>(root, ["hunks"]);

  }

  commitHunks(root: string, message: string, hunks: number[]): Promise<void> {

    return this.check(root, ["commit", "-m", message, "--hunks", hunks.join(",")]).then(() => undefined);

  }

  amend(root: string, message?: string): Promise<void> {

    const args = ["amend"];

    if (message) {

      args.push("-m", message);

    }

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

  }

  undo(root: string): Promise<string> {

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

  }

  opLog(root: string): Promise<OperationInfo[]> {

    return this.json<OperationInfo[]>(root, ["op", "log"]);

  }

}

export interface HunkInfo {

  index: number;

  path: string;

  text: string;

}

export interface OperationInfo {

  id: string;

  when_ms: number;

  command: string;

  snapshot: boolean;

  current: boolean;

  // Write operations: hunks, commit by hunk, discard, amend, undo, op log.

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

  const hunks = await oxy.hunks(root);

  assert.ok(hunks.length >= 2, JSON.stringify(hunks));

  const bHunk = hunks.find((h) => h.path === "b.txt");

  await oxy.commitHunks(root, "b only", [bHunk.index]);

  status = await oxy.status(root);

  assert.deepEqual(status.paths.map((p) => p.path), ["a.txt"], "a.txt stays uncommitted");

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

  assert.equal((await oxy.status(root)).clean, true);

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

  await oxy.amend(root, "b, amended");

  assert.equal((await oxy.status(root)).clean, true);

  const log2 = await oxy.log(root, 10);

  assert.ok(log2.changes.some((c) => c.message === "b, amended"));

  const ops = await oxy.opLog(root);

  assert.ok(ops[0].current && ops.length > 3);

  assert.match(await oxy.undo(root), /Undone/);

  assert.equal((await oxy.status(root)).clean, false, "the amend is undone; its edit is back on disk as uncommitted work");