Milestone 0.6: Subrepos group, Bisect and Trust views, verify, tags, add workspace, clone d2c9a5843004

// The Bisect and Trust views (spec §5.11, §5.12): small trees fed by

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

import * as vscode from "vscode";

import { BisectStatus, PolicyInfo, VerifyInfo } from "./oxy";

import { Repository } from "./repository";

class Line extends vscode.TreeItem {

  constructor(label: string, opts: { description?: string; icon?: string; command?: vscode.Command; tooltip?: string; context?: string } = {}) {

    super(label, vscode.TreeItemCollapsibleState.None);

    this.description = opts.description;

    this.tooltip = opts.tooltip;

    this.command = opts.command;

    this.contextValue = opts.context;

    if (opts.icon) {

      this.iconPath = new vscode.ThemeIcon(opts.icon);

    }

  }

}

abstract class RepoTree implements vscode.TreeDataProvider<vscode.TreeItem> {

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

  readonly onDidChangeTreeData = this.emitter.event;

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

  refresh(): void {

    this.emitter.fire();

  }

  getTreeItem(element: vscode.TreeItem): vscode.TreeItem {

    return element;

  }

  async getChildren(element?: vscode.TreeItem): Promise<vscode.TreeItem[]> {

    const repos = this.repositories();

    if (!element) {

      if (repos.length === 1) {

        return this.items(repos[0]);

      }

      return repos.map((r) => {

        const item = new vscode.TreeItem(r.root.split("/").pop() ?? r.root, vscode.TreeItemCollapsibleState.Expanded);

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

        (item as vscode.TreeItem & { repository?: Repository }).repository = r;

        return item;

      });

    }

    const repo = (element as vscode.TreeItem & { repository?: Repository }).repository;

    return repo ? this.items(repo) : [];

  }

  protected abstract items(repo: Repository): Promise<vscode.TreeItem[]>;

}

export class BisectProvider extends RepoTree {

  protected async items(repo: Repository): Promise<vscode.TreeItem[]> {

    let status: BisectStatus | null;

    try {

      status = await repo.oxy.bisectStatus(repo.root);

    } catch (e) {

      return [new Line(String(e), { icon: "warning" })];

    }

    const cmd = (title: string, command: string, args: unknown[] = []): vscode.Command => ({ title, command, arguments: [repo, ...args] });

    if (!status) {

      return [new Line("No bisect in progress", { icon: "search", description: "start one to find a regression", command: cmd("Start", "oxygen.bisectStart") })];

    }

    switch (status.state) {

      case "need-marks":

        return [

          new Line(`Marked ${status.good} good, ${status.bad} bad`, { icon: "search" }),

          new Line(status.good === 0 ? "Mark a known-good change or bookmark…" : "Mark a known-bad change or bookmark…", { icon: status.good === 0 ? "pass" : "error", command: cmd("Mark", status.good === 0 ? "oxygen.bisectGood" : "oxygen.bisectBad") }),

          new Line("Reset", { icon: "discard", command: cmd("Reset", "oxygen.bisectReset") }),

        ];

      case "testing":

        return [

          new Line(`Testing: ${status.remaining} candidates left`, { icon: "beaker", description: `about ${status.steps_left} more steps` }),

          new Line("This state is good", { icon: "pass", command: cmd("Good", "oxygen.bisectGood", [[]]) }),

          new Line("This state is bad", { icon: "error", command: cmd("Bad", "oxygen.bisectBad", [[]]) }),

          new Line("Skip: cannot test this state", { icon: "debug-step-over", command: cmd("Skip", "oxygen.bisectSkip") }),

          new Line("Run a command for every step…", { icon: "run-all", command: cmd("Run", "oxygen.bisectRun") }),

          new Line("Reset", { icon: "discard", command: cmd("Reset", "oxygen.bisectReset") }),

        ];

      case "found":

        return [

          new Line(`Found: ${status.culprit.slice(0, 12)}`, { icon: "bug", description: "the first change that makes the state bad", command: { title: "Show", command: "oxygen.showChange", arguments: [repo.root, status.culprit] } }),

          new Line("Reset: back to where you were", { icon: "discard", command: cmd("Reset", "oxygen.bisectReset") }),

        ];

      case "inconclusive":

        return [

          new Line(`Inconclusive: ${status.candidates.length} candidates could not be told apart`, { icon: "question" }),

          ...status.candidates.map((c) => new Line(c.slice(0, 12), { icon: "circle-outline", command: { title: "Show", command: "oxygen.showChange", arguments: [repo.root, c] } })),

          new Line("Reset", { icon: "discard", command: cmd("Reset", "oxygen.bisectReset") }),

        ];

    }

  }

}

