@bensandee/tooling 0.3.0 → 0.5.0

package/dist/bin.mjs

@@ -2,7 +2,7 @@
 import { defineCommand, runMain } from "citty";
 import * as p from "@clack/prompts";
 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";
@@ -48,18 +48,6 @@ const RenovateSchema = z.object({
 	$schema: z.string().optional(),
 	extends: z.array(z.string()).optional()
 }).loose();
-const KnipWorkspaceConfig = z.object({
-	entry: z.array(z.string()).optional(),
-	project: z.array(z.string()).optional(),
-	ignore: z.array(z.string()).optional()
-});
-const KnipSchema = z.object({
-	$schema: z.string().optional(),
-	entry: z.array(z.string()).optional(),
-	project: z.array(z.string()).optional(),
-	ignore: z.array(z.string()).optional(),
-	workspaces: z.record(z.string(), KnipWorkspaceConfig).optional()
-}).loose();
 /** Parse a JSONC string as a tsconfig.json. Returns a typed object with `{}` fallback on failure. */
 function parseTsconfig(raw) {
 	const result = TsconfigSchema.safeParse(parse(raw));
@@ -70,11 +58,6 @@ function parseRenovateJson(raw) {
 	const result = RenovateSchema.safeParse(parse(raw));
 	return result.success ? result.data : {};
 }
-/** Parse a JSONC string as a knip.json. Returns a typed object with `{}` fallback on failure. */
-function parseKnipJson(raw) {
-	const result = KnipSchema.safeParse(parse(raw));
-	return result.success ? result.data : {};
-}
 /** Parse a JSON string as a package.json. Returns `undefined` on failure. */
 function parsePackageJson(raw) {
 	try {
@@ -208,11 +191,11 @@ async function runInitPrompts(targetDir) {
 		p.cancel("Cancelled.");
 		process.exit(0);
 	}
-	const useLintRules = await p.confirm({
-		message: "Include @bensandee/lint-rules?",
+	const useEslintPlugin = await p.confirm({
+		message: "Include @bensandee/eslint-plugin?",
 		initialValue: true
 	});
-	if (isCancelled(useLintRules)) {
+	if (isCancelled(useEslintPlugin)) {
 		p.cancel("Cancelled.");
 		process.exit(0);
 	}
@@ -361,7 +344,7 @@ async function runInitPrompts(targetDir) {
 		name,
 		isNew: !isExisting,
 		structure,
-		useLintRules,
+		useEslintPlugin,
 		formatter,
 		setupVitest,
 		ci,
@@ -380,7 +363,7 @@ function buildDefaultConfig(targetDir, flags) {
 		name: existingPkg?.name ?? path.basename(targetDir),
 		isNew: !detected.hasPackageJson,
 		structure: detected.hasPnpmWorkspace ? "monorepo" : "single",
-		useLintRules: flags.lintRules ?? true,
+		useEslintPlugin: flags.eslintPlugin ?? true,
 		formatter: detected.legacyConfigs.some((l) => l.tool === "prettier") ? "prettier" : "oxfmt",
 		setupVitest: !detected.hasVitestConfig,
 		ci: flags.noCi ? "none" : DEFAULT_CI,
@@ -412,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
 	};
 }
 
@@ -436,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",
@@ -445,11 +446,10 @@ 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 = {
-	"@tsconfig/strictest": "2.0.8",
 	"@types/node": "25.3.2",
 	tsdown: "0.20.3",
 	typescript: "5.9.3",
@@ -457,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"
 };
 /**
@@ -527,7 +526,7 @@ async function generatePackageJson(ctx) {
 	if (!isMonorepo) Object.assign(devDeps, PER_PACKAGE_DEV_DEPS);
 	devDeps["@bensandee/config"] = isWorkspacePackage(ctx, "@bensandee/config") ? "workspace:*" : "latest";
 	devDeps["@bensandee/tooling"] = isWorkspacePackage(ctx, "@bensandee/tooling") ? "workspace:*" : "latest";
-	if (ctx.config.useLintRules) devDeps["@bensandee/lint-rules"] = isWorkspacePackage(ctx, "@bensandee/lint-rules") ? "workspace:*" : "latest";
+	if (ctx.config.useEslintPlugin) devDeps["@bensandee/eslint-plugin"] = isWorkspacePackage(ctx, "@bensandee/eslint-plugin") ? "workspace:*" : "latest";
 	if (ctx.config.formatter === "oxfmt") devDeps["oxfmt"] = "0.35.0";
 	if (ctx.config.formatter === "prettier") devDeps["prettier"] = "3.8.1";
 	addReleaseDeps(devDeps, ctx.config);
@@ -608,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}`);
@@ -618,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}`);
@@ -644,6 +649,18 @@ 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("1. Review the archived files for any custom configuration that should be preserved in the new files");
+		sections.push("2. If the project previously used `husky` and `lint-staged`, remove them from `devDependencies`");
+		sections.push("3. 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");
@@ -710,7 +727,7 @@ function generateMigratePrompt(results, config, detected) {
 	sections.push("");
 	sections.push("- **Lint errors**: fix the code rather than adding disable comments or rule exceptions");
 	sections.push("- **Test failures**: update the test or fix the underlying bug rather than skipping or deleting the test");
-	sections.push("- **Knip findings**: remove genuinely unused code/exports/dependencies rather than adding ignores to `knip.json`");
+	sections.push("- **Knip findings**: remove genuinely unused code/exports/dependencies rather than adding ignores to `knip.config.ts`");
 	sections.push("- **Type errors**: add proper types rather than using `any` or `@ts-expect-error`");
 	sections.push("");
 	sections.push("Only suppress an issue if there is a clear, documented reason why the fix is not feasible (e.g. a third-party type mismatch). Leave a comment explaining why.");
@@ -942,7 +959,7 @@ export default defineConfig({
 `;
 async function generateOxlint(ctx) {
 	const filePath = "oxlint.config.ts";
-	const content = ctx.config.useLintRules ? CONFIG_WITH_LINT_RULES : CONFIG_PRESET_ONLY;
+	const content = ctx.config.useEslintPlugin ? CONFIG_WITH_LINT_RULES : CONFIG_PRESET_ONLY;
 	const existing = ctx.read(filePath);
 	if (existing) {
 		if (existing === content) return {
@@ -1050,7 +1067,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) {
@@ -1146,88 +1164,62 @@ async function generateCi(ctx) {
 
 //#endregion
 //#region src/generators/knip.ts
-const KNIP_CONFIG_SINGLE = {
-	$schema: "https://unpkg.com/knip@latest/schema.json",
-	entry: ["src/index.ts"],
-	project: ["src/**/*.ts"],
-	ignore: ["dist/**"]
-};
-const KNIP_CONFIG_MONOREPO = {
-	$schema: "https://unpkg.com/knip@latest/schema.json",
-	workspaces: {
-		".": {
-			entry: [],
-			project: []
-		},
-		"packages/*": {
-			entry: ["src/index.ts", "src/bin.ts"],
-			project: ["src/**/*.ts"],
-			ignore: ["dist/**"]
-		}
-	}
-};
+const KNIP_CONFIG_SINGLE = `import type { KnipConfig } from "knip";
+
+export default {
+  entry: ["src/index.ts"],
+  project: ["src/**/*.ts"],
+  ignore: ["dist/**"],
+} satisfies KnipConfig;
+`;
+const KNIP_CONFIG_MONOREPO = `import type { KnipConfig } from "knip";
+
+export default {
+  workspaces: {
+    ".": {
+      entry: [],
+      project: [],
+    },
+    "packages/*": {
+      entry: ["src/index.ts", "src/bin.ts"],
+      project: ["src/**/*.ts"],
+      ignore: ["dist/**"],
+    },
+  },
+} satisfies KnipConfig;
+`;
 /** All known knip config file locations, in priority order. */
 const KNIP_CONFIG_PATHS = [
+	"knip.config.ts",
+	"knip.config.mts",
 	"knip.json",
 	"knip.jsonc",
 	"knip.ts",
-	"knip.mts",
-	"knip.config.ts",
-	"knip.config.mts"
+	"knip.mts"
 ];
 async function generateKnip(ctx) {
-	const filePath = "knip.json";
+	const filePath = "knip.config.ts";
 	const isMonorepo = ctx.config.structure === "monorepo";
 	const existingPath = KNIP_CONFIG_PATHS.find((p) => ctx.exists(p));
-	if (existingPath === filePath) {
-		const existing = ctx.read(filePath);
-		if (existing) {
-			const parsed = parseKnipJson(existing);
-			const changes = [];
-			if (isMonorepo && !parsed.workspaces) {
-				parsed.workspaces = KNIP_CONFIG_MONOREPO.workspaces;
-				changes.push("added monorepo workspaces config");
-			}
-			if (!isMonorepo) {
-				if (!parsed.entry) {
-					parsed.entry = KNIP_CONFIG_SINGLE.entry;
-					changes.push("added entry patterns");
-				}
-				if (!parsed.project) {
-					parsed.project = KNIP_CONFIG_SINGLE.project;
-					changes.push("added project patterns");
-				}
-			}
-			if (changes.length === 0) return {
-				filePath,
-				action: "skipped",
-				description: "Already configured"
-			};
-			ctx.write(filePath, JSON.stringify(parsed, null, 2) + "\n");
-			return {
-				filePath,
-				action: "updated",
-				description: changes.join(", ")
-			};
-		}
-	}
 	if (existingPath) return {
 		filePath: existingPath,
 		action: "skipped",
-		description: `Existing config found at ${existingPath}`
+		description: existingPath === filePath ? "Already configured" : `Existing config found at ${existingPath}`
 	};
 	const config = isMonorepo ? KNIP_CONFIG_MONOREPO : KNIP_CONFIG_SINGLE;
-	ctx.write(filePath, JSON.stringify(config, null, 2) + "\n");
+	ctx.write(filePath, config);
 	return {
 		filePath,
 		action: "created",
-		description: "Generated knip.json for dead code analysis"
+		description: "Generated knip.config.ts for dead code analysis"
 	};
 }
 
 //#endregion
 //#region src/generators/renovate.ts
-const SHARED_PRESET = "@bensandee/config";
+const SHARED_PRESET = "local>bensandee/tooling";
+/** Deprecated npm-based preset to migrate away from. */
+const LEGACY_PRESET = "@bensandee/config";
 /** All known renovate config file locations, in priority order. */
 const RENOVATE_CONFIG_PATHS = [
 	"renovate.json",
@@ -1250,6 +1242,17 @@ async function generateRenovate(ctx) {
 		if (existing) {
 			const parsed = parseRenovateJson(existing);
 			const existingExtends = parsed.extends ?? [];
+			const legacyIndex = existingExtends.indexOf(LEGACY_PRESET);
+			if (legacyIndex !== -1) {
+				existingExtends[legacyIndex] = SHARED_PRESET;
+				parsed.extends = existingExtends;
+				ctx.write(filePath, JSON.stringify(parsed, null, 2) + "\n");
+				return {
+					filePath,
+					action: "updated",
+					description: `Migrated extends: ${LEGACY_PRESET} → ${SHARED_PRESET}`
+				};
+			}
 			if (!existingExtends.includes(SHARED_PRESET)) {
 				existingExtends.unshift(SHARED_PRESET);
 				parsed.extends = existingExtends;
@@ -1339,6 +1342,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 *)",
@@ -1378,6 +1383,8 @@ function buildSettings(ctx) {
 		"Bash(head *)",
 		"Bash(tail *)",
 		"Bash(wc *)",
+		"Bash(test *)",
+		"Bash([ *)",
 		"Bash(find *)",
 		"Bash(which *)",
 		"Bash(node -e *)",
@@ -1710,12 +1717,21 @@ 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"}",\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";
+/** All known lint-staged config file locations to archive. */
 const LINT_STAGED_CONFIG_PATHS = [
 	"lint-staged.config.mjs",
 	"lint-staged.config.js",
@@ -1727,37 +1743,71 @@ 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"];
+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 = [];
+	const huskyPath = ".husky/pre-commit";
+	const existingHusky = ctx.read(huskyPath);
+	if (existingHusky !== void 0) {
+		ctx.write(`${ARCHIVE_DIR}/${huskyPath}`, existingHusky);
+		ctx.remove(huskyPath);
+		results.push({
+			filePath: huskyPath,
+			action: "archived",
+			description: `Moved to ${ARCHIVE_DIR}/${huskyPath}`
+		});
+	}
+	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}`
+			});
+		}
+	}
+	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
@@ -1778,9 +1828,9 @@ const initCommand = defineCommand({
 			alias: "y",
 			description: "Accept all defaults (non-interactive)"
 		},
-		"lint-rules": {
+		"eslint-plugin": {
 			type: "boolean",
-			description: "Include @bensandee/lint-rules (default: true)"
+			description: "Include @bensandee/eslint-plugin (default: true)"
 		},
 		"no-ci": {
 			type: "boolean",
@@ -1794,14 +1844,14 @@ const initCommand = defineCommand({
 	async run({ args }) {
 		const targetDir = path.resolve(args.dir ?? ".");
 		await runInit(args.yes ? buildDefaultConfig(targetDir, {
-			lintRules: args["lint-rules"] === true ? true : void 0,
+			eslintPlugin: args["eslint-plugin"] === true ? true : void 0,
 			noCi: args["no-ci"] === true ? true : void 0
 		}) : await runInitPrompts(targetDir), args["no-prompt"] === true ? { noPrompt: true } : {});
 	}
 });
 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: [{
@@ -1824,7 +1874,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));
@@ -1835,13 +1885,21 @@ 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!");
 	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) {
@@ -1981,10 +2039,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 = [];
@@ -2066,6 +2120,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);
@@ -2093,6 +2163,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";
@@ -2165,11 +2250,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",
@@ -2183,13 +2277,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,
@@ -2235,12 +2330,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");
@@ -2299,6 +2399,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({
@@ -2306,33 +2480,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);
 }
 
@@ -2350,21 +2534,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 })
@@ -2390,18 +2570,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;
@@ -2411,6 +2583,51 @@ 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({
@@ -2424,7 +2641,8 @@ runMain(defineCommand({
 		"repo:update": updateCommand,
 		"release:changesets": releaseForgejoCommand,
 		"release:trigger": releaseTriggerCommand,
-		"release:create-forgejo-release": createForgejoReleaseCommand
+		"release:create-forgejo-release": createForgejoReleaseCommand,
+		"release:merge": releaseMergeCommand
 	}
 }));
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bensandee/tooling",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "CLI tool to bootstrap and maintain standardized TypeScript project tooling",
   "bin": {
     "tooling": "./dist/bin.mjs"
@@ -9,17 +9,13 @@
     "dist"
   ],
   "type": "module",
-  "main": "./dist/index.mjs",
-  "module": "./dist/index.mjs",
-  "types": "./dist/index.d.mts",
   "imports": {
     "#src/*": "./src/*.ts"
   },
   "exports": {
-    ".": {
-      "types": "./dist/index.d.mts",
-      "import": "./dist/index.mjs"
-    }
+    ".": "./dist/index.mjs",
+    "./bin": "./dist/bin.mjs",
+    "./package.json": "./package.json"
   },
   "publishConfig": {
     "access": "public"
@@ -35,7 +31,7 @@
     "tsdown": "0.20.3",
     "typescript": "5.9.3",
     "vitest": "4.0.18",
-    "@bensandee/config": "0.3.0"
+    "@bensandee/config": "0.5.0"
   },
   "scripts": {
     "build": "tsdown",

package/dist/bin.d.mts

@@ -1 +0,0 @@
-export { };

package/dist/index.d.mts

@@ -1,102 +0,0 @@
-import { z } from "zod";
-
-//#region src/utils/json.d.ts
-declare const PackageJsonSchema: z.ZodObject<{
-  name: z.ZodOptional<z.ZodString>;
-  version: z.ZodOptional<z.ZodString>;
-  private: z.ZodOptional<z.ZodBoolean>;
-  type: z.ZodOptional<z.ZodString>;
-  scripts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-  dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-  devDependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-  bin: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
-  exports: z.ZodOptional<z.ZodUnknown>;
-  main: z.ZodOptional<z.ZodString>;
-  types: z.ZodOptional<z.ZodString>;
-  typings: z.ZodOptional<z.ZodString>;
-  engines: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-}, z.core.$loose>;
-type PackageJson = z.infer<typeof PackageJsonSchema>;
-//#endregion
-//#region src/types.d.ts
-type CiPlatform = "github" | "forgejo" | "none";
-type ReleaseStrategy = "release-it" | "commit-and-tag-version" | "changesets" | "none";
-/** User's answers from the interactive prompt or CLI flags. */
-interface ProjectConfig {
-  /** Project name (from package.json name or user input) */
-  name: string;
-  /** Whether this is a new project or existing */
-  isNew: boolean;
-  /** Project structure */
-  structure: "single" | "monorepo";
-  /** Include @bensandee/lint-rules oxlint plugin */
-  useLintRules: boolean;
-  /** Formatter choice */
-  formatter: "oxfmt" | "prettier";
-  /** Set up vitest with a starter test */
-  setupVitest: boolean;
-  /** CI platform choice */
-  ci: CiPlatform;
-  /** Set up Renovate for automated dependency updates */
-  setupRenovate: boolean;
-  /** Release management strategy */
-  releaseStrategy: ReleaseStrategy;
-  /** Project type determines tsconfig base configuration */
-  projectType: "default" | "node" | "react" | "library";
-  /** Auto-detect and configure tsconfig bases for monorepo packages */
-  detectPackageTypes: boolean;
-  /** Target directory (default: cwd) */
-  targetDir: string;
-}
-/** Result from a single generator: what file was written and how. */
-interface GeneratorResult {
-  filePath: string;
-  action: "created" | "updated" | "skipped";
-  /** Human-readable description of what changed */
-  description: string;
-}
-/** Context passed to each generator function. */
-interface GeneratorContext {
-  config: ProjectConfig;
-  /** Absolute path to target directory */
-  targetDir: string;
-  /** Pre-parsed package.json from the target directory, or undefined if missing/invalid */
-  packageJson: PackageJson | undefined;
-  /** Check whether a file exists in the target directory */
-  exists: (relativePath: string) => boolean;
-  /** Read an existing file from the target directory, returns undefined if not found */
-  read: (relativePath: string) => string | undefined;
-  /** Write a file to the target directory (creating directories as needed) */
-  write: (relativePath: string, content: string) => void;
-  /** Prompt user for conflict resolution on non-mergeable files */
-  confirmOverwrite: (relativePath: string) => Promise<"overwrite" | "skip">;
-}
-/** Generator function signature. */
-type Generator = (ctx: GeneratorContext) => Promise<GeneratorResult>;
-/** State detected from an existing project directory. */
-interface DetectedProjectState {
-  hasPackageJson: boolean;
-  hasTsconfig: boolean;
-  hasOxlintConfig: boolean;
-  /** Legacy .oxlintrc.json found (should be migrated to oxlint.config.ts) */
-  hasLegacyOxlintJson: boolean;
-  hasGitignore: boolean;
-  hasVitestConfig: boolean;
-  hasTsdownConfig: boolean;
-  hasPnpmWorkspace: boolean;
-  hasKnipConfig: boolean;
-  hasRenovateConfig: boolean;
-  hasReleaseItConfig: boolean;
-  hasCommitAndTagVersionConfig: boolean;
-  hasChangesetsConfig: boolean;
-  /** Legacy tooling configs found */
-  legacyConfigs: LegacyConfig[];
-}
-declare const LEGACY_TOOLS: readonly ["eslint", "prettier", "jest", "webpack", "rollup"];
-type LegacyTool = (typeof LEGACY_TOOLS)[number];
-interface LegacyConfig {
-  tool: LegacyTool;
-  files: string[];
-}
-//#endregion
-export { type DetectedProjectState, type Generator, type GeneratorContext, type GeneratorResult, type LegacyConfig, type ProjectConfig };