Releases view and Draft Release from a tag with notes from history (0.6.0) 1cc0ff44e5ca

// The Releases view (spec §8.2): each repository's releases with their

// assets, and drafting a release from a tag with notes from history.

import * as vscode from "vscode";

import type * as api from "./hubapi";

import { HubAuth } from "./auth";

import { looksPrerelease, releaseNotes } from "./hub";

import type { HubRepo } from "./proposals";

type Node =

  | { kind: "repo"; repo: HubRepo }

  | { kind: "release"; repo: HubRepo; r: api.Release }

  | { kind: "asset"; repo: HubRepo; r: api.Release; name: string; url: string; size?: number; downloads?: number };

export type ReleaseNode = Extract<Node, { kind: "release" }>;

export class ReleasesProvider implements vscode.TreeDataProvider<Node> {

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

  readonly onDidChangeTreeData = this.emitter.event;

  constructor(

    private readonly repos: () => Promise<HubRepo[]>,

    private readonly auth: HubAuth,

  ) {}

  refresh(): void {

    this.emitter.fire();

  }

  getTreeItem(node: Node): vscode.TreeItem {

    switch (node.kind) {

      case "repo": {

        const item = new vscode.TreeItem(`${node.repo.owner}/${node.repo.name}`, vscode.TreeItemCollapsibleState.Expanded);

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

        item.contextValue = "releaseRepo";

        return item;

      }

      case "release": {

        const r = node.r;

        const item = new vscode.TreeItem(r.title || r.tag, vscode.TreeItemCollapsibleState.Collapsed);

        item.description = [r.tag, r.latest ? "latest" : "", r.prerelease ? "pre-release" : "", new Date(r.created_ms).toLocaleDateString()].filter(Boolean).join(" · ");

        item.iconPath = new vscode.ThemeIcon(r.prerelease ? "beaker" : "tag");

        item.tooltip = new vscode.MarkdownString(`**${r.title || r.tag}** · ${r.tag} by ${r.author}\n\n${r.notes.slice(0, 600)}`);

        item.contextValue = "release";

        item.command = { title: "Open", command: "vscode.open", arguments: [vscode.Uri.parse(r.url)] };

        return item;

      }

      case "asset": {

        const item = new vscode.TreeItem(node.name, vscode.TreeItemCollapsibleState.None);

        item.description = node.size !== undefined ? `${formatSize(node.size)} · ${node.downloads ?? 0} downloads` : "source archive";

        item.iconPath = new vscode.ThemeIcon(node.size !== undefined ? "package" : "file-zip");

        item.command = { title: "Download", command: "vscode.open", arguments: [vscode.Uri.parse(node.url)] };

        return item;

      }

    }

  }

  async getChildren(node?: Node): Promise<Node[]> {

    if (!node) {

      return (await this.repos()).map((repo) => ({ kind: "repo", repo }));

    }

    if (node.kind === "repo") {

      try {

        const list = await this.auth.clientFor(node.repo.base).releases(node.repo.owner, node.repo.name);

        return list.map((r) => ({ kind: "release", repo: node.repo, r }));

      } catch (e) {

        void vscode.window.showWarningMessage(`Oxygenhub: ${(e as Error).message}`);

        return [];

      }

    }

    if (node.kind === "release") {

      const assets: Node[] = node.r.assets.map((a) => ({ kind: "asset", repo: node.repo, r: node.r, name: a.name, url: a.url, size: a.size, downloads: a.downloads }));

      const archives: Node[] = node.r.archives.map((url) => ({ kind: "asset", repo: node.repo, r: node.r, name: url.split("/").pop() ?? url, url }));

      return [...assets, ...archives];

    }

    return [];

  }

}

function formatSize(n: number): string {

  return n >= 1 << 20 ? `${(n / (1 << 20)).toFixed(1)} MiB` : n >= 1024 ? `${(n / 1024).toFixed(1)} KiB` : `${n} B`;

}

/** Draft a release: a tag without one, a title, notes from the changes since the last release. */