export class TrustProvider extends RepoTree {

  protected async items(repo: Repository): Promise<vscode.TreeItem[]> {

    let policy: PolicyInfo | null;

    let verify: VerifyInfo[];

    try {

      [policy, verify] = await Promise.all([repo.oxy.policyShow(repo.root), repo.oxy.verify(repo.root)]);

    } catch (e) {

      return [new Line(String(e), { icon: "warning" })];

    }

    const items: vscode.TreeItem[] = [];

    if (!policy) {

      items.push(new Line("No trust policy: this repository is unverified", { icon: "unlock", description: "oxy policy init creates one", tooltip: "Without a policy every change and reference update is accepted." }));

    } else {

      const expires = new Date(policy.expires_ms).toLocaleDateString();

      items.push(new Line(`Policy serial ${policy.serial}`, { icon: policy.expired ? "error" : "shield", description: policy.expired ? `EXPIRED ${expires}` : `expires ${expires}` }));

      for (const r of policy.roots) {

        items.push(new Line(`Root: ${r.name || r.key.slice(0, 12)}`, { icon: "key", description: r.email, tooltip: r.key }));

      }

      items.push(new Line(`Root threshold ${policy.root_threshold}`, { icon: "law" }));

      for (const rule of policy.rules) {

        items.push(new Line(`Rule ${rule.pattern}`, { icon: "list-tree", description: `${rule.keys.map((k) => k.name || k.key.slice(0, 8)).join(", ")} · threshold ${rule.threshold} · ${rule.require}${rule.allow_conflicts ? "" : " · no conflicts"}` }));

      }

      for (const r of policy.revoked) {

        items.push(new Line(`Revoked: ${r.name || r.key.slice(0, 12)}`, { icon: "circle-slash" }));

      }

    }

    const counts = { signed: 0, sealed: 0, unsigned: 0, invalid: 0, revoked: 0 };

    for (const v of verify) {

      if (v.status in counts) {

        counts[v.status as keyof typeof counts] += 1;

      }

      if (v.revoked) {

        counts.revoked += 1;

      }

    }

    items.push(

      new Line(`${verify.length} changes verified`, {

        icon: counts.invalid > 0 ? "error" : "verified",

        description: `${counts.signed} signed, ${counts.sealed} sealed, ${counts.unsigned} unsigned${counts.invalid ? `, ${counts.invalid} INVALID` : ""}${counts.revoked ? `, ${counts.revoked} by revoked keys` : ""}`,

        command: { title: "Verify", command: "oxygen.verify", arguments: [repo] },

      }),

    );

    return items;

  }

}

## 0.6.0 (2026-09-27)

Milestone 0.6: a Subrepos group with update and open, Oxygen Bisect and Oxygen Trust views, Verify Signatures, tag picker and Create Tag, Add Workspace, and Clone Repository.

  "version": "0.6.0",

      { "command": "oxygen.openConflict", "title": "Open Conflict", "category": "Oxygen" },

      { "command": "oxygen.openSubrepo", "title": "Open Subrepo", "category": "Oxygen" },

      { "command": "oxygen.updateSubrepo", "title": "Update to Pin", "category": "Oxygen", "icon": "$(cloud-download)" },

      { "command": "oxygen.updateSubrepos", "title": "Update Subrepos", "category": "Oxygen" },

      { "command": "oxygen.bisectStart", "title": "Bisect: Start", "category": "Oxygen" },

      { "command": "oxygen.bisectGood", "title": "Bisect: Good", "category": "Oxygen" },

      { "command": "oxygen.bisectBad", "title": "Bisect: Bad", "category": "Oxygen" },

      { "command": "oxygen.bisectSkip", "title": "Bisect: Skip", "category": "Oxygen" },

      { "command": "oxygen.bisectRun", "title": "Bisect: Run…", "category": "Oxygen" },

      { "command": "oxygen.bisectReset", "title": "Bisect: Reset", "category": "Oxygen" },

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

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

      { "command": "oxygen.verify", "title": "Verify Signatures", "category": "Oxygen" },

      { "command": "oxygen.tags", "title": "Tags…", "category": "Oxygen" },

      { "command": "oxygen.createTag", "title": "Create Tag…", "category": "Oxygen" },

      { "command": "oxygen.addWorkspace", "title": "Add Workspace…", "category": "Oxygen" },

      { "command": "oxygen.clone", "title": "Clone Repository…", "category": "Oxygen" }

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

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

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

        { "command": "oxygen.tags", "group": "6_more@1", "when": "scmProvider == oxygen" },

        { "command": "oxygen.createTag", "group": "6_more@2", "when": "scmProvider == oxygen" },

        { "command": "oxygen.addWorkspace", "group": "6_more@3", "when": "scmProvider == oxygen" },

        { "command": "oxygen.updateSubrepos", "group": "6_more@4", "when": "scmProvider == oxygen" },

        { "command": "oxygen.verify", "group": "6_more@5", "when": "scmProvider == oxygen" },

        { "command": "oxygen.updateSubrepo", "group": "inline@0", "when": "scmProvider == oxygen && scmResourceState == subrepo" },

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

        { "command": "oxygen.refreshBisect", "group": "navigation", "when": "view == oxygen.bisect" },

        { "command": "oxygen.refreshTrust", "group": "navigation", "when": "view == oxygen.trust" }

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

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

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

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

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

