bstack 0.0.0 → 0.2.0

package/dist/bstack.js

@@ -0,0 +1,730 @@
+#!/usr/bin/env node
+import { parseArgs } from "node:util";
+import { spawnSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+//#region package.json
+var version = "0.2.0";
+//#endregion
+//#region src/command.ts
+var CommandError = class extends Error {
+	command;
+	result;
+	constructor(command, result) {
+		const detail = result.stderr.trim() || result.stdout.trim();
+		super(`${command.join(" ")} failed with exit code ${result.exitCode}${detail ? `\n${detail}` : ""}`);
+		this.command = command;
+		this.result = result;
+	}
+};
+var NodeCommandRunner = class {
+	run(command, options) {
+		const [executable, ...args] = command;
+		if (!executable) throw new Error("Cannot run an empty command");
+		const result = spawnSync(executable, args, {
+			cwd: options.cwd,
+			input: options.stdin,
+			encoding: "utf8",
+			env: options.env === void 0 ? process.env : {
+				...process.env,
+				...options.env
+			}
+		});
+		const commandResult = {
+			stdout: result.stdout ?? "",
+			stderr: result.stderr ?? result.error?.message ?? "",
+			exitCode: result.status ?? 1
+		};
+		if (commandResult.exitCode !== 0 && !options.allowFailure) throw new CommandError(command, commandResult);
+		return commandResult;
+	}
+};
+//#endregion
+//#region src/checkout.ts
+function checkoutStack(repository, github, options) {
+	const { reporter } = options;
+	reporter.progress("Checking the repository and GitHub prerequisites");
+	repository.assertReady();
+	github.assertReady();
+	const remote = repository.resolveRemote(options.remote);
+	reporter.progress(`Looking up pull request ${options.reference}`);
+	const headRef = github.pullRequestHead(options.reference);
+	if (!headRef.startsWith("bstack/")) {
+		reporter.progress("This is not a bstack pull request; delegating to gh pr checkout");
+		github.checkoutPullRequest(options.reference);
+		return {
+			headRef,
+			delegated: true
+		};
+	}
+	let currentBase;
+	let remoteBase;
+	if (options.sameBase) {
+		const base = options.base ?? github.defaultBranch();
+		reporter.progress(`Checking that the merge base remains on ${remote}/${base}`);
+		remoteBase = repository.fetchBase(remote, base);
+		currentBase = repository.mergeBase("HEAD", remoteBase);
+	}
+	reporter.progress(`Fetching ${remote}/${headRef}`);
+	const target = repository.fetchRemoteBranch(remote, headRef);
+	if (currentBase && remoteBase) {
+		const targetBase = repository.mergeBase(target, remoteBase);
+		if (currentBase !== targetBase) throw new Error(`Checkout would change the merge base from ${currentBase.slice(0, 8)} to ${targetBase.slice(0, 8)}`);
+	}
+	reporter.progress(`Checking out ${remote}/${headRef} in detached HEAD state`);
+	repository.checkout(target);
+	reporter.progress("Checkout complete; amend the commits and run bstack to publish updates");
+	return {
+		headRef,
+		delegated: false
+	};
+}
+//#endregion
+//#region src/identity.ts
+const trailerPattern = /^Bstack-Id:\s*(\S+)\s*$/gim;
+function readChangeId(message) {
+	const matches = [...message.matchAll(trailerPattern)];
+	if (matches.length > 1) throw new Error("A commit contains more than one Bstack-Id trailer");
+	return matches[0]?.[1];
+}
+function addChangeId(message, changeId) {
+	return `${message.trimEnd()}\n\nBstack-Id: ${changeId}\n`;
+}
+function newChangeId() {
+	return randomUUID().replaceAll("-", "");
+}
+function parseRawCommit(oid, raw) {
+	const boundary = raw.indexOf("\n\n");
+	if (boundary === -1) throw new Error(`Commit ${oid} has an invalid object format`);
+	const headers = raw.slice(0, boundary).split("\n");
+	const treeLine = headers.find((line) => line.startsWith("tree "));
+	const parents = headers.filter((line) => line.startsWith("parent "));
+	if (!treeLine || parents.length !== 1) throw new Error(`Commit ${oid} must have exactly one parent; merge and root commits are not supported`);
+	if (headers.some((line) => line.startsWith("gpgsig "))) throw new Error(`Commit ${oid} is signed. bstack cannot add an identity trailer without replacing its signature`);
+	const message = raw.slice(boundary + 2);
+	return {
+		oid,
+		tree: treeLine.slice(5),
+		parent: parents[0].slice(7),
+		message,
+		headers,
+		changeId: readChangeId(message)
+	};
+}
+function rewriteCommit(commit, parent, message) {
+	const rewrittenHeaders = [];
+	let replacedParent = false;
+	for (const header of commit.headers) {
+		if (header.startsWith("parent ")) {
+			if (!replacedParent) {
+				rewrittenHeaders.push(`parent ${parent}`);
+				replacedParent = true;
+			}
+			continue;
+		}
+		rewrittenHeaders.push(header);
+	}
+	return `${rewrittenHeaders.join("\n")}\n\n${message}`;
+}
+function splitCommitMessage(message) {
+	const [subject = "Untitled change", ...bodyLines] = message.split("\n").filter((line) => !/^Bstack-Id:\s*\S+\s*$/i.test(line)).join("\n").trim().split("\n");
+	return {
+		subject,
+		body: bodyLines.join("\n").trim()
+	};
+}
+//#endregion
+//#region src/git.ts
+var GitRepository = class {
+	cwd;
+	runner;
+	constructor(cwd, runner) {
+		this.cwd = cwd;
+		this.runner = runner;
+	}
+	git(args, options = {}) {
+		return this.runner.run(["git", ...args], {
+			cwd: this.cwd,
+			...options
+		});
+	}
+	assertReady() {
+		this.git(["rev-parse", "--show-toplevel"]);
+		if (this.git(["status", "--porcelain"]).stdout.trim()) throw new Error("The working tree must be clean before bstack rewrites or publishes commits");
+	}
+	currentBranch() {
+		return this.git([
+			"symbolic-ref",
+			"--quiet",
+			"--short",
+			"HEAD"
+		], { allowFailure: true }).stdout.trim();
+	}
+	remotes() {
+		return this.git(["remote"]).stdout.split("\n").filter(Boolean);
+	}
+	configuredPushRemote() {
+		const result = this.git([
+			"config",
+			"--get",
+			"remote.pushDefault"
+		], { allowFailure: true });
+		return result.exitCode === 0 ? result.stdout.trim() || void 0 : void 0;
+	}
+	resolveRemote(requested) {
+		if (requested) {
+			if (!this.remotes().includes(requested)) throw new Error(`Git remote ${requested} does not exist`);
+			return requested;
+		}
+		const configured = this.configuredPushRemote();
+		if (configured) return configured;
+		const remotes = this.remotes();
+		if (remotes.length === 1) return remotes[0];
+		if (remotes.includes("origin")) return "origin";
+		throw new Error("Cannot choose a Git remote. Pass --remote or configure remote.pushDefault");
+	}
+	fetchBase(remote, base) {
+		const destination = `refs/remotes/${remote}/${base}`;
+		this.git([
+			"fetch",
+			"--no-tags",
+			remote,
+			`refs/heads/${base}:${destination}`
+		]);
+		return destination;
+	}
+	fetchRemoteBranch(remote, branch) {
+		const destination = `refs/remotes/${remote}/${branch}`;
+		this.git([
+			"fetch",
+			"--no-tags",
+			remote,
+			`+refs/heads/${branch}:${destination}`
+		]);
+		return destination;
+	}
+	checkout(ref) {
+		this.git([
+			"checkout",
+			"--detach",
+			ref
+		]);
+	}
+	mergeBase(left, right) {
+		return this.git([
+			"merge-base",
+			left,
+			right
+		]).stdout.trim();
+	}
+	commitsSince(baseOid) {
+		return this.git([
+			"rev-list",
+			"--reverse",
+			"--first-parent",
+			`${baseOid}..HEAD`
+		]).stdout.split("\n").filter(Boolean).map((oid) => parseRawCommit(oid, this.git([
+			"cat-file",
+			"commit",
+			oid
+		]).stdout));
+	}
+	ensureChangeIds(commits, dryRun) {
+		const assigned = commits.map((commit) => commit.changeId ?? newChangeId());
+		const needsRewrite = commits.some((commit) => commit.changeId === void 0);
+		let parent = commits[0]?.parent;
+		const rewrittenOids = [];
+		if (needsRewrite && !dryRun) {
+			for (const [index, commit] of commits.entries()) {
+				const changeId = assigned[index];
+				const message = commit.changeId ? commit.message : addChangeId(commit.message, changeId);
+				const raw = rewriteCommit(commit, parent, message);
+				const oid = this.git([
+					"hash-object",
+					"-t",
+					"commit",
+					"-w",
+					"--stdin"
+				], { stdin: raw }).stdout.trim();
+				rewrittenOids.push(oid);
+				parent = oid;
+			}
+			const oldHead = commits.at(-1).oid;
+			const newHead = rewrittenOids.at(-1);
+			this.git([
+				"update-ref",
+				"HEAD",
+				newHead,
+				oldHead
+			]);
+		}
+		return commits.map((commit, index) => {
+			const id = assigned[index];
+			const oid = needsRewrite && !dryRun ? rewrittenOids[index] : commit.oid;
+			const { subject, body } = splitCommitMessage(commit.message);
+			return {
+				id,
+				oid,
+				subject,
+				body,
+				remoteBranch: `bstack/${id}`
+			};
+		});
+	}
+	remoteBranchOids(remote, branches) {
+		if (branches.length === 0) return /* @__PURE__ */ new Map();
+		const result = this.git([
+			"ls-remote",
+			"--heads",
+			remote,
+			...branches.map((branch) => `refs/heads/${branch}`)
+		]);
+		return new Map(result.stdout.split("\n").filter(Boolean).map((line) => {
+			const [oid, ref] = line.split(/\s+/, 2);
+			return [ref.replace("refs/heads/", ""), oid];
+		}));
+	}
+	pushChanges(remote, changes) {
+		const existing = this.remoteBranchOids(remote, changes.map((change) => change.remoteBranch));
+		const leases = [];
+		const refspecs = [];
+		for (const change of changes) {
+			const expected = existing.get(change.remoteBranch) ?? "";
+			leases.push(`--force-with-lease=refs/heads/${change.remoteBranch}:${expected}`);
+			refspecs.push(`${change.oid}:refs/heads/${change.remoteBranch}`);
+		}
+		this.git([
+			"push",
+			"--atomic",
+			...leases,
+			remote,
+			...refspecs
+		]);
+	}
+	statePath() {
+		return this.git([
+			"rev-parse",
+			"--path-format=absolute",
+			"--git-path",
+			"bstack/state.json"
+		]).stdout.trim();
+	}
+};
+//#endregion
+//#region src/github.ts
+var GhPlatform = class {
+	cwd;
+	runner;
+	constructor(cwd, runner) {
+		this.cwd = cwd;
+		this.runner = runner;
+	}
+	gh(args) {
+		return this.runner.run(["gh", ...args], { cwd: this.cwd });
+	}
+	assertReady() {
+		this.gh([
+			"auth",
+			"status",
+			"--active"
+		]);
+		this.gh(["stack", "--version"]);
+	}
+	defaultBranch() {
+		return this.gh([
+			"repo",
+			"view",
+			"--json",
+			"defaultBranchRef",
+			"--jq",
+			".defaultBranchRef.name"
+		]).stdout.trim();
+	}
+	pullRequestForBranch(branch) {
+		const raw = this.gh([
+			"pr",
+			"list",
+			"--head",
+			branch,
+			"--state",
+			"all",
+			"--limit",
+			"20",
+			"--json",
+			"number,url,state,title,body,isDraft"
+		]).stdout;
+		const candidates = JSON.parse(raw);
+		const selected = candidates.find((pr) => pr.state === "OPEN") ?? candidates.find((pr) => pr.state === "MERGED");
+		return selected ? normalizePullRequest(selected) : void 0;
+	}
+	pullRequest(number) {
+		const raw = this.gh([
+			"pr",
+			"view",
+			String(number),
+			"--json",
+			"number,url,state,title,body,isDraft"
+		]).stdout;
+		return normalizePullRequest(JSON.parse(raw));
+	}
+	createPullRequest(change, base, open) {
+		const args = [
+			"pr",
+			"create",
+			"--base",
+			base,
+			"--head",
+			change.remoteBranch,
+			"--title",
+			change.subject,
+			"--body",
+			change.body
+		];
+		if (!open) args.push("--draft");
+		this.gh(args);
+		const created = this.pullRequestForBranch(change.remoteBranch);
+		if (!created) throw new Error(`GitHub did not return the PR created for ${change.remoteBranch}`);
+		return created;
+	}
+	linkStack(branches, base, remote, open) {
+		const args = [
+			"stack",
+			"link",
+			"--base",
+			base,
+			"--remote",
+			remote
+		];
+		if (open) args.push("--open");
+		args.push(...branches);
+		this.gh(args);
+	}
+	appendToStack(stackNumber, branches, remote, open) {
+		const args = [
+			"stack",
+			"link",
+			"--remote",
+			remote
+		];
+		if (open) args.push("--open");
+		args.push(String(stackNumber), ...branches);
+		this.gh(args);
+	}
+	editPullRequest(pr, change) {
+		if (pr.title === change.subject && pr.body === change.body) return;
+		this.gh([
+			"pr",
+			"edit",
+			String(pr.number),
+			"--title",
+			change.subject,
+			"--body",
+			change.body
+		]);
+	}
+	stackNumberForPullRequest(prNumber) {
+		const raw = this.gh(["api", `repos/{owner}/{repo}/stacks?pull_request=${prNumber}`]).stdout;
+		return JSON.parse(raw)[0]?.number;
+	}
+	pullRequestHead(reference) {
+		return this.gh([
+			"pr",
+			"view",
+			reference,
+			"--json",
+			"headRefName",
+			"--jq",
+			".headRefName"
+		]).stdout.trim();
+	}
+	checkoutPullRequest(reference) {
+		this.gh([
+			"pr",
+			"checkout",
+			reference
+		]);
+	}
+};
+function normalizePullRequest(pr) {
+	if (pr.state !== "OPEN" && pr.state !== "CLOSED" && pr.state !== "MERGED") throw new Error(`GitHub returned an unknown PR state: ${pr.state}`);
+	return {
+		...pr,
+		state: pr.state
+	};
+}
+//#endregion
+//#region src/reporter.ts
+var ConsoleReporter = class {
+	enabled;
+	constructor(enabled = true) {
+		this.enabled = enabled;
+	}
+	progress(message) {
+		if (this.enabled) process.stderr.write(`[bstack] ${message}\n`);
+	}
+};
+//#endregion
+//#region src/state.ts
+const emptyState = () => ({
+	schemaVersion: 1,
+	stacks: []
+});
+var StateStore = class {
+	path;
+	constructor(path) {
+		this.path = path;
+	}
+	read() {
+		try {
+			const parsed = JSON.parse(readFileSync(this.path, "utf8"));
+			if (!isState(parsed)) throw new Error(`Unsupported bstack state in ${this.path}`);
+			return parsed;
+		} catch (error) {
+			if (isMissingFile(error)) return emptyState();
+			throw error;
+		}
+	}
+	write(state) {
+		mkdirSync(dirname(this.path), { recursive: true });
+		const temporary = `${this.path}.tmp`;
+		writeFileSync(temporary, `${JSON.stringify(state, null, 2)}\n`);
+		renameSync(temporary, this.path);
+	}
+	findByChangeIds(state, ids) {
+		const matches = state.stacks.filter((stack) => stack.changes.some((change) => ids.has(change.id)));
+		if (matches.length > 1) throw new Error("The current commits match more than one stored bstack stack");
+		return matches[0];
+	}
+};
+function isMissingFile(error) {
+	return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+function isState(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const candidate = value;
+	return candidate.schemaVersion === 1 && Array.isArray(candidate.stacks);
+}
+//#endregion
+//#region src/sync.ts
+function syncStack(repository, github, options) {
+	const { reporter } = options;
+	reporter.progress("Checking the repository and GitHub prerequisites");
+	repository.assertReady();
+	github.assertReady();
+	const remote = repository.resolveRemote(options.remote);
+	const base = options.base ?? github.defaultBranch();
+	reporter.progress(`Using ${remote} as the remote and ${base} as the stack base`);
+	reporter.progress(`Fetching ${remote}/${base}`);
+	const remoteBase = repository.fetchBase(remote, base);
+	const baseOid = repository.mergeBase("HEAD", remoteBase);
+	const commits = repository.commitsSince(baseOid);
+	if (commits.length === 0) throw new Error(`No commits found between ${base} and HEAD`);
+	reporter.progress(`Found ${commits.length} local change${commits.length === 1 ? "" : "s"}`);
+	const rewritten = commits.some((commit) => commit.changeId === void 0);
+	if (rewritten) reporter.progress(options.dryRun ? "Stable change IDs would be added to the commits" : "Adding stable change IDs to the commits");
+	else reporter.progress("All commits already have stable change IDs");
+	const changes = repository.ensureChangeIds(commits, options.dryRun);
+	if (options.dryRun) {
+		reporter.progress("Dry run complete; no commits or remote branches were changed");
+		return {
+			base,
+			remote,
+			rewritten,
+			changes
+		};
+	}
+	reporter.progress("Reading the previous stack state");
+	const store = new StateStore(repository.statePath());
+	const state = store.read();
+	const previous = store.findByChangeIds(state, new Set(changes.map((change) => change.id)));
+	const evolution = analyzeEvolution(previous, changes, github);
+	reporter.progress(`Publishing ${changes.length} protected remote ref${changes.length === 1 ? "" : "s"}`);
+	repository.pushChanges(remote, changes);
+	reporter.progress("Looking up existing pull requests");
+	const existing = changes.map((change) => github.pullRequestForBranch(change.remoteBranch));
+	let pullRequests;
+	if (changes.length === 1) {
+		if (evolution.kind === "partial") reporter.progress("Updating this down-stack prefix while preserving higher pull requests");
+		reporter.progress(existing[0] ? "Using the existing pull request" : "Creating a pull request");
+		pullRequests = [existing[0] ?? github.createPullRequest(changes[0], base, options.open)];
+	} else {
+		if (evolution.kind === "full") {
+			reporter.progress(`Linking ${changes.length} pull requests as a native GitHub stack`);
+			github.linkStack(changes.map((change) => change.remoteBranch), base, remote, options.open);
+		} else if (evolution.kind === "append") {
+			reporter.progress(`Appending ${evolution.branches.length} pull request${evolution.branches.length === 1 ? "" : "s"} to stack #${evolution.stackNumber}`);
+			github.appendToStack(evolution.stackNumber, evolution.branches, remote, options.open);
+		} else if (evolution.kind === "partial") reporter.progress("Updating this down-stack prefix while preserving higher pull requests");
+		else reporter.progress("The native GitHub stack already has the correct members");
+		pullRequests = changes.map((change, index) => {
+			const pr = existing[index] ?? github.pullRequestForBranch(change.remoteBranch);
+			if (!pr) throw new Error(`GitHub did not return a PR for ${change.remoteBranch}`);
+			return pr;
+		});
+	}
+	reporter.progress("Synchronizing pull request titles and descriptions");
+	for (const [index, pr] of pullRequests.entries()) {
+		github.editPullRequest(pr, changes[index]);
+		reporter.progress(`PR #${pr.number}: ${changes[index].subject}`);
+	}
+	const stackNumber = previous?.stackNumber ?? (pullRequests.length > 1 ? github.stackNumberForPullRequest(pullRequests[0].number) : void 0);
+	const synchronizedChanges = changes.map((change, index) => ({
+		id: change.id,
+		remoteBranch: change.remoteBranch,
+		pullRequest: pullRequests[index].number,
+		url: pullRequests[index].url
+	}));
+	const storedChanges = evolution.kind === "partial" && previous ? [...synchronizedChanges, ...previous.changes.slice(evolution.previousOffset + changes.length)] : synchronizedChanges;
+	writeUpdatedState(store, state, previous, {
+		remote,
+		base,
+		...stackNumber === void 0 ? {} : { stackNumber },
+		changes: storedChanges
+	});
+	reporter.progress("Saved the local stack state");
+	return {
+		base,
+		remote,
+		rewritten,
+		changes: changes.map((change, index) => ({
+			...change,
+			pullRequest: pullRequests[index]
+		}))
+	};
+}
+function analyzeEvolution(previous, changes, github) {
+	if (!previous) return { kind: "full" };
+	const previousIds = previous.changes.map((change) => change.id);
+	const currentIds = changes.map((change) => change.id);
+	const firstCurrentIndex = previousIds.indexOf(currentIds[0]);
+	if (firstCurrentIndex === -1) throw new Error("The current commits do not continue the previously submitted stack");
+	const removedPrefix = previous.changes.slice(0, firstCurrentIndex);
+	for (const removed of removedPrefix) if (github.pullRequest(removed.pullRequest).state !== "MERGED") throw new Error("Submitted commits may only disappear from the bottom after their pull requests are merged");
+	const surviving = previousIds.slice(firstCurrentIndex);
+	const sharedLength = Math.min(surviving.length, currentIds.length);
+	for (let index = 0; index < sharedLength; index++) if (surviving[index] !== currentIds[index]) throw new Error("Reordering or removing submitted commits is not supported yet. Restore the original order before syncing");
+	if (currentIds.length < surviving.length) return {
+		kind: "partial",
+		previousOffset: firstCurrentIndex
+	};
+	const appended = changes.slice(surviving.length);
+	if (removedPrefix.length === 0) return { kind: "full" };
+	if (appended.length === 0) return { kind: "skip" };
+	if (previous.stackNumber === void 0) throw new Error("Cannot append after a merge because the native GitHub stack number is missing from local state");
+	return {
+		kind: "append",
+		stackNumber: previous.stackNumber,
+		branches: appended.map((change) => change.remoteBranch)
+	};
+}
+function writeUpdatedState(store, state, previous, updated) {
+	const stacks = previous ? state.stacks.map((stack) => stack === previous ? updated : stack) : [...state.stacks, updated];
+	store.write({
+		schemaVersion: 1,
+		stacks
+	});
+}
+//#endregion
+//#region src/cli.ts
+const help = `bstack - turn a linear commit series into native GitHub stacked PRs
+
+Usage:
+  bstack [sync] [options]
+  bstack checkout <PR-number-or-URL> [options]
+
+Options:
+  --base <branch>    Stack trunk; defaults to the GitHub default branch
+  --remote <name>    Git remote; defaults to remote.pushDefault or origin
+  --open             Create PRs ready for review instead of drafts
+  --dry-run          Inspect the stack without rewriting commits or pushing
+  --quiet            Hide progress logs; the final summary is still printed
+  --same-base        Refuse checkout if it would change the current merge base
+  -v, --version      Show the installed version
+  -h, --help         Show this help
+`;
+function main() {
+	const { values, positionals } = parseArgs({
+		args: process.argv.slice(2),
+		allowPositionals: true,
+		options: {
+			base: { type: "string" },
+			remote: { type: "string" },
+			open: {
+				type: "boolean",
+				default: false
+			},
+			"dry-run": {
+				type: "boolean",
+				default: false
+			},
+			quiet: {
+				type: "boolean",
+				default: false
+			},
+			"same-base": {
+				type: "boolean",
+				default: false
+			},
+			version: {
+				type: "boolean",
+				short: "v",
+				default: false
+			},
+			help: {
+				type: "boolean",
+				short: "h",
+				default: false
+			}
+		}
+	});
+	if (values.help) {
+		process.stdout.write(help);
+		return;
+	}
+	if (values.version) {
+		console.log(version);
+		return;
+	}
+	const runner = new NodeCommandRunner();
+	const cwd = process.cwd();
+	const repository = new GitRepository(cwd, runner);
+	const github = new GhPlatform(cwd, runner);
+	const reporter = new ConsoleReporter(!values.quiet);
+	const command = positionals[0] ?? "sync";
+	if (command === "checkout") {
+		const reference = positionals[1];
+		if (!reference || positionals.length > 2) throw new Error(`Usage: bstack checkout <PR-number-or-URL> [options]`);
+		const result = checkoutStack(repository, github, {
+			reference,
+			base: values.base,
+			remote: values.remote,
+			sameBase: values["same-base"],
+			reporter
+		});
+		console.log(result.delegated ? `Checked out pull request ${reference}` : `Checked out ${result.headRef} from pull request ${reference}`);
+		return;
+	}
+	if (command !== "sync" || positionals.length > 1) throw new Error(`Unknown command: ${positionals.join(" ")}\n\n${help}`);
+	const result = syncStack(repository, github, {
+		base: values.base,
+		remote: values.remote,
+		open: values.open,
+		dryRun: values["dry-run"],
+		reporter
+	});
+	console.log(`${values["dry-run"] ? "Would publish" : "Published"} ${result.changes.length} change${result.changes.length === 1 ? "" : "s"} against ${result.base}:`);
+	for (const change of result.changes) {
+		const destination = change.pullRequest ? ` ${change.pullRequest.url}` : "";
+		console.log(`  ${change.oid.slice(0, 8)}  ${change.subject}${destination}`);
+	}
+}
+try {
+	main();
+} catch (error) {
+	const message = error instanceof Error ? error.message : String(error);
+	console.error(`bstack: ${message}`);
+	process.exitCode = 1;
+}
+//#endregion
+export {};