@varlock/bumpy 0.0.0 → 0.0.2

package/.claude-plugin/plugin.json

@@ -0,0 +1,13 @@
+{
+  "name": "bumpy",
+  "version": "0.0.1",
+  "description": "AI-assisted changeset creation for bumpy monorepo versioning",
+  "author": {
+    "name": "DMNO",
+    "url": "https://github.com/dmno-dev"
+  },
+  "repository": "https://github.com/dmno-dev/bumpy",
+  "license": "MIT",
+  "keywords": ["monorepo", "versioning", "changelog", "changesets"],
+  "skills": "./skills/"
+}

package/dist/add-BjyVIUlr.mjs

@@ -0,0 +1,175 @@
+import { n as log, o as __toESM, r as require_picocolors } from "./logger-C2dEe5Su.mjs";
+import { n as exists, t as ensureDir } from "./fs-0AtnPUUe.mjs";
+import { a as loadConfig, r as getBumpyDir, s as matchGlob } from "./config-BkwIEaQg.mjs";
+import { t as discoverPackages } from "./workspace-CxEKakDm.mjs";
+import { t as DependencyGraph } from "./dep-graph-E-9-eQ2J.mjs";
+import { i as writeChangeset } from "./changeset-UCZdSRDv.mjs";
+import { c as ot, d as yt, i as _t, l as pt, o as gt, r as Ot, s as mt, t as unwrap, u as wt } from "./clack-CDRCHrC-.mjs";
+import { n as slugify, t as randomName } from "./names-Ck8cun7B.mjs";
+import { resolve } from "node:path";
+//#region src/commands/add.ts
+var import_picocolors = /* @__PURE__ */ __toESM(require_picocolors(), 1);
+const BUMP_CHOICES = [
+	{
+		label: "patch",
+		value: "patch"
+	},
+	{
+		label: "minor",
+		value: "minor"
+	},
+	{
+		label: "major",
+		value: "major"
+	},
+	{
+		label: "patch (isolated)",
+		value: "patch-isolated",
+		hint: "no cascade"
+	},
+	{
+		label: "minor (isolated)",
+		value: "minor-isolated",
+		hint: "no cascade"
+	}
+];
+const CASCADE_CHOICES = [
+	{
+		label: "patch",
+		value: "patch"
+	},
+	{
+		label: "minor",
+		value: "minor"
+	},
+	{
+		label: "major",
+		value: "major"
+	}
+];
+async function addCommand(rootDir, opts) {
+	const config = await loadConfig(rootDir);
+	const bumpyDir = getBumpyDir(rootDir);
+	await ensureDir(bumpyDir);
+	if (opts.empty) {
+		const filename = opts.name ? slugify(opts.name) : randomName();
+		const filePath = resolve(bumpyDir, `${filename}.md`);
+		const { writeText } = await import("./fs-0AtnPUUe.mjs").then((n) => n.r);
+		await writeText(filePath, "---\n---\n");
+		log.success(`Created empty changeset: .bumpy/${filename}.md`);
+		return;
+	}
+	let releases;
+	let summary;
+	let filename;
+	if (opts.packages) {
+		releases = parsePackagesFlag(opts.packages);
+		summary = opts.message || "";
+		filename = opts.name ? slugify(opts.name) : randomName();
+	} else {
+		mt(import_picocolors.default.bgCyan(import_picocolors.default.black(" bumpy add ")));
+		const pkgs = await discoverPackages(rootDir, config);
+		const depGraph = new DependencyGraph(pkgs);
+		if (pkgs.size === 0) {
+			pt("No managed packages found in this workspace.");
+			process.exit(1);
+		}
+		const selected = unwrap(await yt({
+			message: "Which packages should be included in this changeset?",
+			options: [...pkgs.values()].map((pkg) => ({
+				label: pkg.name,
+				value: pkg.name,
+				hint: pkg.version
+			})),
+			required: true
+		}));
+		releases = [];
+		for (const name of selected) {
+			const bumpType = unwrap(await _t({
+				message: `Bump type for ${import_picocolors.default.cyan(name)}`,
+				options: BUMP_CHOICES
+			}));
+			const release = {
+				name,
+				type: bumpType
+			};
+			if (!bumpType.endsWith("-isolated")) {
+				const dependents = depGraph.getDependents(name);
+				const cascadeTargets = pkgs.get(name).bumpy?.cascadeTo;
+				if (dependents.length > 0 || cascadeTargets) {
+					if (unwrap(await ot({
+						message: `${import_picocolors.default.cyan(name)} has ${import_picocolors.default.bold(String(dependents.length))} dependents. Specify explicit cascades?`,
+						initialValue: false
+					}))) {
+						const allTargets = /* @__PURE__ */ new Set();
+						for (const d of dependents) allTargets.add(d.name);
+						if (cascadeTargets) {
+							for (const pattern of Object.keys(cascadeTargets)) for (const [pName] of pkgs) if (matchGlob(pName, pattern)) allTargets.add(pName);
+						}
+						const cascadeSelected = unwrap(await yt({
+							message: "Which packages should cascade?",
+							options: [...allTargets].map((n) => ({
+								label: n,
+								value: n
+							})),
+							required: false
+						}));
+						if (cascadeSelected.length > 0) {
+							const cascadeBump = unwrap(await _t({
+								message: "Cascade bump type",
+								options: CASCADE_CHOICES
+							}));
+							const cascade = {};
+							for (const target of cascadeSelected) cascade[target] = cascadeBump;
+							release.cascade = cascade;
+						}
+					}
+				}
+			}
+			releases.push(release);
+		}
+		summary = unwrap(await Ot({
+			message: "Summary (what changed and why)",
+			placeholder: "A short description of the change",
+			validate: (value) => {
+				if (!value || !value.trim()) return "Summary is required";
+			}
+		}));
+		const defaultName = randomName();
+		filename = slugify(unwrap(await Ot({
+			message: "Changeset name",
+			placeholder: defaultName,
+			defaultValue: defaultName,
+			validate: (value) => {
+				if (!value) return void 0;
+				if (!slugify(value)) return "Name must contain at least one alphanumeric character";
+			}
+		}))) || defaultName;
+	}
+	if (await exists(resolve(bumpyDir, `${filename}.md`))) filename = `${filename}-${Date.now()}`;
+	await writeChangeset(rootDir, filename, releases, summary);
+	if (opts.packages) {
+		log.success(`Created changeset: .bumpy/${filename}.md`);
+		for (const r of releases) log.dim(`  ${r.name}: ${r.type}${formatCascade(r)}`);
+	} else {
+		wt(releases.map((r) => `${import_picocolors.default.cyan(r.name)} ${import_picocolors.default.dim("→")} ${import_picocolors.default.bold(r.type)}${formatCascade(r)}`).join("\n"), "Changeset");
+		gt(import_picocolors.default.green(`Created .bumpy/${filename}.md`));
+	}
+}
+function formatCascade(r) {
+	if (!("cascade" in r) || Object.keys(r.cascade).length === 0) return "";
+	const parts = Object.entries(r.cascade).map(([k, v]) => `${k}:${v}`);
+	return import_picocolors.default.dim(` (cascade: ${parts.join(", ")})`);
+}
+function parsePackagesFlag(input) {
+	return input.split(",").map((entry) => {
+		const [name, type] = entry.trim().split(":");
+		if (!name || !type) throw new Error(`Invalid package format: "${entry}". Expected "name:bumpType"`);
+		return {
+			name: name.trim(),
+			type: type.trim()
+		};
+	});
+}
+//#endregion
+export { addCommand };