import { Repository, OxyResourceState, SubrepoState } from "./repository";

import { BisectProvider, TrustProvider } from "./panels";

let bisectView: BisectProvider;

let trustView: TrustProvider;

  bisectView = new BisectProvider(() => [...repositories.values()]);

  trustView = new TrustProvider(() => [...repositories.values()]);

  context.subscriptions.push(vscode.window.registerTreeDataProvider("oxygen.bisect", bisectView), vscode.window.registerTreeDataProvider("oxygen.trust", trustView));

    vscode.commands.registerCommand("oxygen.openSubrepo", (state?: SubrepoState) => state && openSubrepo(state)),

    vscode.commands.registerCommand("oxygen.updateSubrepo", (state?: SubrepoState) => state && updateSubrepos(state.repository, true, [state.info.path])),

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

      const repo = repositoryFor(arg);

      return repo && updateSubrepos(repo, true, []);

    }),

    vscode.commands.registerCommand("oxygen.bisectStart", (arg?: Repository) => bisect(arg, (r) => r.oxy.bisectStart(r.root).then(() => "Started; mark a good and a bad change"))),

    vscode.commands.registerCommand("oxygen.bisectGood", (arg?: Repository, changes?: string[]) => bisectMark(arg, "good", changes)),

    vscode.commands.registerCommand("oxygen.bisectBad", (arg?: Repository, changes?: string[]) => bisectMark(arg, "bad", changes)),

    vscode.commands.registerCommand("oxygen.bisectSkip", (arg?: Repository) => bisect(arg, (r) => r.oxy.bisectMark(r.root, "skip"))),

    vscode.commands.registerCommand("oxygen.bisectRun", (arg?: Repository) => bisectRun(arg)),

    vscode.commands.registerCommand("oxygen.bisectReset", (arg?: Repository) => bisect(arg, (r) => r.oxy.bisectReset(r.root).then(() => "Bisect reset; working copy restored"))),

    vscode.commands.registerCommand("oxygen.refreshBisect", () => bisectView.refresh()),

    vscode.commands.registerCommand("oxygen.refreshTrust", () => trustView.refresh()),

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

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

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

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

    vscode.commands.registerCommand("oxygen.clone", () => cloneRepository()),

        bisectView.refresh();

        trustView.refresh();

// ---------------------------------------------------------------- subrepos, bisect, trust, tags, workspaces, clone

async function openSubrepo(state: SubrepoState): Promise<void> {

  if (!state.info.actual) {

    const pick = await vscode.window.showInformationMessage(`${state.info.path} is not checked out yet.`, "Update --init");

    if (pick) {

      await updateSubrepos(state.repository, true, [state.info.path]);

    }

    return;

  }

  const pick = await vscode.window.showQuickPick(

    [

      { label: "$(folder-opened) Open in new window", action: "window" },

      { label: "$(cloud-download) Update to the pin", action: "update", description: state.info.at_pin ? "already at pin" : "moves the nested repository" },

    ],

    { placeHolder: `${state.info.path} · ${state.decorations.tooltip}` },

  );

  if (pick?.action === "window") {

    await vscode.commands.executeCommand("vscode.openFolder", state.resourceUri, { forceNewWindow: true });

  } else if (pick?.action === "update") {

    await updateSubrepos(state.repository, true, [state.info.path]);

  }

}