export async function draftRelease(auth: HubAuth, repo: HubRepo): Promise<api.Release | undefined> {

  const client = auth.clientFor(repo.base);

  const [tags, releases] = await Promise.all([client.tags(repo.owner, repo.name), client.releases(repo.owner, repo.name)]);

  const released = new Set(releases.map((r) => r.tag));

  const open = tags.filter((t) => !released.has(t.name));

  if (!open.length) {

    void vscode.window.showInformationMessage(`Oxygenhub: every tag of ${repo.owner}/${repo.name} has a release. Tag a state with \`oxy tag create\` and push it first.`);

    return undefined;

  }

  const pick = await vscode.window.showQuickPick(

    open.map((t) => ({ label: t.name, description: t.message.split("\n")[0], detail: t.signer ? "signed" : undefined, t })),

    { placeHolder: "Tag to release" },

  );

  if (!pick) {

    return undefined;

  }

  const title = await vscode.window.showInputBox({ prompt: "Release title", value: pick.t.message.split("\n")[0] || pick.label });

  if (title === undefined) {

    return undefined;

  }

  const previous = releases.filter((r) => !r.prerelease).sort((a, b) => b.created_ms - a.created_ms)[0];

  const current = await client.history(repo.owner, repo.name, pick.label, 500);

  const before = previous ? await client.history(repo.owner, repo.name, previous.tag, 500) : { changes: [] as api.ChangeSummary[] };

  const notes = releaseNotes(current.changes, before.changes, previous?.tag);

  const pre = await vscode.window.showQuickPick(

    [

      { label: "Release", pre: false },

      { label: "Pre-release", pre: true },

    ].sort((a) => (a.pre === looksPrerelease(pick.label) ? -1 : 1)),

    { placeHolder: "Kind" },

  );

  if (!pre) {

    return undefined;

  }

  return client.createRelease(repo.owner, repo.name, { tag: pick.label, title: title || pick.label, notes, prerelease: pre.pre });

}

## 0.6.0

- A **Releases** view: each repository's releases with their assets and source archives, to open or download.

- **Draft Release…**: pick a tag without a release, confirm the title, and the notes are written from the changes since the last release.

- **Releases** view: releases with their assets; draft a release from a tag with notes written from the changes since the last one.

### 8.2 Releases

The **Releases** view lists each repository's releases, newest first (`GET /repos/{o}/{n}/releases`): title, tag, `latest` or `pre-release`, date; the tooltip shows the start of the notes. Expanding a release lists its uploaded assets (size, downloads) and the hub's source archives; picking one downloads it through the browser, picking the release opens it on the hub.

**Draft Release…** (the view's title bar, or inline on a repository) releases a tag that has none yet: pick the tag (`GET /tags`, minus those already released), confirm a title (the tag's message by default), and choose release or pre-release (a tag such as `v2.0-rc1` or `1.0.0-beta.2` suggests pre-release). The notes are generated: the changes in the tag's history that the newest full release's tag does not have, newest first, one line each with the message's subject and a short hash. The release is created with `POST /releases`; assets are uploaded on the hub or with `oxy`. Editing notes after creation happens on the hub.

  "version": "0.6.0",

        },

        {

          "id": "oxygenhub.releases",

          "name": "Releases"

      },

      {

        "command": "oxygenhub.draftRelease",

        "title": "Draft Release\u2026",

        "category": "Oxygenhub",

        "icon": "$(tag)"

          "when": "view == oxygenhub.proposals || view == oxygenhub.issues || view == oxygenhub.releases",

          "group": "navigation"

        },

        {

          "command": "oxygenhub.draftRelease",

          "when": "view == oxygenhub.releases",

        },

        {

          "command": "oxygenhub.draftRelease",

          "when": "view == oxygenhub.releases && viewItem == releaseRepo",

          "group": "inline"

import { draftRelease, ReleasesProvider } from "./releases";

let releases: ReleasesProvider;

  releases = new ReleasesProvider(() => proposals.repos(), auth);

  context.subscriptions.push(vscode.window.registerTreeDataProvider("oxygenhub.releases", releases));

    vscode.commands.registerCommand("oxygenhub.draftRelease", async (node?: { repo?: HubRepo }) => {

      const repos = await proposals.repos();

      const repo = node?.repo ?? (repos.length === 1 ? repos[0] : (await vscode.window.showQuickPick(repos.map((r) => ({ label: `${r.owner}/${r.name}`, r })), { placeHolder: "Repository" }))?.r);

      if (!repo) {

        return;

      }

      try {

        const r = await draftRelease(auth, repo);

        if (r) {

          releases.refresh();

          const open = await vscode.window.showInformationMessage(`Oxygenhub: released ${r.tag}.`, "Open on Hub");

          if (open) {

            void vscode.env.openExternal(vscode.Uri.parse(r.url));

          }

        }

      } catch (e) {

        void vscode.window.showErrorMessage(`Oxygenhub: ${(e as Error).message}`);

      }

    }),

  releases.refresh();

  releases(owner: string, name: string): Promise<api.Release[]> {

    return this.request("GET", `/repos/${owner}/${name}/releases`);

  }

  createRelease(owner: string, name: string, r: api.NewRelease): Promise<api.Release> {

    return this.request("POST", `/repos/${owner}/${name}/releases`, r);

  }

  tags(owner: string, name: string): Promise<api.Tag[]> {

    return this.request("GET", `/repos/${owner}/${name}/tags`);

  }

}