package/dist/ai-CQhUyHAG.mjs

@@ -0,0 +1,82 @@
+import { n as log } from "./logger-C2dEe5Su.mjs";
+import { l as writeText, n as exists, t as ensureDir } from "./fs-0AtnPUUe.mjs";
+import { dirname, resolve } from "node:path";
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+//#region src/commands/ai.ts
+const SUPPORTED_TARGETS = [
+	"opencode",
+	"cursor",
+	"codex"
+];
+async function aiSetupCommand(rootDir, opts) {
+	const target = opts.target;
+	if (!target) {
+		log.error(`Please specify a target: bumpy ai setup --target <${SUPPORTED_TARGETS.join("|")}>`);
+		log.dim("  Claude Code users: install the plugin instead — claude plugin install @varlock/bumpy");
+		process.exit(1);
+	}
+	if (!SUPPORTED_TARGETS.includes(target)) {
+		log.error(`Unknown target: "${target}". Supported: ${SUPPORTED_TARGETS.join(", ")}`);
+		process.exit(1);
+	}
+	const promptContent = await loadPromptTemplate();
+	switch (target) {
+		case "opencode":
+			await setupOpenCode(rootDir, promptContent);
+			break;
+		case "cursor":
+			await setupCursor(rootDir, promptContent);
+			break;
+		case "codex":
+			await setupCodex(rootDir, promptContent);
+			break;
+	}
+}
+async function loadPromptTemplate() {
+	return (await readFile(resolve(dirname(fileURLToPath(import.meta.url)), "../../skills/add-change/SKILL.md"), "utf-8")).replace(/^---\n[\s\S]*?\n---\n\n?/, "");
+}
+/** Install as an OpenCode custom command */
+async function setupOpenCode(rootDir, promptContent) {
+	const commandsDir = resolve(rootDir, ".opencode", "commands");
+	const targetPath = resolve(commandsDir, "add-bumpy-change.md");
+	await ensureDir(commandsDir);
+	if (await exists(targetPath)) log.warn(".opencode/commands/add-bumpy-change.md already exists — overwriting");
+	await writeText(targetPath, `---
+description: Create a bumpy changeset to track package version bumps
+---
+
+${promptContent}`);
+	log.success("Installed OpenCode command");
+	log.dim("  Created .opencode/commands/add-bumpy-change.md");
+	log.dim("  Usage: type /add-bumpy-change in OpenCode");
+}
+/** Install as a Cursor rule */
+async function setupCursor(rootDir, promptContent) {
+	const rulesDir = resolve(rootDir, ".cursor", "rules");
+	const targetPath = resolve(rulesDir, "add-bumpy-change.mdc");
+	await ensureDir(rulesDir);
+	if (await exists(targetPath)) log.warn(".cursor/rules/add-bumpy-change.mdc already exists — overwriting");
+	await writeText(targetPath, `---
+description: Create a bumpy changeset to track package version bumps
+globs:
+alwaysApply: false
+---
+
+${promptContent}`);
+	log.success("Installed Cursor rule");
+	log.dim("  Created .cursor/rules/add-bumpy-change.mdc");
+	log.dim("  The rule will be suggested when relevant, or you can reference it manually");
+}
+/** Install as a Codex instruction */
+async function setupCodex(rootDir, promptContent) {
+	const targetPath = resolve(rootDir, ".codex", "add-bumpy-change.md");
+	await ensureDir(resolve(rootDir, ".codex"));
+	if (await exists(targetPath)) log.warn(".codex/add-bumpy-change.md already exists — overwriting");
+	await writeText(targetPath, promptContent);
+	log.success("Installed Codex instruction");
+	log.dim("  Created .codex/add-bumpy-change.md");
+	log.dim("  Reference this file in your AGENTS.md or pass it as context");
+}
+//#endregion
+export { aiSetupCommand };