async function updateSubrepos(repo: Repository, init: boolean, paths: string[]): Promise<void> {

  try {

    const out = await vscode.window.withProgress({ location: vscode.ProgressLocation.SourceControl, title: "Updating subrepos" }, () => repo.oxy.submoduleUpdate(repo.root, init, paths));

    await repo.refresh();

    const lines = out.trim().split("\n").filter(Boolean);

    if (lines.some((l) => /missing|uncommitted|✖|x /.test(l))) {

      void vscode.window.showWarningMessage(`Oxygen: ${lines.join("; ")}`);

    } else {

      vscode.window.setStatusBarMessage(`$(check) ${lines.join("; ") || "Subrepos up to date"}`, 5000);

    }

  } catch (e) {

    showError(e);

  }

}

async function bisect(arg: Repository | undefined, run: (repo: Repository) => Promise<string>): Promise<void> {

  const repo = arg instanceof Repository ? arg : repositoryFor(undefined);

  if (!repo) {

    return;

  }

  try {

    const out = await run(repo);

    await repo.refresh();

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

  } catch (e) {

    showError(e);

  }

}

async function bisectMark(arg: Repository | undefined, verdict: "good" | "bad", changes?: string[]): Promise<void> {

  const repo = arg instanceof Repository ? arg : repositoryFor(undefined);

  if (!repo) {

    return;

  }

  let picked = changes;

  if (picked === undefined) {

    const status = await repo.oxy.bisectStatus(repo.root).catch(() => null);

    if (!status || status.state === "need-marks") {

      const value = await vscode.window.showInputBox({ prompt: `A change, bookmark or tag known to be ${verdict}`, placeHolder: verdict === "good" ? "v1.2 or a ChangeId prefix" : "main" });

      if (!value?.trim()) {

        return;

      }

      picked = value.trim().split(/\s+/);

    } else {

      picked = [];

    }

  }

  await bisect(repo, (r) => r.oxy.bisectMark(r.root, verdict, picked));

}

async function bisectRun(arg: Repository | undefined): Promise<void> {

  const repo = arg instanceof Repository ? arg : repositoryFor(undefined);

  if (!repo) {

    return;

  }

  const value = await vscode.window.showInputBox({ prompt: "Command to run for each step (exit 0 good, 125 skip, anything else bad)", placeHolder: "make test" });

  if (!value?.trim()) {

    return;

  }

  await bisect(repo, (r) => Promise.resolve(vscode.window.withProgress({ location: vscode.ProgressLocation.Notification, title: "Oxygen: bisecting", cancellable: false }, () => r.oxy.bisectRun(r.root, ["sh", "-c", value.trim()]))));

}

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

  const repo = repositoryFor(arg);

  if (!repo) {

    return;

  }

  try {

    const results = await repo.oxy.verify(repo.root);

    const icon = (s: string, revoked: boolean) => (s === "invalid" ? "$(error)" : s === "unsigned" ? "$(circle-outline)" : revoked ? "$(warning)" : "$(verified)");

    const pick = await vscode.window.showQuickPick(

      results.map((r) => ({

        label: `${icon(r.status, r.revoked)} ${r.change_id.slice(0, 8)} ${r.status}${r.revoked ? " (key revoked)" : ""}`,

        description: r.name ?? "",

        detail: r.reason ?? undefined,

        hash: r.hash,

      })),

      { placeHolder: `${results.length} changes; ${results.filter((r) => r.status === "invalid").length} invalid`, matchOnDescription: true },

    );

    if (pick) {

      await showChange(repo.root, pick.hash);

    }

  } catch (e) {

    showError(e);

  }

}

