@bensandee/tooling 0.4.0 → 0.5.1

package/dist/bin.mjs

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 import { defineCommand, runMain } from "citty";
 import * as p from "@clack/prompts";
+import { execSync } from "node:child_process";
 import path from "node:path";
-import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
 import { parse } from "jsonc-parser";
 import { z } from "zod";
-import { execSync } from "node:child_process";
 
 //#region src/types.ts
 /** Default CI platform when not explicitly chosen. */
@@ -41,7 +41,7 @@ const TsconfigSchema = z.object({
 	include: z.array(z.string()).optional(),
 	exclude: z.array(z.string()).optional(),
 	files: z.array(z.string()).optional(),
-	references: z.array(z.object({ path: z.string() })).optional(),
+	references: z.array(z.object({ path: z.string() }).passthrough()).optional(),
 	compilerOptions: z.record(z.string(), z.unknown()).optional()
 }).loose();
 const RenovateSchema = z.object({
@@ -395,17 +395,35 @@ function writeFile(targetDir, relativePath, content) {
 }
 /**
 * Create a GeneratorContext from a ProjectConfig and a conflict resolution handler.
+* Returns the context and a list of files that were auto-archived before overwriting.
 */
 function createContext(config, confirmOverwrite) {
+	const archivedFiles = [];
 	const pkgRaw = readFile(config.targetDir, "package.json");
 	return {
-		config,
-		targetDir: config.targetDir,
-		packageJson: pkgRaw ? parsePackageJson(pkgRaw) : void 0,
-		exists: (rel) => fileExists(config.targetDir, rel),
-		read: (rel) => readFile(config.targetDir, rel),
-		write: (rel, content) => writeFile(config.targetDir, rel, content),
-		confirmOverwrite
+		ctx: {
+			config,
+			targetDir: config.targetDir,
+			packageJson: pkgRaw ? parsePackageJson(pkgRaw) : void 0,
+			exists: (rel) => fileExists(config.targetDir, rel),
+			read: (rel) => readFile(config.targetDir, rel),
+			write: (rel, content) => {
+				if (!rel.startsWith(".tooling-archived/")) {
+					const existing = readFile(config.targetDir, rel);
+					if (existing !== void 0 && existing !== content) {
+						writeFile(config.targetDir, `.tooling-archived/${rel}`, existing);
+						archivedFiles.push(rel);
+					}
+				}
+				writeFile(config.targetDir, rel, content);
+			},
+			remove: (rel) => {
+				const fullPath = path.join(config.targetDir, rel);
+				if (existsSync(fullPath)) rmSync(fullPath);
+			},
+			confirmOverwrite
+		},
+		archivedFiles
 	};
 }
 
@@ -419,7 +437,7 @@ const STANDARD_SCRIPTS_SINGLE = {
 	lint: "oxlint",
 	knip: "knip",
 	check: "pnpm typecheck && pnpm build && pnpm lint && pnpm knip",
-	prepare: "husky"
+	prepare: "lefthook install"
 };
 const STANDARD_SCRIPTS_MONOREPO = {
 	build: "pnpm -r build",
@@ -428,7 +446,7 @@ const STANDARD_SCRIPTS_MONOREPO = {
 	lint: "oxlint",
 	knip: "knip",
 	check: "pnpm typecheck && pnpm build && pnpm lint && pnpm knip",
-	prepare: "husky"
+	prepare: "lefthook install"
 };
 /** DevDeps that belong in every project (single repo) or per-package (monorepo). */
 const PER_PACKAGE_DEV_DEPS = {
@@ -439,9 +457,8 @@ const PER_PACKAGE_DEV_DEPS = {
 };
 /** DevDeps that belong at the root regardless of structure. */
 const ROOT_DEV_DEPS = {
-	husky: "9.1.7",
 	knip: "5.85.0",
-	"lint-staged": "16.3.1",
+	lefthook: "2.1.2",
 	oxlint: "1.50.0"
 };
 /**
@@ -590,6 +607,7 @@ function generateMigratePrompt(results, config, detected) {
 	const created = results.filter((r) => r.action === "created");
 	const updated = results.filter((r) => r.action === "updated");
 	const skipped = results.filter((r) => r.action === "skipped");
+	const archived = results.filter((r) => r.action === "archived");
 	if (created.length > 0) {
 		sections.push("**Created:**");
 		for (const r of created) sections.push(`- \`${r.filePath}\` — ${r.description}`);
@@ -600,6 +618,11 @@ function generateMigratePrompt(results, config, detected) {
 		for (const r of updated) sections.push(`- \`${r.filePath}\` — ${r.description}`);
 		sections.push("");
 	}
+	if (archived.length > 0) {
+		sections.push("**Archived:**");
+		for (const r of archived) sections.push(`- \`${r.filePath}\` — ${r.description}`);
+		sections.push("");
+	}
 	if (skipped.length > 0) {
 		sections.push("**Skipped (review these):**");
 		for (const r of skipped) sections.push(`- \`${r.filePath}\` — ${r.description}`);
@@ -626,6 +649,25 @@ function generateMigratePrompt(results, config, detected) {
 		}
 		sections.push("");
 	}
+	if (archived.length > 0) {
+		sections.push("### Review archived files");
+		sections.push("");
+		sections.push("The following files were modified or replaced. The originals have been saved to `.tooling-archived/`:");
+		sections.push("");
+		for (const r of archived) sections.push(`- \`${r.filePath}\` → \`.tooling-archived/${r.filePath}\``);
+		sections.push("");
+		sections.push("For each archived file, **diff the old version against the new one** and look for features, categories, or modules that were enabled in the original but are missing from the replacement. Focus on broad capability gaps rather than individual rule strictness (in general, being stricter is fine). Examples of what to look for:");
+		sections.push("");
+		sections.push("- **Lint configs**: enabled plugin categories (e.g. `jsx-a11y`, `import`, `react`, `nextjs`), custom `plugins` or `overrides`, file-scoped rule blocks");
+		sections.push("- **TypeScript configs**: compiler features like `jsx`, `paths`, `baseUrl`, or `references` that affect build behavior");
+		sections.push("- **Other configs**: feature flags, custom presets, or integrations that go beyond the default template");
+		sections.push("");
+		sections.push("If the old config had capabilities the new one lacks, port them into the new file. Then:");
+		sections.push("");
+		sections.push("1. If the project previously used `husky` and `lint-staged`, remove them from `devDependencies`");
+		sections.push("2. Delete the `.tooling-archived/` directory when migration is complete");
+		sections.push("");
+	}
 	const oxlintWasSkipped = results.find((r) => r.filePath === "oxlint.config.ts")?.action === "skipped";
 	if (detected.hasLegacyOxlintJson) {
 		sections.push("### Migrate .oxlintrc.json to oxlint.config.ts");
@@ -1032,7 +1074,8 @@ const STANDARD_ENTRIES = [
 	".env",
 	".env.*",
 	"!.env.example",
-	".tooling-migrate.md"
+	".tooling-migrate.md",
+	".tooling-archived/"
 ];
 /** Normalize a gitignore entry for comparison: strip leading `/` and trailing `/`. */
 function normalizeEntry(entry) {
@@ -1306,6 +1349,8 @@ function buildSettings(ctx) {
 		`Bash(${pm} view *)`,
 		`Bash(${pm} list)`,
 		`Bash(${pm} list *)`,
+		`Bash(${pm} ls)`,
+		`Bash(${pm} ls *)`,
 		"Bash(npm view *)",
 		"Bash(npm info *)",
 		"Bash(npm show *)",
@@ -1345,6 +1390,8 @@ function buildSettings(ctx) {
 		"Bash(head *)",
 		"Bash(tail *)",
 		"Bash(wc *)",
+		"Bash(test *)",
+		"Bash([ *)",
 		"Bash(find *)",
 		"Bash(which *)",
 		"Bash(node -e *)",
@@ -1677,12 +1724,30 @@ async function generateReleaseCi(ctx) {
 }
 
 //#endregion
-//#region src/generators/lint-staged.ts
+//#region src/generators/lefthook.ts
 function buildConfig(formatter) {
-	return `export default {\n  "*": "${formatter === "prettier" ? "prettier --write" : "oxfmt --no-error-on-unmatched-pattern"}",\n};\n`;
-}
-const HUSKY_PRE_COMMIT = "pnpm exec lint-staged\n";
-/** All known lint-staged config file locations, in priority order. */
+	return [
+		"pre-commit:",
+		"  commands:",
+		"    lint:",
+		"      run: pnpm exec oxlint {staged_files}",
+		"    format:",
+		`      run: ${formatter === "prettier" ? "pnpm exec prettier --write {staged_files}" : "pnpm exec oxfmt --no-error-on-unmatched-pattern {staged_files}"}`,
+		"      stage_fixed: true",
+		""
+	].join("\n");
+}
+const ARCHIVE_DIR = ".tooling-archived";
+/** Common client-side git hooks that husky may have configured. */
+const HUSKY_HOOK_NAMES = [
+	"pre-commit",
+	"commit-msg",
+	"pre-push",
+	"post-merge",
+	"post-checkout",
+	"prepare-commit-msg"
+];
+/** All known lint-staged config file locations to archive. */
 const LINT_STAGED_CONFIG_PATHS = [
 	"lint-staged.config.mjs",
 	"lint-staged.config.js",
@@ -1694,37 +1759,117 @@ const LINT_STAGED_CONFIG_PATHS = [
 	".lintstagedrc.mjs",
 	".lintstagedrc.cjs"
 ];
-async function generateLintStaged(ctx) {
-	const filePath = "lint-staged.config.mjs";
-	const huskyPath = ".husky/pre-commit";
+/** All known lefthook config file locations, in priority order. */
+const LEFTHOOK_CONFIG_PATHS = ["lefthook.yml", ".lefthook.yml"];
+/** Archive all husky hook files found in .husky/ */
+function archiveHuskyHooks(ctx, results) {
+	let found = false;
+	for (const hook of HUSKY_HOOK_NAMES) {
+		const huskyPath = `.husky/${hook}`;
+		const existing = ctx.read(huskyPath);
+		if (existing !== void 0) {
+			ctx.write(`${ARCHIVE_DIR}/${huskyPath}`, existing);
+			ctx.remove(huskyPath);
+			results.push({
+				filePath: huskyPath,
+				action: "archived",
+				description: `Moved to ${ARCHIVE_DIR}/${huskyPath}`
+			});
+			found = true;
+		}
+	}
+	return found;
+}
+/** Archive all lint-staged config files. */
+function archiveLintStagedConfigs(ctx, results) {
+	let found = false;
+	for (const lsPath of LINT_STAGED_CONFIG_PATHS) {
+		const existing = ctx.read(lsPath);
+		if (existing !== void 0) {
+			ctx.write(`${ARCHIVE_DIR}/${lsPath}`, existing);
+			ctx.remove(lsPath);
+			results.push({
+				filePath: lsPath,
+				action: "archived",
+				description: `Moved to ${ARCHIVE_DIR}/${lsPath}`
+			});
+			found = true;
+		}
+	}
+	return found;
+}
+/** Remove husky/lint-staged from package.json devDependencies and fix prepare script. */
+function cleanPackageJson(ctx, results) {
+	const raw = ctx.read("package.json");
+	if (!raw) return;
+	const pkg = parsePackageJson(raw);
+	if (!pkg) return;
+	const changes = [];
+	if (pkg.devDependencies) {
+		if ("husky" in pkg.devDependencies) {
+			delete pkg.devDependencies["husky"];
+			changes.push("removed devDependency: husky");
+		}
+		if ("lint-staged" in pkg.devDependencies) {
+			delete pkg.devDependencies["lint-staged"];
+			changes.push("removed devDependency: lint-staged");
+		}
+	}
+	if (pkg.scripts?.["prepare"] && /\bhusky\b/.test(pkg.scripts["prepare"])) {
+		pkg.scripts["prepare"] = "lefthook install";
+		changes.push("replaced prepare script: husky → lefthook install");
+	}
+	if (changes.length === 0) return;
+	ctx.write("package.json", JSON.stringify(pkg, null, 2) + "\n");
+	results.push({
+		filePath: "package.json",
+		action: "updated",
+		description: changes.join(", ")
+	});
+}
+async function generateLefthook(ctx) {
+	const filePath = "lefthook.yml";
 	const content = buildConfig(ctx.config.formatter);
-	if (ctx.read(huskyPath) !== HUSKY_PRE_COMMIT) ctx.write(huskyPath, HUSKY_PRE_COMMIT);
-	const existingPath = LINT_STAGED_CONFIG_PATHS.find((p) => ctx.exists(p));
+	const results = [];
+	archiveHuskyHooks(ctx, results);
+	archiveLintStagedConfigs(ctx, results);
+	cleanPackageJson(ctx, results);
+	const existingPath = LEFTHOOK_CONFIG_PATHS.find((p) => ctx.exists(p));
 	if (existingPath === filePath) {
 		const existing = ctx.read(filePath);
 		if (existing) {
-			if (existing === content) return {
-				filePath,
-				action: "skipped",
-				description: "Already configured"
-			};
-			if (await ctx.confirmOverwrite(filePath) === "skip") return {
-				filePath,
-				action: "skipped",
-				description: "Existing lint-staged config preserved"
-			};
+			if (existing === content) {
+				results.push({
+					filePath,
+					action: "skipped",
+					description: "Already configured"
+				});
+				return results;
+			}
+			if (await ctx.confirmOverwrite(filePath) === "skip") {
+				results.push({
+					filePath,
+					action: "skipped",
+					description: "Existing lefthook config preserved"
+				});
+				return results;
+			}
 		}
-	} else if (existingPath) return {
-		filePath: existingPath,
-		action: "skipped",
-		description: `Existing config found at ${existingPath}`
-	};
+	} else if (existingPath) {
+		results.push({
+			filePath: existingPath,
+			action: "skipped",
+			description: `Existing config found at ${existingPath}`
+		});
+		return results;
+	}
 	ctx.write(filePath, content);
-	return {
+	results.push({
 		filePath,
 		action: existingPath === filePath ? "updated" : "created",
-		description: "Generated lint-staged config and husky pre-commit hook"
-	};
+		description: "Generated lefthook pre-commit config"
+	});
+	return results;
 }
 
 //#endregion
@@ -1768,7 +1913,7 @@ const initCommand = defineCommand({
 });
 async function runInit(config, options = {}) {
 	const detected = detectProject(config.targetDir);
-	const ctx = createContext(config, options.confirmOverwrite ?? (async (relativePath) => {
+	const { ctx, archivedFiles } = createContext(config, options.confirmOverwrite ?? (async (relativePath) => {
 		const result = await p.select({
 			message: `${relativePath} already exists. What do you want to do?`,
 			options: [{
@@ -1791,7 +1936,7 @@ async function runInit(config, options = {}) {
 	results.push(await generateTsdown(ctx));
 	results.push(await generateOxlint(ctx));
 	results.push(await generateFormatter(ctx));
-	results.push(await generateLintStaged(ctx));
+	results.push(...await generateLefthook(ctx));
 	results.push(await generateGitignore(ctx));
 	results.push(await generateKnip(ctx));
 	results.push(await generateRenovate(ctx));
@@ -1802,13 +1947,27 @@ async function runInit(config, options = {}) {
 	results.push(await generateReleaseCi(ctx));
 	const vitestResults = await generateVitest(ctx);
 	results.push(...vitestResults);
+	const alreadyArchived = new Set(results.filter((r) => r.action === "archived").map((r) => r.filePath));
+	for (const rel of archivedFiles) if (!alreadyArchived.has(rel)) results.push({
+		filePath: rel,
+		action: "archived",
+		description: `Original saved to .tooling-archived/${rel}`
+	});
 	s.stop("Done!");
+	if (results.some((r) => r.action === "archived" && r.filePath.startsWith(".husky/"))) try {
+		execSync("git config --unset core.hooksPath", {
+			cwd: config.targetDir,
+			stdio: "ignore"
+		});
+	} catch (_error) {}
 	const created = results.filter((r) => r.action === "created");
 	const updated = results.filter((r) => r.action === "updated");
 	const skipped = results.filter((r) => r.action === "skipped");
+	const archived = results.filter((r) => r.action === "archived");
 	const summaryLines = [];
 	if (created.length > 0) summaryLines.push(`Created: ${created.map((r) => r.filePath).join(", ")}`);
 	if (updated.length > 0) summaryLines.push(`Updated: ${updated.map((r) => r.filePath).join(", ")}`);
+	if (archived.length > 0) summaryLines.push(`Archived: ${archived.map((r) => r.filePath).join(", ")}`);
 	if (skipped.length > 0) summaryLines.push(`Skipped: ${skipped.map((r) => r.filePath).join(", ")}`);
 	p.note(summaryLines.join("\n"), "Summary");
 	if (!options.noPrompt) {
@@ -1948,10 +2107,6 @@ function createRealExecutor() {
 		}
 	};
 }
-/** Check whether there are pending changeset files. */
-function hasChangesets(executor, cwd) {
-	return executor.listChangesetFiles(cwd).length > 0;
-}
 /** Parse "New tag:" lines from changeset publish output. */
 function parseNewTags(output) {
 	const tags = [];
@@ -2033,6 +2188,22 @@ async function updatePr(executor, conn, prNumber, options) {
 	});
 	if (!res.ok) throw new TransientError(`Failed to update PR #${String(prNumber)}: ${res.status} ${res.statusText}`);
 }
+/** Merge a pull request by number. */
+async function mergePr(executor, conn, prNumber, options) {
+	const url = `${conn.serverUrl}/api/v1/repos/${conn.repository}/pulls/${String(prNumber)}/merge`;
+	const res = await executor.fetch(url, {
+		method: "POST",
+		headers: {
+			Authorization: `token ${conn.token}`,
+			"Content-Type": "application/json"
+		},
+		body: JSON.stringify({
+			Do: options?.method ?? "merge",
+			delete_branch_after_merge: options?.deleteBranch ?? true
+		})
+	});
+	if (!res.ok) throw new TransientError(`Failed to merge PR #${String(prNumber)}: ${res.status} ${res.statusText}`);
+}
 /** Check whether a Forgejo release already exists for a given tag. */
 async function findRelease(executor, conn, tag) {
 	const encodedTag = encodeURIComponent(tag);
@@ -2060,6 +2231,21 @@ async function createRelease(executor, conn, tag) {
 	if (!res.ok) throw new TransientError(`Failed to create release for ${tag}: ${res.status} ${res.statusText}`);
 }
 
+//#endregion
+//#region src/release/log.ts
+/** Log a debug message when verbose mode is enabled. */
+function debug(config, message) {
+	if (config.verbose) p.log.info(`[debug] ${message}`);
+}
+/** Log the result of an exec call when verbose mode is enabled. */
+function debugExec(config, label, result) {
+	if (!config.verbose) return;
+	const lines = [`[debug] ${label} (exit code ${String(result.exitCode)})`];
+	if (result.stdout.trim()) lines.push(`  stdout: ${result.stdout.trim()}`);
+	if (result.stderr.trim()) lines.push(`  stderr: ${result.stderr.trim()}`);
+	p.log.info(lines.join("\n"));
+}
+
 //#endregion
 //#region src/release/version.ts
 const BRANCH = "changeset-release/main";
@@ -2132,11 +2318,20 @@ function buildPrContent(executor, cwd, packagesBefore) {
 async function runVersionMode(executor, config) {
 	p.log.info("Changesets detected — versioning packages");
 	const packagesBefore = executor.listWorkspacePackages(config.cwd);
-	executor.exec("pnpm changeset version", { cwd: config.cwd });
-	executor.exec("pnpm install --no-frozen-lockfile", { cwd: config.cwd });
+	debug(config, `Packages before versioning: ${packagesBefore.map((pkg) => `${pkg.name}@${pkg.version}`).join(", ") || "(none)"}`);
+	const versionResult = executor.exec("pnpm changeset version", { cwd: config.cwd });
+	debugExec(config, "pnpm changeset version", versionResult);
+	if (versionResult.exitCode !== 0) throw new FatalError(`pnpm changeset version failed (exit code ${String(versionResult.exitCode)}):\n${versionResult.stderr}`);
+	debugExec(config, "pnpm install --no-frozen-lockfile", executor.exec("pnpm install --no-frozen-lockfile", { cwd: config.cwd }));
 	const { title, body } = buildPrContent(executor, config.cwd, packagesBefore);
+	debug(config, `PR title: ${title}`);
 	executor.exec("git add -A", { cwd: config.cwd });
-	if (executor.exec("git commit -m \"chore: version packages\"", { cwd: config.cwd }).exitCode !== 0) {
+	const remainingChangesets = executor.listChangesetFiles(config.cwd);
+	if (remainingChangesets.length > 0) p.log.warn(`Changeset files still present after versioning: ${remainingChangesets.join(", ")}`);
+	debug(config, `Changeset files after versioning: ${remainingChangesets.length > 0 ? remainingChangesets.join(", ") : "(none — all consumed)"}`);
+	const commitResult = executor.exec("git commit -m \"chore: version packages\"", { cwd: config.cwd });
+	debugExec(config, "git commit", commitResult);
+	if (commitResult.exitCode !== 0) {
 		p.log.info("Nothing to commit after versioning");
 		return {
 			mode: "version",
@@ -2150,13 +2345,14 @@ async function runVersionMode(executor, config) {
 			pr: "none"
 		};
 	}
-	executor.exec(`git push origin "HEAD:refs/heads/${BRANCH}" --force`, { cwd: config.cwd });
+	debugExec(config, "git push", executor.exec(`git push origin "HEAD:refs/heads/${BRANCH}" --force`, { cwd: config.cwd }));
 	const conn = {
 		serverUrl: config.serverUrl,
 		repository: config.repository,
 		token: config.token
 	};
 	const existingPr = await findOpenPr(executor, conn, BRANCH);
+	debug(config, `Existing open PR for ${BRANCH}: ${existingPr === null ? "(none)" : `#${String(existingPr)}`}`);
 	if (existingPr === null) {
 		await createPr(executor, conn, {
 			title,
@@ -2202,12 +2398,17 @@ async function retryAsync(fn) {
 async function runPublishMode(executor, config) {
 	p.log.info("No changesets — publishing packages");
 	const publishResult = executor.exec("pnpm changeset publish", { cwd: config.cwd });
+	debugExec(config, "pnpm changeset publish", publishResult);
 	if (publishResult.exitCode !== 0) throw new FatalError(`pnpm changeset publish failed (exit code ${String(publishResult.exitCode)}):\n${publishResult.stderr}`);
 	const stdoutTags = parseNewTags(publishResult.stdout + "\n" + publishResult.stderr);
+	debug(config, `Tags from publish stdout: ${stdoutTags.length > 0 ? stdoutTags.join(", ") : "(none)"}`);
 	const expectedTags = computeExpectedTags(executor.listWorkspacePackages(config.cwd));
+	debug(config, `Expected tags from workspace packages: ${expectedTags.length > 0 ? expectedTags.join(", ") : "(none)"}`);
 	const remoteTags = parseRemoteTags(executor.exec("git ls-remote --tags origin", { cwd: config.cwd }).stdout);
+	debug(config, `Remote tags: ${remoteTags.length > 0 ? remoteTags.join(", ") : "(none)"}`);
 	const remoteSet = new Set(remoteTags);
 	const tagsToPush = reconcileTags(expectedTags, remoteTags, stdoutTags);
+	debug(config, `Reconciled tags to push: ${tagsToPush.length > 0 ? tagsToPush.join(", ") : "(none)"}`);
 	if (config.dryRun) {
 		if (tagsToPush.length === 0) {
 			p.log.info("No packages were published");
@@ -2266,6 +2467,80 @@ async function runPublishMode(executor, config) {
 	};
 }
 
+//#endregion
+//#region src/release/connection.ts
+const RepositorySchema = z.union([z.string(), z.object({ url: z.string() })]);
+/**
+* Resolve the hosting platform and connection details.
+*
+* Priority:
+* 1. Environment variables (FORGEJO_SERVER_URL, FORGEJO_REPOSITORY, FORGEJO_TOKEN)
+* 2. `repository` field in package.json (server URL and owner/repo parsed from the URL)
+*
+* For Forgejo, FORGEJO_TOKEN is always required (either from env or explicitly).
+* If the repository URL hostname is `github.com`, returns `{ type: "github" }`.
+*/
+function resolveConnection(cwd) {
+	const serverUrl = process.env["FORGEJO_SERVER_URL"];
+	const repository = process.env["FORGEJO_REPOSITORY"];
+	const token = process.env["FORGEJO_TOKEN"];
+	if (serverUrl && repository && token) return {
+		type: "forgejo",
+		conn: {
+			serverUrl,
+			repository,
+			token
+		}
+	};
+	const parsed = parseRepositoryUrl(cwd);
+	if (parsed === null) {
+		if (serverUrl) {
+			if (!repository) throw new FatalError("FORGEJO_REPOSITORY environment variable is required");
+			if (!token) throw new FatalError("FORGEJO_TOKEN environment variable is required");
+		}
+		return { type: "github" };
+	}
+	if (parsed.hostname === "github.com") return { type: "github" };
+	const resolvedToken = token;
+	if (!resolvedToken) throw new FatalError("FORGEJO_TOKEN environment variable is required (server URL and repository were resolved from package.json)");
+	return {
+		type: "forgejo",
+		conn: {
+			serverUrl: serverUrl ?? `${parsed.protocol}//${parsed.hostname}`,
+			repository: repository ?? parsed.repository,
+			token: resolvedToken
+		}
+	};
+}
+function parseRepositoryUrl(cwd) {
+	const pkgPath = path.join(cwd, "package.json");
+	let raw;
+	try {
+		raw = readFileSync(pkgPath, "utf-8");
+	} catch {
+		return null;
+	}
+	const pkg = z.object({ repository: RepositorySchema.optional() }).safeParse(JSON.parse(raw));
+	if (!pkg.success) return null;
+	const repo = pkg.data.repository;
+	if (!repo) return null;
+	return parseGitUrl(typeof repo === "string" ? repo : repo.url);
+}
+function parseGitUrl(urlStr) {
+	try {
+		const url = new URL(urlStr);
+		const pathname = url.pathname.replace(/\.git$/, "").replace(/^\//, "");
+		if (!pathname.includes("/")) return null;
+		return {
+			protocol: url.protocol,
+			hostname: url.hostname,
+			repository: pathname
+		};
+	} catch {
+		return null;
+	}
+}
+
 //#endregion
 //#region src/commands/release-changesets.ts
 const releaseForgejoCommand = defineCommand({
@@ -2273,33 +2548,43 @@ const releaseForgejoCommand = defineCommand({
 		name: "release:changesets",
 		description: "Changesets version/publish for Forgejo CI"
 	},
-	args: { "dry-run": {
-		type: "boolean",
-		description: "Skip push, API calls, and publishing side effects"
-	} },
+	args: {
+		"dry-run": {
+			type: "boolean",
+			description: "Skip push, API calls, and publishing side effects"
+		},
+		verbose: {
+			type: "boolean",
+			description: "Enable detailed debug logging (also enabled by RELEASE_DEBUG env var)"
+		}
+	},
 	async run({ args }) {
-		if ((await runRelease(buildReleaseConfig({ dryRun: args["dry-run"] === true }), createRealExecutor())).mode === "none") process.exitCode = 0;
+		if ((await runRelease(buildReleaseConfig({
+			dryRun: args["dry-run"] === true,
+			verbose: args.verbose === true || process.env["RELEASE_DEBUG"] === "true"
+		}), createRealExecutor())).mode === "none") process.exitCode = 0;
 	}
 });
-/** Build release config from environment variables and CLI flags. */
+/** Build release config from environment / package.json and CLI flags. */
 function buildReleaseConfig(flags) {
-	const serverUrl = process.env["FORGEJO_SERVER_URL"];
-	const repository = process.env["FORGEJO_REPOSITORY"];
-	const token = process.env["FORGEJO_TOKEN"];
-	if (!serverUrl) throw new FatalError("FORGEJO_SERVER_URL environment variable is required");
-	if (!repository) throw new FatalError("FORGEJO_REPOSITORY environment variable is required");
-	if (!token) throw new FatalError("FORGEJO_TOKEN environment variable is required");
+	const resolved = resolveConnection(process.cwd());
+	if (resolved.type !== "forgejo") throw new FatalError("release:changesets requires a Forgejo repository");
 	return {
-		serverUrl,
-		repository,
-		token,
+		...resolved.conn,
 		cwd: process.cwd(),
-		dryRun: flags.dryRun ?? false
+		dryRun: flags.dryRun ?? false,
+		verbose: flags.verbose ?? false
 	};
 }
 /** Core release logic — testable with a mock executor. */
 async function runRelease(config, executor) {
-	if (hasChangesets(executor, config.cwd)) return runVersionMode(executor, config);
+	const changesetFiles = executor.listChangesetFiles(config.cwd);
+	debug(config, `Changeset files found: ${changesetFiles.length > 0 ? changesetFiles.join(", ") : "(none)"}`);
+	if (changesetFiles.length > 0) {
+		debug(config, "Entering version mode");
+		return runVersionMode(executor, config);
+	}
+	debug(config, "Entering publish mode");
 	return runPublishMode(executor, config);
 }
 
@@ -2317,21 +2602,17 @@ const releaseTriggerCommand = defineCommand({
 	} },
 	async run({ args }) {
 		const ref = args.ref ?? "main";
-		const serverUrl = process.env["FORGEJO_SERVER_URL"];
-		if (serverUrl) await triggerForgejo(serverUrl, ref);
+		const resolved = resolveConnection(process.cwd());
+		if (resolved.type === "forgejo") await triggerForgejo(resolved.conn, ref);
 		else triggerGitHub(ref);
 	}
 });
-async function triggerForgejo(serverUrl, ref) {
-	const repository = process.env["FORGEJO_REPOSITORY"];
-	const token = process.env["FORGEJO_TOKEN"];
-	if (!repository) throw new FatalError("FORGEJO_REPOSITORY environment variable is required");
-	if (!token) throw new FatalError("FORGEJO_TOKEN environment variable is required");
-	const url = `${serverUrl}/api/v1/repos/${repository}/actions/workflows/release.yml/dispatches`;
+async function triggerForgejo(conn, ref) {
+	const url = `${conn.serverUrl}/api/v1/repos/${conn.repository}/actions/workflows/release.yml/dispatches`;
 	const res = await fetch(url, {
 		method: "POST",
 		headers: {
-			Authorization: `token ${token}`,
+			Authorization: `token ${conn.token}`,
 			"Content-Type": "application/json"
 		},
 		body: JSON.stringify({ ref })
@@ -2357,18 +2638,10 @@ const createForgejoReleaseCommand = defineCommand({
 		required: true
 	} },
 	async run({ args }) {
-		const serverUrl = process.env["FORGEJO_SERVER_URL"];
-		const repository = process.env["FORGEJO_REPOSITORY"];
-		const token = process.env["FORGEJO_TOKEN"];
-		if (!serverUrl) throw new FatalError("FORGEJO_SERVER_URL environment variable is required");
-		if (!repository) throw new FatalError("FORGEJO_REPOSITORY environment variable is required");
-		if (!token) throw new FatalError("FORGEJO_TOKEN environment variable is required");
+		const resolved = resolveConnection(process.cwd());
+		if (resolved.type !== "forgejo") throw new FatalError("release:create-forgejo-release requires a Forgejo repository");
 		const executor = createRealExecutor();
-		const conn = {
-			serverUrl,
-			repository,
-			token
-		};
+		const conn = resolved.conn;
 		if (await findRelease(executor, conn, args.tag)) {
 			p.log.info(`Release for ${args.tag} already exists — skipping`);
 			return;
@@ -2378,12 +2651,57 @@ const createForgejoReleaseCommand = defineCommand({
 	}
 });
 
+//#endregion
+//#region src/commands/release-merge.ts
+const HEAD_BRANCH = "changeset-release/main";
+const releaseMergeCommand = defineCommand({
+	meta: {
+		name: "release:merge",
+		description: "Merge the open changesets version PR"
+	},
+	args: { "dry-run": {
+		type: "boolean",
+		description: "Show what would be merged without actually merging"
+	} },
+	async run({ args }) {
+		const dryRun = args["dry-run"] === true;
+		const resolved = resolveConnection(process.cwd());
+		if (resolved.type === "forgejo") await mergeForgejo(resolved.conn, dryRun);
+		else mergeGitHub(dryRun);
+	}
+});
+async function mergeForgejo(conn, dryRun) {
+	const executor = createRealExecutor();
+	const prNumber = await findOpenPr(executor, conn, HEAD_BRANCH);
+	if (prNumber === null) throw new FatalError(`No open PR found for branch ${HEAD_BRANCH}`);
+	if (dryRun) {
+		p.log.info(`[dry-run] Would merge PR #${String(prNumber)} and delete branch ${HEAD_BRANCH}`);
+		return;
+	}
+	await mergePr(executor, conn, prNumber, {
+		method: "merge",
+		deleteBranch: true
+	});
+	p.log.info(`Merged PR #${String(prNumber)} and deleted branch ${HEAD_BRANCH}`);
+}
+function mergeGitHub(dryRun) {
+	const executor = createRealExecutor();
+	if (dryRun) {
+		const prNum = executor.exec(`gh pr view ${HEAD_BRANCH} --json number --jq .number`, { cwd: process.cwd() }).stdout.trim();
+		if (!prNum) throw new FatalError(`No open PR found for branch ${HEAD_BRANCH}`);
+		p.log.info(`[dry-run] Would merge PR #${prNum} and delete branch ${HEAD_BRANCH}`);
+		return;
+	}
+	executor.exec(`gh pr merge ${HEAD_BRANCH} --merge --delete-branch`, { cwd: process.cwd() });
+	p.log.info(`Merged changesets PR and deleted branch ${HEAD_BRANCH}`);
+}
+
 //#endregion
 //#region src/bin.ts
-runMain(defineCommand({
+const main = defineCommand({
 	meta: {
 		name: "tooling",
-		version: "0.1.0",
+		version: "0.5.1",
 		description: "Bootstrap and maintain standardized TypeScript project tooling"
 	},
 	subCommands: {
@@ -2391,9 +2709,12 @@ runMain(defineCommand({
 		"repo:update": updateCommand,
 		"release:changesets": releaseForgejoCommand,
 		"release:trigger": releaseTriggerCommand,
-		"release:create-forgejo-release": createForgejoReleaseCommand
+		"release:create-forgejo-release": createForgejoReleaseCommand,
+		"release:merge": releaseMergeCommand
 	}
-}));
+});
+console.log(`@bensandee/tooling v0.5.1`);
+runMain(main);
 
 //#endregion
 export {  };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bensandee/tooling",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "description": "CLI tool to bootstrap and maintain standardized TypeScript project tooling",
   "bin": {
     "tooling": "./dist/bin.mjs"
@@ -31,7 +31,7 @@
     "tsdown": "0.20.3",
     "typescript": "5.9.3",
     "vitest": "4.0.18",
-    "@bensandee/config": "0.4.0"
+    "@bensandee/config": "0.5.0"
   },
   "scripts": {
     "build": "tsdown",