package/dist/apply-release-plan-D6TSrcwX.mjs

@@ -0,0 +1,137 @@
+import { n as log } from "./logger-C2dEe5Su.mjs";
+import { a as readJson, c as writeJson, l as writeText, n as exists, o as readText } from "./fs-0AtnPUUe.mjs";
+import { t as deleteChangesets } from "./changeset-UCZdSRDv.mjs";
+import { resolve } from "node:path";
+//#region src/core/changelog.ts
+/** Default formatter — version heading, date, bullet points */
+const defaultFormatter = (ctx) => {
+	const { release, changesets, date } = ctx;
+	const lines = [];
+	lines.push(`## ${release.newVersion}`);
+	lines.push("");
+	lines.push(`_${date}_`);
+	lines.push("");
+	const relevantChangesets = changesets.filter((cs) => release.changesets.includes(cs.id));
+	if (relevantChangesets.length > 0) {
+		for (const cs of relevantChangesets) if (cs.summary) {
+			const summaryLines = cs.summary.split("\n");
+			lines.push(`- ${summaryLines[0]}`);
+			for (let i = 1; i < summaryLines.length; i++) if (summaryLines[i].trim()) lines.push(`  ${summaryLines[i]}`);
+		}
+	}
+	if (release.isDependencyBump && relevantChangesets.length === 0) lines.push("- Updated dependencies");
+	if (release.isCascadeBump && !release.isDependencyBump && relevantChangesets.length === 0) lines.push("- Version bump via cascade rule");
+	lines.push("");
+	return lines.join("\n");
+};
+const BUILTIN_FORMATTERS = {
+	default: defaultFormatter,
+	github: async () => {
+		const { createGithubFormatter } = await import("./changelog-github-Du62krXi.mjs");
+		return createGithubFormatter();
+	}
+};
+/**
+* Load a changelog formatter from config.
+* Supports: "default", "./path/to/formatter.ts", or a module name.
+*/
+async function loadFormatter(changelog, rootDir) {
+	const [name, options] = Array.isArray(changelog) ? changelog : [changelog, {}];
+	if (typeof name === "string" && BUILTIN_FORMATTERS[name]) {
+		const builtin = BUILTIN_FORMATTERS[name];
+		if (typeof builtin === "function" && builtin.length === 0) return builtin();
+		return builtin;
+	}
+	if (name === "github") {
+		const { createGithubFormatter } = await import("./changelog-github-Du62krXi.mjs");
+		return createGithubFormatter(options);
+	}
+	if (typeof name === "string") try {
+		let modulePath;
+		if (name.startsWith(".")) {
+			modulePath = resolve(rootDir, name);
+			if (!modulePath.startsWith(rootDir + "/")) throw new Error(`Changelog formatter path "${name}" resolves outside the project root`);
+		} else modulePath = name;
+		const mod = await import(modulePath);
+		const exported = mod.default || mod.changelogFormatter;
+		if (typeof exported === "function") {
+			const result = exported(options);
+			if (typeof result === "function") return result;
+			return exported;
+		}
+		throw new Error(`Changelog module "${name}" does not export a function`);
+	} catch (err) {
+		log.warn(`Failed to load changelog formatter "${name}": ${err instanceof Error ? err.message : err}`);
+		log.warn("Falling back to default formatter");
+		return defaultFormatter;
+	}
+	return defaultFormatter;
+}
+/** Generate a changelog entry using the configured formatter */
+async function generateChangelogEntry(release, changesets, formatter = defaultFormatter, date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0]) {
+	return formatter({
+		release,
+		changesets,
+		date
+	});
+}
+/** Prepend a new entry to an existing CHANGELOG.md content */
+function prependToChangelog(existingContent, newEntry) {
+	const headerMatch = existingContent.match(/^# /m);
+	if (headerMatch && headerMatch.index !== void 0) {
+		const afterTitle = existingContent.indexOf("\n##");
+		if (afterTitle !== -1) return existingContent.slice(0, afterTitle + 1) + "\n" + newEntry + existingContent.slice(afterTitle + 1);
+		return existingContent.trimEnd() + "\n\n" + newEntry;
+	}
+	return "# Changelog\n\n" + newEntry;
+}
+//#endregion
+//#region src/core/apply-release-plan.ts
+/** Apply the release plan: bump versions, update changelogs, delete changesets */
+async function applyReleasePlan(releasePlan, packages, rootDir, config) {
+	const releaseMap = new Map(releasePlan.releases.map((r) => [r.name, r]));
+	const formatter = await loadFormatter(config.changelog, rootDir);
+	for (const release of releasePlan.releases) {
+		const pkgJsonPath = resolve(packages.get(release.name).dir, "package.json");
+		const pkgJson = await readJson(pkgJsonPath);
+		pkgJson.version = release.newVersion;
+		for (const depField of [
+			"dependencies",
+			"devDependencies",
+			"peerDependencies",
+			"optionalDependencies"
+		]) {
+			const deps = pkgJson[depField];
+			if (!deps) continue;
+			for (const [depName, range] of Object.entries(deps)) {
+				const depRelease = releaseMap.get(depName);
+				if (!depRelease) continue;
+				deps[depName] = updateRange(range, depRelease.newVersion);
+			}
+		}
+		await writeJson(pkgJsonPath, pkgJson);
+	}
+	for (const release of releasePlan.releases) {
+		const changelogPath = resolve(packages.get(release.name).dir, "CHANGELOG.md");
+		const entry = await generateChangelogEntry(release, releasePlan.changesets, formatter);
+		let existingContent = "";
+		if (await exists(changelogPath)) existingContent = await readText(changelogPath);
+		await writeText(changelogPath, prependToChangelog(existingContent, entry));
+	}
+	await deleteChangesets(rootDir, releasePlan.changesets.map((cs) => cs.id));
+}
+/** Update a version range to include a new version, preserving the range prefix */
+function updateRange(range, newVersion) {
+	let protocol = "";
+	let cleanRange = range;
+	const protoMatch = range.match(/^(workspace:|catalog:)/);
+	if (protoMatch) {
+		protocol = protoMatch[1];
+		cleanRange = range.slice(protocol.length);
+	}
+	const prefix = cleanRange.match(/^(\^|~|>=|>|<=|<|=)?/)?.[1] ?? "^";
+	if (cleanRange === "*" || cleanRange === "") return range;
+	return `${protocol}${prefix}${newVersion}`;
+}
+//#endregion
+export { prependToChangelog as a, loadFormatter as i, defaultFormatter as n, generateChangelogEntry as r, applyReleasePlan as t };

package/dist/changelog-github-Du62krXi.mjs

@@ -0,0 +1,193 @@
+import { o as tryRunArgs } from "./shell-Dj7JRD_q.mjs";
+//#region src/core/changelog-github.ts
+/**
+* GitHub-enhanced changelog formatter.
+* Adds PR links, commit links, and contributor attribution when git/gh info is available.
+*
+* Usage in config:
+*   "changelog": "github"
+*   "changelog": ["github", { "repo": "dmno-dev/bumpy" }]
+*   "changelog": ["github", { "repo": "dmno-dev/bumpy", "internalAuthors": ["theoephraim"] }]
+*/
+function createGithubFormatter(options = {}) {
+	const internalAuthorsSet = new Set((options.internalAuthors ?? []).map((a) => a.toLowerCase()));
+	return async (ctx) => {
+		const { release, changesets, date } = ctx;
+		const repoSlug = options.repo ?? detectRepo();
+		const serverUrl = process.env.GITHUB_SERVER_URL || "https://github.com";
+		const lines = [];
+		lines.push(`## ${release.newVersion}`);
+		lines.push("");
+		lines.push(`_${date}_`);
+		lines.push("");
+		const relevantChangesets = changesets.filter((cs) => release.changesets.includes(cs.id));
+		if (relevantChangesets.length > 0) for (const cs of relevantChangesets) {
+			if (!cs.summary) continue;
+			const { cleanSummary, overrides } = extractSummaryMeta(cs.summary);
+			const gitInfo = resolveChangesetInfo(cs.id, repoSlug, serverUrl, overrides);
+			const summaryLines = cleanSummary.split("\n");
+			const firstLine = linkifyIssueRefs(summaryLines[0], serverUrl, repoSlug);
+			const prefix = formatPrefix(gitInfo, serverUrl, repoSlug, internalAuthorsSet);
+			lines.push(`-${prefix ? ` ${prefix} -` : ""} ${firstLine}`);
+			for (let i = 1; i < summaryLines.length; i++) if (summaryLines[i].trim()) lines.push(`  ${linkifyIssueRefs(summaryLines[i], serverUrl, repoSlug)}`);
+		}
+		if (release.isDependencyBump && relevantChangesets.length === 0) lines.push("- Updated dependencies");
+		if (release.isCascadeBump && !release.isDependencyBump && relevantChangesets.length === 0) lines.push("- Version bump via cascade rule");
+		lines.push("");
+		return lines.join("\n");
+	};
+}
+/**
+* Extract metadata lines (pr, commit, author) from a changeset summary.
+* These override git-derived info, matching the behavior of @changesets/changelog-github.
+*/
+function extractSummaryMeta(summary) {
+	const overrides = {};
+	return {
+		cleanSummary: summary.replace(/^\s*(?:pr|pull|pull\s+request):\s*#?(\d+)/im, (_, pr) => {
+			const num = Number(pr);
+			if (!isNaN(num)) overrides.pr = num;
+			return "";
+		}).replace(/^\s*commit:\s*([^\s]+)/im, (_, commit) => {
+			overrides.commit = commit;
+			return "";
+		}).replace(/^\s*(?:author|user):\s*@?([^\s]+)/gim, (_, user) => {
+			overrides.authors ??= [];
+			overrides.authors.push(user);
+			return "";
+		}).trim(),
+		overrides
+	};
+}
+/**
+* Resolve PR, commit, and author info for a changeset.
+* Summary overrides take precedence over git-derived info.
+*/
+function resolveChangesetInfo(changesetId, repo, serverUrl, overrides) {
+	if (overrides.pr !== void 0) {
+		const prInfo = lookupPr(overrides.pr, repo);
+		return {
+			prNumber: overrides.pr,
+			prUrl: prInfo?.url ?? `${serverUrl}/${repo}/pull/${overrides.pr}`,
+			commitHash: overrides.commit ?? prInfo?.commitHash,
+			author: overrides.authors?.[0] ?? prInfo?.author
+		};
+	}
+	const gitInfo = findChangesetCommitInfo(changesetId, repo);
+	return {
+		prNumber: gitInfo?.prNumber,
+		prUrl: gitInfo?.prUrl,
+		commitHash: overrides.commit ?? gitInfo?.commitHash,
+		author: overrides.authors?.[0] ?? gitInfo?.author
+	};
+}
+/** Look up a PR by number using gh CLI */
+function lookupPr(prNumber, repo) {
+	try {
+		const ghArgs = [
+			"gh",
+			"pr",
+			"view",
+			String(prNumber),
+			"--json",
+			"url,author,mergeCommit"
+		];
+		if (repo) ghArgs.push("--repo", repo);
+		const result = tryRunArgs(ghArgs);
+		if (!result) return null;
+		const pr = JSON.parse(result);
+		return {
+			url: pr.url,
+			author: pr.author?.login,
+			commitHash: pr.mergeCommit?.oid
+		};
+	} catch {
+		return null;
+	}
+}
+/**
+* Find the PR that introduced a changeset file by checking git log
+* for the commit that added the file, then looking up the PR.
+*/
+function findChangesetCommitInfo(changesetId, repo) {
+	try {
+		const commitOutput = tryRunArgs([
+			"git",
+			"log",
+			"--diff-filter=A",
+			"--format=%H",
+			"--",
+			`.bumpy/${changesetId}.md`,
+			`.changeset/${changesetId}.md`
+		]);
+		if (!commitOutput) return null;
+		const commitHash = commitOutput.split("\n")[0].trim();
+		if (!commitHash) return null;
+		const ghArgs = [
+			"gh",
+			"pr",
+			"list",
+			"--search",
+			commitHash,
+			"--state",
+			"merged",
+			"--json",
+			"number,url,author",
+			"--jq",
+			".[0]"
+		];
+		if (repo) ghArgs.push("--repo", repo);
+		const prJson = tryRunArgs(ghArgs);
+		if (!prJson) return { commitHash };
+		const pr = JSON.parse(prJson);
+		if (!pr.number) return { commitHash };
+		return {
+			prNumber: pr.number,
+			prUrl: pr.url,
+			commitHash,
+			author: pr.author?.login
+		};
+	} catch {
+		return null;
+	}
+}
+/**
+* Build the prefix portion of a changelog line: PR link, commit link, thanks.
+* Matches the format used by @changesets/changelog-github.
+*/
+function formatPrefix(info, serverUrl, repo, internalAuthors) {
+	const parts = [];
+	if (info.prNumber && info.prUrl) parts.push(`[#${info.prNumber}](${info.prUrl})`);
+	if (info.commitHash && repo) {
+		const short = info.commitHash.slice(0, 7);
+		parts.push(`[\`${short}\`](${serverUrl}/${repo}/commit/${info.commitHash})`);
+	}
+	if (info.author && !internalAuthors.has(info.author.toLowerCase())) parts.push(`Thanks [@${info.author}](${serverUrl}/${info.author})!`);
+	return parts.join(" ");
+}
+/**
+* Linkify bare issue/PR references like #123 in text,
+* but skip references already inside markdown links.
+*/
+function linkifyIssueRefs(line, serverUrl, repo) {
+	if (!repo) return line;
+	return line.replace(/\[.*?\]\(.*?\)|\B#([1-9]\d*)\b/g, (match, issue) => issue ? `[#${issue}](${serverUrl}/${repo}/issues/${issue})` : match);
+}
+/** Try to detect the repo slug from the gh CLI */
+function detectRepo() {
+	try {
+		return tryRunArgs([
+			"gh",
+			"repo",
+			"view",
+			"--json",
+			"nameWithOwner",
+			"--jq",
+			".nameWithOwner"
+		])?.trim() || void 0;
+	} catch {
+		return;
+	}
+}
+//#endregion
+export { createGithubFormatter };