async function tags(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) {

      const pick = await vscode.window.showInformationMessage("Oxygen: no tags yet.", "Create tag");

      if (pick) {

        await createTag(repo);

      }

      return;

    }

    const pick = await vscode.window.showQuickPick(

      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 })),

      { placeHolder: "Check out a tag's state" },

    );

    if (!pick) {

      return;

    }

    await repo.oxy.checkout(repo.root, [pick.tag.name]);

    await repo.refresh();

  } catch (e) {

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

      void vscode.window.showWarningMessage("Oxygen: commit or discard your changes before checking out a tag.");

      return;

    }

    showError(e);

  }

}

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

  const repo = repositoryFor(arg);

  if (!repo) {

    return;

  }

  const name = await vscode.window.showInputBox({ prompt: "Tag name (tags the current bookmark's heads)" });

  if (!name?.trim()) {

    return;

  }

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

  try {

    await repo.oxy.tagCreate(repo.root, name.trim(), [], message);

    await repo.refresh();

    vscode.window.setStatusBarMessage(`$(tag) Tagged ${name.trim()}`, 4000);

  } catch (e) {

    showError(e);

  }

}

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

  const repo = repositoryFor(arg);

  if (!repo) {

    return;

  }

  const folders = await vscode.window.showOpenDialog({ canSelectFiles: false, canSelectFolders: true, canSelectMany: false, openLabel: "Create workspace here", title: "Folder for the new workspace (must be empty or absent)" });

  if (!folders?.[0]) {

    return;

  }

  try {

    await repo.oxy.workspaceAdd(repo.root, folders[0].fsPath);

    const pick = await vscode.window.showInformationMessage(`Oxygen: workspace created at ${folders[0].fsPath}.`, "Open in new window");

    if (pick) {

      await vscode.commands.executeCommand("vscode.openFolder", folders[0], { forceNewWindow: true });

    }

  } catch (e) {

    showError(e);

  }

}

async function cloneRepository(): Promise<void> {

  const url = await vscode.window.showInputBox({ prompt: "Repository to clone (path or https URL)", placeHolder: "https://host:8890/project" });

  if (!url?.trim()) {

    return;

  }

  const parent = await vscode.window.showOpenDialog({ canSelectFiles: false, canSelectFolders: true, canSelectMany: false, openLabel: "Clone into this folder" });

  if (!parent?.[0]) {

    return;

  }

  const name = url.trim().replace(/\/+$/, "").split("/").pop()?.replace(/\.oxy$/, "") || "repository";

  const dest = vscode.Uri.joinPath(parent[0], name);

  try {

    await vscode.window.withProgress({ location: vscode.ProgressLocation.Notification, title: `Oxygen: cloning ${name}` }, () => oxy.clone(parent[0].fsPath, url.trim(), dest.fsPath));

    const pick = await vscode.window.showInformationMessage(`Oxygen: cloned into ${dest.fsPath}.`, "Open", "Open in new window");

    if (pick) {

      await vscode.commands.executeCommand("vscode.openFolder", dest, { forceNewWindow: pick === "Open in new window" });

    }

  } catch (e) {

    showError(e);

  }

}

  // ---------------------------------------------------------------- subrepos, bisect, trust, tags, workspaces

  submodules(root: string): Promise<SubrepoInfo[]> {

    return this.json<SubrepoInfo[]>(root, ["submodule", "status"]);

  }

  submoduleUpdate(root: string, init: boolean, paths: string[] = []): Promise<string> {

    return this.check(root, ["submodule", "update", ...(init ? ["--init"] : []), ...paths], [0, 1]).then((r) => r.stdout.toString("utf8"));

  }

  bisectStatus(root: string): Promise<BisectStatus | null> {

    return this.json<BisectStatus | null>(root, ["bisect", "status"]);

  }

  bisectStart(root: string): Promise<void> {

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

  }

  bisectMark(root: string, verdict: "good" | "bad" | "skip", changes: string[] = []): Promise<string> {

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

  }

  bisectRun(root: string, command: string[]): Promise<string> {

    return this.check(root, ["bisect", "run", ...command], [0, 1]).then((r) => r.stdout.toString("utf8").trim());

  }

  bisectReset(root: string): Promise<void> {

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

  }

  policyShow(root: string): Promise<PolicyInfo | null> {

    return this.json<PolicyInfo | null>(root, ["policy", "show"]);

  }

  verify(root: string, change?: string): Promise<VerifyInfo[]> {

    return this.json<VerifyInfo[]>(root, ["verify", ...(change ? [change] : [])], [0, 1]);

  }

  tags(root: string): Promise<TagInfo[]> {

    return this.json<TagInfo[]>(root, ["tag", "list"]);

  }

  workspaces(root: string): Promise<WorkspaceInfo[]> {

    return this.json<WorkspaceInfo[]>(root, ["workspace", "list"]);

  }

  workspaceAdd(root: string, path: string, changes: string[] = []): Promise<void> {

    return this.check(root, ["workspace", "add", path, ...changes]).then(() => undefined);

  }

}

