Apply swimlane plans from OxygenHub (0.12.0) 196392053c9f

## 0.12.0 (2026-09-29)

- **Plans from the swimlanes:** on a proposal's swimlane board in OxygenHub, drag one change onto another to plan a squash or a rebase. **Apply in VS Code** opens `vscode://oxygen.oxygen-vscode/plan?url=…&bookmark=…&kind=…&change=…&target=…`.

  - The extension finds the checkout of that repository, or offers to clone it.

  - It confirms the plan, switches to the proposal's bookmark and pulls it, then squashes or rebases. The rewritten changes are signed with your key.

  - It then offers to push the bookmark, replacing it on the hub.

  - Links with a bad URL, bookmark, kind or change hash are refused.

### Squash or rebase from a proposal's swimlanes

On a proposal's swimlane board in OxygenHub, drag a change onto another to plan a squash (into it) or a rebase (onto it). **Apply in VS Code** opens this extension. It confirms the plan, switches to the proposal's bookmark, pulls it, and rewrites the changes here, where they are signed with your key. It then offers to push the bookmark.

  "version": "0.12.0",

import { parsePlanQuery, parseResolveQuery, sameRemote } from "./handoff";

  if (uri.path === "/plan") {

    return applyPlan(uri);

  }

  } catch (e) {

    showError(e);

  }

}

/** The open checkout whose remote is `url`, with that remote's name. */

async function checkoutOf(url: string): Promise<{ repo: Repository; remote: string } | undefined> {

  for (const repo of repositories.values()) {

    const remotes = await repo.oxy.remotes(repo.root).catch(() => []);

    const r = remotes.find((x) => sameRemote(x.url, url));

    if (r) {

      return { repo, remote: r.name };

    }

  }

  return undefined;

}

/**

 * vscode://oxygen.oxygen-vscode/plan?… from OxygenHub's swimlanes: squash

 * or rebase a change of a proposal's bookmark here, where it is signed as

 * you, then push the rewritten bookmark.

 */

async function applyPlan(uri: vscode.Uri): Promise<void> {

  const plan = parsePlanQuery(uri.query);

  if (typeof plan === "string") {

    vscode.window.showErrorMessage(`Oxygen: cannot apply this plan: ${plan}.`);

    return;

  }

  const found = await checkoutOf(plan.url);

  if (!found) {

    const pick = await vscode.window.showInformationMessage(`Oxygen: no open folder is a checkout of ${plan.url}. Clone it, open it, then follow the link again.`, "Clone…");

    if (pick) {

      await cloneRepository(plan.url);

    }

    return;

  }

  const { repo, remote } = found;

  const [c, t] = [plan.change.slice(0, 12), plan.target.slice(0, 12)];

  const what = plan.kind === "squash" ? `Squash #${c} into #${t}` : `Rebase #${c} onto #${t}`;

  const ok = await vscode.window.showInformationMessage(`Oxygen: ${what} on ${plan.bookmark}? The rewritten changes are signed as you.`, { modal: true }, "Apply");

  if (!ok) {

    return;

  }

  try {

    if (repo.currentBookmark?.name !== plan.bookmark) {

      await repo.oxy.bookmarkSwitch(repo.root, plan.bookmark);

    }

    await repo.oxy.pull(repo.root, remote);

    await vscode.window.withProgress({ location: vscode.ProgressLocation.SourceControl, title: what }, () =>

      plan.kind === "squash"

        ? repo.oxy.squash(repo.root, `#${plan.change}`, `#${plan.target}`)

        : repo.oxy.rebase(repo.root, `#${plan.change}`, [`#${plan.target}`]),

    );

    await repo.refresh();

    const push = await vscode.window.showInformationMessage(`Oxygen: ${what} done. Push ${plan.bookmark}? Its history changed, so this replaces it on ${remote}.`, "Push");

    if (push) {

      await vscode.window.withProgress({ location: vscode.ProgressLocation.Notification, title: `Oxygen: pushing ${plan.bookmark}` }, () =>

        repo.oxy.push(repo.root, remote, plan.bookmark, true),

      );

    }

export interface PlanRequest {

  url: string;

  bookmark: string;

  /** `squash` (change into target) or `rebase` (change onto target). */

  kind: "squash" | "rebase";

  change: string;

  target: string;

}

/**

 * A rewrite planned on OxygenHub's swimlanes:

 * vscode://oxygen.oxygen-vscode/plan?url=…&bookmark=…&kind=…&change=…&target=…

 */

export function parsePlanQuery(query: string): PlanRequest | string {

  const q = new URLSearchParams(query);

  const base = parseResolveQuery(new URLSearchParams({ url: q.get("url") ?? "", bookmark: q.get("bookmark") ?? "", path: "x" }).toString());

  if (typeof base === "string") {

    return base;

  }

  const kind = q.get("kind");

  if (kind !== "squash" && kind !== "rebase") {

    return "the link names no squash or rebase";

  }

  const hex = /^[0-9a-f]{64}$/;

  const change = q.get("change") ?? "";

  const target = q.get("target") ?? "";

  if (!hex.test(change) || !hex.test(target) || change === target) {

    return "the link names no two changes";

  }

  return { url: base.url, bookmark: base.bookmark, kind, change, target };

}

import { parsePlanQuery, parseResolveQuery, sameRemote } from "../out/handoff.mjs";

});

test("plan links are read and checked", () => {

  const c = "a".repeat(64), t = "b".repeat(64);

  const q = new URLSearchParams({ url: "https://hub.example:7343/andy/demo", bookmark: "feature", kind: "squash", change: c, target: t }).toString();

  assert.deepEqual(parsePlanQuery(q), { url: "https://hub.example:7343/andy/demo", bookmark: "feature", kind: "squash", change: c, target: t });

  assert.match(parsePlanQuery(q.replace("squash", "reorder")), /no squash or rebase/);

  assert.match(parsePlanQuery(q.replace(t, c)), /no two changes/);

  assert.match(parsePlanQuery(q.replace(c, "abc")), /no two changes/);

  assert.match(parsePlanQuery(q.replace("feature", "a..b")), /no valid bookmark/);