/**

 * Release notes from history: the changes in `current` that `previous`

 * does not have, newest first, one line each (the message's subject).

 */

export function releaseNotes(current: api.ChangeSummary[], previous: api.ChangeSummary[], sinceTag?: string): string {

  const seen = new Set(previous.map((c) => c.hash));

  const lines = current

    .filter((c) => !seen.has(c.hash))

    .sort((a, b) => b.when_ms - a.when_ms)

    .map((c) => `- ${c.message.split("\n")[0].trim()} (${c.hash.slice(0, 12)})`);

  const head = sinceTag ? `Changes since ${sinceTag}:` : "Changes:";

  return lines.length ? `${head}\n\n${lines.join("\n")}\n` : "No changes since the last release.\n";

}

/** Whether a tag name reads as a pre-release (`v1.0-rc1`, `2.0.0-beta.2`, `alpha`). */

export function looksPrerelease(tag: string): boolean {

  return /(^|[-.+_])(alpha|beta|rc|pre|preview|dev)\d*([-.+_]|$)/i.test(tag) || /-(a|b|rc)\d+$/i.test(tag);

import { HubClient, HubError, encodeDiffQuery, decodeDiffQuery, hubTarget, releaseNotes, looksPrerelease } from "../out/hub.mjs";

    // Releases: a tag pushed with oxy, then released with notes from history.

    oxy("bookmark", "switch", "main");

    oxy("tag", "create", "v1.0", "-m", "First");

    oxy("push", "origin");

    const tags = await client.tags("andy", "demo");

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

    assert.deepEqual(await client.releases("andy", "demo"), []);

    const hist = await client.history("andy", "demo", "v1.0", 500);

    const rel = await client.createRelease("andy", "demo", { tag: "v1.0", title: "One", notes: releaseNotes(hist.changes, []), prerelease: false });

    assert.equal(rel.tag, "v1.0");

    assert.match(rel.notes, /- base \(/);

    const rels = await client.releases("andy", "demo");

    assert.equal(rels.length, 1);

    assert.equal(rels[0].title, "One");

});

test("release notes list the changes since the previous release, newest first", () => {

  const c = (hash, message, when_ms) => ({ hash, message, when_ms, author: {}, deps: [], head: false, signature: {} });

  const old = [c("a".repeat(64), "base", 1)];

  const now = [...old, c("b".repeat(64), "Add feature\n\nbody", 2), c("c".repeat(64), "Fix bug", 3)];

  assert.equal(releaseNotes(now, old, "v1.0"), `Changes since v1.0:\n\n- Fix bug (${"c".repeat(12)})\n- Add feature (${"b".repeat(12)})\n`);

  assert.equal(releaseNotes(old, old, "v1.0"), "No changes since the last release.\n");

  assert.match(releaseNotes(old, []), /^Changes:\n\n- base/);

});

test("pre-release tags are recognised", () => {

  for (const t of ["v1.0-rc1", "2.0.0-beta.2", "v3-alpha", "1.0.0-pre", "v2.1b3".replace("b3", "-b3")]) {

    assert.ok(looksPrerelease(t), t);

  }

  for (const t of ["v1.0", "2.0.0", "release-2026", "v1.0-final", "debate"]) {

    assert.ok(!looksPrerelease(t), t);

  }