export interface SubrepoInfo {

  path: string;

  pin: PinInfo;

  actual: PinInfo | null;

  at_pin: boolean;

  dirty: boolean;

  url: string | null;

}

export type PinInfo = { kind: "oxy"; repo: string; heads: string[]; bookmark: string } | { kind: "git"; sha: string; branch: string };

export type BisectStatus =

  | { state: "need-marks"; good: number; bad: number }

  | { state: "testing"; heads: string[]; remaining: number; steps_left: number }

  | { state: "found"; culprit: string }

  | { state: "inconclusive"; candidates: string[] };

export interface PolicyInfo {

  hash: string;

  serial: number;

  expires_ms: number;

  expired: boolean;

  root_threshold: number;

  roots: { key: string; name: string; email: string }[];

  rules: { pattern: string; keys: { key: string; name: string; email: string }[]; threshold: number; require: string; allow_conflicts: boolean }[];

  revoked: { key: string; name: string; email: string }[];

}

export interface VerifyInfo {

  hash: string;

  change_id: string;

  status: string;

  key: string | null;

  name: string | null;

  revoked: boolean;

  reason: string | null;

}

export interface TagInfo {

  name: string;

  state: string;

  heads: string[];

  message: string;

  signer: string | null;

}

export interface WorkspaceInfo {

  id: string;

  path: string;

  current: boolean;

  working_copy: string | null;

import { BookmarkInfo, Oxy, PathStatus, StatusInfo, SubrepoInfo } from "./oxy";

export class SubrepoState implements vscode.SourceControlResourceState {

  readonly resourceUri: vscode.Uri;

  readonly decorations: vscode.SourceControlResourceDecorations;

  readonly command: vscode.Command;

  readonly contextValue = "subrepo";

  constructor(

    readonly repository: Repository,

    readonly info: SubrepoInfo,

  ) {

    this.resourceUri = vscode.Uri.file(join(repository.root, info.path));

    const pin = info.pin.kind === "oxy" ? `${info.pin.bookmark} ${info.pin.heads.map((h) => h.slice(0, 8)).join(" ")}` : `git ${info.pin.branch} ${info.pin.sha.slice(0, 10)}`;

    const state = !info.actual ? "missing (update --init)" : info.dirty ? "uncommitted changes inside" : info.at_pin ? "at pin" : "differs from pin";

    this.decorations = { tooltip: `${pin} · ${state}`, faded: !info.actual, strikeThrough: false };

    this.command = { command: "oxygen.openSubrepo", title: "Open", arguments: [this] };

  }

}

  readonly subreposGroup: vscode.SourceControlResourceGroup;

  private subreposLatest: SubrepoInfo[] = [];

    this.subreposGroup = this.sourceControl.createResourceGroup("subrepos", "Subrepos");

    this.subreposGroup.hideWhenEmpty = true;

    this.disposables.push(this.sourceControl, this.conflictsGroup, this.changesGroup, this.subreposGroup, this.statusBar, this.syncBar, this.onDidChangeStatusEmitter);

  get subrepos(): SubrepoInfo[] {

    return this.subreposLatest;

  }

      const [status, prompt, bookmarks, subrepos] = await Promise.all([

        this.oxy.status(this.root),

        this.oxy.prompt(this.root),

        this.oxy.bookmarks(this.root).catch(() => [] as BookmarkInfo[]),

        this.oxy.submodules(this.root).catch(() => [] as SubrepoInfo[]),

      ]);

      this.subreposLatest = subrepos;

      this.subreposGroup.resourceStates = subrepos.map((s) => new SubrepoState(this, s));

  // Tags, workspaces, trust, bisect status, subrepos.

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

  const tags = await oxy.tags(root);

  assert.deepEqual(tags.map((t) => [t.name, t.message]), [["v1", "first"]]);

  const workspaces = await oxy.workspaces(root);

  assert.equal(workspaces.length, 1);

  assert.equal(workspaces[0].current, true);

  assert.equal(await oxy.policyShow(root), null, "no policy yet");

  const verify = await oxy.verify(root);

  assert.ok(verify.every((v) => v.status === "unsigned"));

  assert.equal(await oxy.bisectStatus(root), null);

  assert.deepEqual(await oxy.submodules(root), []);

  await oxy.bisectStart(root);

  assert.equal((await oxy.bisectStatus(root))?.state, "need-marks");

  await oxy.bisectReset(root);