@bensandee/tooling 0.2.0

package/dist/bin.mjs

@@ -0,0 +1,2371 @@
+#!/usr/bin/env node
+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 { 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. */
+const DEFAULT_CI = "forgejo";
+const LEGACY_TOOLS = [
+	"eslint",
+	"prettier",
+	"jest",
+	"webpack",
+	"rollup"
+];
+
+//#endregion
+//#region src/utils/json.ts
+const StringRecord = z.record(z.string(), z.string());
+const PackageJsonSchema = z.object({
+	name: z.string().optional(),
+	version: z.string().optional(),
+	private: z.boolean().optional(),
+	type: z.string().optional(),
+	scripts: StringRecord.optional(),
+	dependencies: StringRecord.optional(),
+	devDependencies: StringRecord.optional(),
+	bin: z.union([z.string(), StringRecord]).optional(),
+	exports: z.unknown().optional(),
+	main: z.string().optional(),
+	types: z.string().optional(),
+	typings: z.string().optional(),
+	engines: StringRecord.optional()
+}).loose();
+const TsconfigSchema = z.object({
+	extends: z.union([z.string(), z.array(z.string())]).optional(),
+	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(),
+	compilerOptions: z.record(z.string(), z.unknown()).optional()
+}).loose();
+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));
+	return result.success ? result.data : {};
+}
+/** Parse a JSON string as a renovate.json. Returns a typed object with `{}` fallback on failure. */
+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 {
+		const result = PackageJsonSchema.safeParse(JSON.parse(raw));
+		return result.success ? result.data : void 0;
+	} catch {
+		return;
+	}
+}
+
+//#endregion
+//#region src/utils/detect.ts
+const LEGACY_PATTERNS = {
+	eslint: [/^\.eslintrc/, /^eslint\.config\./],
+	prettier: [/^\.prettierrc/, /^prettier\.config\./],
+	jest: [/^jest\.config\./, /^jest\.setup\./],
+	webpack: [/^webpack\.config\./],
+	rollup: [/^rollup\.config\./]
+};
+/** Detect existing project state in the target directory. */
+function detectProject(targetDir) {
+	const exists = (rel) => existsSync(path.join(targetDir, rel));
+	return {
+		hasPackageJson: exists("package.json"),
+		hasTsconfig: exists("tsconfig.json"),
+		hasOxlintConfig: exists("oxlint.config.ts"),
+		hasLegacyOxlintJson: exists(".oxlintrc.json"),
+		hasGitignore: exists(".gitignore"),
+		hasVitestConfig: exists("vitest.config.ts") || exists("vitest.config.mts"),
+		hasTsdownConfig: exists("tsdown.config.ts") || exists("tsdown.config.mts"),
+		hasPnpmWorkspace: exists("pnpm-workspace.yaml"),
+		hasKnipConfig: exists("knip.json") || exists("knip.jsonc") || exists("knip.ts") || exists("knip.mts") || exists("knip.config.ts") || exists("knip.config.mts"),
+		hasRenovateConfig: exists("renovate.json") || exists("renovate.json5") || exists(".renovaterc") || exists(".renovaterc.json") || exists(".github/renovate.json") || exists(".github/renovate.json5"),
+		hasReleaseItConfig: exists(".release-it.json") || exists(".release-it.yaml") || exists(".release-it.toml"),
+		hasCommitAndTagVersionConfig: exists(".versionrc") || exists(".versionrc.json") || exists(".versionrc.js"),
+		hasChangesetsConfig: exists(".changeset/config.json"),
+		legacyConfigs: detectLegacyConfigs(targetDir)
+	};
+}
+/** Scan for legacy/conflicting tooling config files. */
+function detectLegacyConfigs(targetDir) {
+	let entries;
+	try {
+		entries = readdirSync(targetDir);
+	} catch (_error) {
+		return [];
+	}
+	const results = [];
+	for (const tool of LEGACY_TOOLS) {
+		const patterns = LEGACY_PATTERNS[tool];
+		const matched = entries.filter((entry) => patterns.some((p) => p.test(entry)));
+		if (matched.length > 0) results.push({
+			tool,
+			files: matched
+		});
+	}
+	return results;
+}
+/** Read and parse existing package.json, or return undefined. */
+function readPackageJson(targetDir) {
+	const pkgPath = path.join(targetDir, "package.json");
+	if (!existsSync(pkgPath)) return void 0;
+	try {
+		return parsePackageJson(readFileSync(pkgPath, "utf-8"));
+	} catch (_error) {
+		return;
+	}
+}
+/** Detect whether the project is a monorepo. */
+function detectMonorepo(targetDir) {
+	return existsSync(path.join(targetDir, "pnpm-workspace.yaml"));
+}
+/** Detect project type from package.json signals. */
+function detectProjectType(targetDir) {
+	const pkg = readPackageJson(targetDir);
+	if (!pkg) return "default";
+	const deps = {
+		...pkg.dependencies,
+		...pkg.devDependencies
+	};
+	if ("react" in deps || "react-dom" in deps) return "react";
+	const scripts = pkg.scripts ?? {};
+	if (!!pkg.bin || Object.values(scripts).some((cmd) => typeof cmd === "string" && /\b(node|tsx|ts-node)\b/.test(cmd))) return "node";
+	if (pkg.exports || pkg.main || pkg.types || pkg.typings) return "library";
+	return "default";
+}
+/** List packages in a monorepo's packages/ directory. */
+function getMonorepoPackages(targetDir) {
+	const packagesDir = path.join(targetDir, "packages");
+	if (!existsSync(packagesDir)) return [];
+	const results = [];
+	try {
+		for (const entry of readdirSync(packagesDir, { withFileTypes: true })) {
+			if (!entry.isDirectory()) continue;
+			const pkgDir = path.join(packagesDir, entry.name);
+			const pkg = readPackageJson(pkgDir);
+			if (!pkg) continue;
+			results.push({
+				dir: pkgDir,
+				name: pkg.name ?? entry.name
+			});
+		}
+	} catch (_error) {}
+	return results;
+}
+
+//#endregion
+//#region src/prompts/init-prompts.ts
+function isCancelled(value) {
+	return p.isCancel(value);
+}
+async function runInitPrompts(targetDir) {
+	p.intro("@bensandee/tooling repo:init");
+	const existingPkg = readPackageJson(targetDir);
+	const detected = detectProject(targetDir);
+	const isExisting = detected.hasPackageJson;
+	const name = existingPkg?.name ?? path.basename(targetDir);
+	const detectedMonorepo = detectMonorepo(targetDir);
+	const structure = await p.select({
+		message: "Project structure",
+		initialValue: detectedMonorepo ? "monorepo" : "single",
+		options: [{
+			value: "single",
+			label: "Single repo"
+		}, {
+			value: "monorepo",
+			label: "Monorepo (pnpm workspaces)"
+		}]
+	});
+	if (isCancelled(structure)) {
+		p.cancel("Cancelled.");
+		process.exit(0);
+	}
+	const useLintRules = await p.confirm({
+		message: "Include @bensandee/lint-rules?",
+		initialValue: true
+	});
+	if (isCancelled(useLintRules)) {
+		p.cancel("Cancelled.");
+		process.exit(0);
+	}
+	const hasExistingPrettier = detected.legacyConfigs.some((l) => l.tool === "prettier");
+	const formatter = await p.select({
+		message: "Formatter",
+		initialValue: hasExistingPrettier ? "prettier" : "oxfmt",
+		options: [{
+			value: "oxfmt",
+			label: "oxfmt",
+			hint: "fast, Rust-based"
+		}, {
+			value: "prettier",
+			label: "Prettier"
+		}]
+	});
+	if (isCancelled(formatter)) {
+		p.cancel("Cancelled.");
+		process.exit(0);
+	}
+	const setupVitest = await p.confirm({
+		message: "Set up vitest with a starter test?",
+		initialValue: !isExisting
+	});
+	if (isCancelled(setupVitest)) {
+		p.cancel("Cancelled.");
+		process.exit(0);
+	}
+	const ci = await p.select({
+		message: "CI workflow",
+		options: [
+			{
+				value: "forgejo",
+				label: "Forgejo Actions"
+			},
+			{
+				value: "github",
+				label: "GitHub Actions"
+			},
+			{
+				value: "none",
+				label: "None"
+			}
+		]
+	});
+	if (isCancelled(ci)) {
+		p.cancel("Cancelled.");
+		process.exit(0);
+	}
+	let setupRenovate = true;
+	if (ci === "github") {
+		const renovateAnswer = await p.confirm({
+			message: "Set up Renovate for automated dependency updates?",
+			initialValue: true
+		});
+		if (isCancelled(renovateAnswer)) {
+			p.cancel("Cancelled.");
+			process.exit(0);
+		}
+		setupRenovate = renovateAnswer;
+	}
+	const releaseStrategy = await p.select({
+		message: "Release management",
+		initialValue: "none",
+		options: [
+			{
+				value: "none",
+				label: "None"
+			},
+			{
+				value: "release-it",
+				label: "release-it",
+				hint: "interactive, conventional commits"
+			},
+			{
+				value: "changesets",
+				label: "Changesets",
+				hint: "PR-based versioning"
+			},
+			{
+				value: "commit-and-tag-version",
+				label: "commit-and-tag-version",
+				hint: "conventional commits, automatic CHANGELOG"
+			}
+		]
+	});
+	if (isCancelled(releaseStrategy)) {
+		p.cancel("Cancelled.");
+		process.exit(0);
+	}
+	let projectType = "default";
+	let detectPackageTypes = false;
+	if (structure === "monorepo") {
+		const packages = getMonorepoPackages(targetDir);
+		if (packages.length > 0) {
+			const detections = packages.map((pkg) => {
+				const type = detectProjectType(pkg.dir);
+				return `  ${pkg.name} → ${type}`;
+			});
+			p.note(detections.join("\n"), "Detected package types");
+			const applyDetected = await p.confirm({
+				message: "Apply detected tsconfig bases to packages?",
+				initialValue: true
+			});
+			if (isCancelled(applyDetected)) {
+				p.cancel("Cancelled.");
+				process.exit(0);
+			}
+			detectPackageTypes = applyDetected;
+		}
+	} else {
+		const projectTypeAnswer = await p.select({
+			message: "Project type",
+			initialValue: "default",
+			options: [
+				{
+					value: "default",
+					label: "Default",
+					hint: "strictest base, no runtime assumptions"
+				},
+				{
+					value: "node",
+					label: "Node.js",
+					hint: "adds types: [\"node\"]"
+				},
+				{
+					value: "react",
+					label: "React",
+					hint: "browser app with JSX + DOM types"
+				},
+				{
+					value: "library",
+					label: "Library",
+					hint: "publishable package (ES2022 target)"
+				}
+			]
+		});
+		if (isCancelled(projectTypeAnswer)) {
+			p.cancel("Cancelled.");
+			process.exit(0);
+		}
+		projectType = projectTypeAnswer;
+	}
+	p.outro("Configuration complete!");
+	return {
+		name,
+		isNew: !isExisting,
+		structure,
+		useLintRules,
+		formatter,
+		setupVitest,
+		ci,
+		setupRenovate,
+		releaseStrategy,
+		projectType,
+		detectPackageTypes,
+		targetDir
+	};
+}
+/** Build a ProjectConfig from CLI flags for non-interactive mode. */
+function buildDefaultConfig(targetDir, flags) {
+	const existingPkg = readPackageJson(targetDir);
+	const detected = detectProject(targetDir);
+	return {
+		name: existingPkg?.name ?? path.basename(targetDir),
+		isNew: !detected.hasPackageJson,
+		structure: detected.hasPnpmWorkspace ? "monorepo" : "single",
+		useLintRules: flags.lintRules ?? true,
+		formatter: detected.legacyConfigs.some((l) => l.tool === "prettier") ? "prettier" : "oxfmt",
+		setupVitest: !detected.hasVitestConfig,
+		ci: flags.noCi ? "none" : DEFAULT_CI,
+		setupRenovate: true,
+		releaseStrategy: detected.hasReleaseItConfig ? "release-it" : detected.hasCommitAndTagVersionConfig ? "commit-and-tag-version" : detected.hasChangesetsConfig ? "changesets" : "none",
+		projectType: "default",
+		detectPackageTypes: true,
+		targetDir
+	};
+}
+
+//#endregion
+//#region src/utils/fs.ts
+/** Check whether a file exists at the given path. */
+function fileExists(targetDir, relativePath) {
+	return existsSync(path.join(targetDir, relativePath));
+}
+/** Read a file from the target directory. Returns undefined if not found. */
+function readFile(targetDir, relativePath) {
+	const fullPath = path.join(targetDir, relativePath);
+	if (!existsSync(fullPath)) return void 0;
+	return readFileSync(fullPath, "utf-8");
+}
+/** Write a file to the target directory, creating parent directories as needed. */
+function writeFile(targetDir, relativePath, content) {
+	const fullPath = path.join(targetDir, relativePath);
+	mkdirSync(path.dirname(fullPath), { recursive: true });
+	writeFileSync(fullPath, content);
+}
+/**
+* Create a GeneratorContext from a ProjectConfig and a conflict resolution handler.
+*/
+function createContext(config, confirmOverwrite) {
+	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
+	};
+}
+
+//#endregion
+//#region src/generators/package-json.ts
+const STANDARD_SCRIPTS_SINGLE = {
+	build: "tsdown",
+	dev: "tsdown --watch",
+	typecheck: "tsc --noEmit",
+	test: "vitest run",
+	lint: "oxlint",
+	knip: "knip",
+	check: "pnpm typecheck && pnpm build && pnpm lint && pnpm knip",
+	prepare: "husky"
+};
+const STANDARD_SCRIPTS_MONOREPO = {
+	build: "pnpm -r build",
+	test: "pnpm -r test",
+	typecheck: "pnpm -r --parallel run typecheck",
+	lint: "oxlint",
+	knip: "knip",
+	check: "pnpm typecheck && pnpm build && pnpm lint && pnpm knip",
+	prepare: "husky"
+};
+/** DevDeps that belong in every project (single repo) or per-package (monorepo). */
+const PER_PACKAGE_DEV_DEPS = {
+	"@types/node": "25.3.2",
+	tsdown: "0.20.3",
+	typescript: "5.9.3",
+	vitest: "4.0.18"
+};
+/** 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",
+	oxlint: "1.50.0"
+};
+/**
+* Check if a package name is available as a workspace dependency.
+* Looks for a matching package in the packages/ directory.
+*/
+function isWorkspacePackage(ctx, packageName) {
+	if (ctx.config.structure !== "monorepo") return false;
+	const packagesDir = path.join(ctx.targetDir, "packages");
+	if (!existsSync(packagesDir)) return false;
+	try {
+		for (const entry of readdirSync(packagesDir, { withFileTypes: true })) {
+			if (!entry.isDirectory()) continue;
+			const pkgJsonPath = path.join(packagesDir, entry.name, "package.json");
+			if (!existsSync(pkgJsonPath)) continue;
+			try {
+				if (parsePackageJson(readFileSync(pkgJsonPath, "utf-8"))?.name === packageName) return true;
+			} catch (_error) {}
+		}
+	} catch (_error) {}
+	return false;
+}
+/** Deps that should not be blindly bumped to latest (version-sensitive). */
+const UPDATE_EXCLUDE = new Set(["@types/node"]);
+/** Add release-strategy-specific devDeps to a deps record. */
+function addReleaseDeps(deps, config) {
+	switch (config.releaseStrategy) {
+		case "release-it":
+			deps["release-it"] = "18.1.2";
+			if (config.structure === "monorepo") deps["@release-it/bumper"] = "7.0.2";
+			if (config.ci === "forgejo") deps["@bensandee/release-it-forgejo"] = "0.1.1";
+			break;
+		case "commit-and-tag-version":
+			deps["commit-and-tag-version"] = "12.5.0";
+			break;
+		case "changesets":
+			deps["@changesets/cli"] = "2.29.4";
+			break;
+	}
+}
+/** Returns the list of pinned devDependency names that the tool would add for a given config. */
+function getAddedDevDepNames(config) {
+	const deps = { ...ROOT_DEV_DEPS };
+	if (config.structure !== "monorepo") Object.assign(deps, PER_PACKAGE_DEV_DEPS);
+	deps["@bensandee/config"] = "latest";
+	deps["@bensandee/tooling"] = "latest";
+	if (config.formatter === "oxfmt") deps["oxfmt"] = "0.35.0";
+	if (config.formatter === "prettier") deps["prettier"] = "3.8.1";
+	addReleaseDeps(deps, config);
+	return Object.keys(deps).filter((name) => !UPDATE_EXCLUDE.has(name));
+}
+async function generatePackageJson(ctx) {
+	const filePath = "package.json";
+	const existing = ctx.read(filePath);
+	const isMonorepo = ctx.config.structure === "monorepo";
+	const scripts = isMonorepo ? STANDARD_SCRIPTS_MONOREPO : STANDARD_SCRIPTS_SINGLE;
+	const formatScript = ctx.config.formatter === "oxfmt" ? "oxfmt ." : "prettier --write .";
+	const allScripts = {
+		...scripts,
+		format: formatScript
+	};
+	if (ctx.config.releaseStrategy === "changesets") allScripts["changeset"] = "changeset";
+	if (ctx.config.releaseStrategy !== "none") allScripts["trigger-release"] = "pnpm exec tooling release:trigger";
+	const devDeps = { ...ROOT_DEV_DEPS };
+	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.formatter === "oxfmt") devDeps["oxfmt"] = "0.35.0";
+	if (ctx.config.formatter === "prettier") devDeps["prettier"] = "3.8.1";
+	addReleaseDeps(devDeps, ctx.config);
+	if (existing) {
+		const pkg = parsePackageJson(existing);
+		if (!pkg) return {
+			filePath,
+			action: "skipped",
+			description: "Could not parse existing package.json"
+		};
+		const changes = [];
+		if (pkg.type !== "module") {
+			pkg.type = "module";
+			changes.push("set type: \"module\"");
+		}
+		const existingScripts = pkg.scripts ?? {};
+		for (const [key, value] of Object.entries(allScripts)) if (!(key in existingScripts)) {
+			existingScripts[key] = value;
+			changes.push(`added script: ${key}`);
+		}
+		pkg.scripts = existingScripts;
+		const existingDevDeps = pkg.devDependencies ?? {};
+		for (const [key, value] of Object.entries(devDeps)) if (!(key in existingDevDeps)) {
+			existingDevDeps[key] = value;
+			changes.push(`added devDependency: ${key}`);
+		}
+		pkg.devDependencies = existingDevDeps;
+		if (!pkg["engines"]) {
+			pkg["engines"] = { node: ">=24.13.0" };
+			changes.push("set engines.node >= 24.13.0");
+		}
+		if (changes.length === 0) return {
+			filePath,
+			action: "skipped",
+			description: "Already up to spec"
+		};
+		ctx.write(filePath, JSON.stringify(pkg, null, 2) + "\n");
+		return {
+			filePath,
+			action: "updated",
+			description: changes.join(", ")
+		};
+	}
+	const pkg = {
+		name: ctx.config.name,
+		version: "0.1.0",
+		private: true,
+		type: "module",
+		scripts: allScripts,
+		devDependencies: devDeps,
+		engines: { node: ">=24.13.0" },
+		packageManager: "pnpm@10.29.3"
+	};
+	ctx.write(filePath, JSON.stringify(pkg, null, 2) + "\n");
+	return {
+		filePath,
+		action: "created",
+		description: "Generated package.json"
+	};
+}
+
+//#endregion
+//#region src/generators/migrate-prompt.ts
+/**
+* Generate a context-aware AI migration prompt based on what the CLI did.
+* This prompt can be pasted into Claude Code (or similar) to finish the migration.
+*/
+function generateMigratePrompt(results, config, detected) {
+	const sections = [];
+	sections.push("# Migration Prompt");
+	sections.push("");
+	sections.push("The following prompt was generated by `@bensandee/tooling repo:init`. Paste it into Claude Code or another AI assistant to finish migrating this repository.");
+	sections.push("");
+	sections.push("> **Tip:** Before starting, run `/init` in Claude Code to generate a `CLAUDE.md` that gives the AI a complete picture of your repository's structure, conventions, and build commands.");
+	sections.push("");
+	sections.push("## What was changed");
+	sections.push("");
+	const created = results.filter((r) => r.action === "created");
+	const updated = results.filter((r) => r.action === "updated");
+	const skipped = results.filter((r) => r.action === "skipped");
+	if (created.length > 0) {
+		sections.push("**Created:**");
+		for (const r of created) sections.push(`- \`${r.filePath}\` — ${r.description}`);
+		sections.push("");
+	}
+	if (updated.length > 0) {
+		sections.push("**Updated:**");
+		for (const r of updated) 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}`);
+		sections.push("");
+	}
+	sections.push("## Migration tasks");
+	sections.push("");
+	const legacyToRemove = detected.legacyConfigs.filter((legacy) => !(legacy.tool === "prettier" && config.formatter === "prettier"));
+	if (legacyToRemove.length > 0) {
+		sections.push("### Remove legacy tooling");
+		sections.push("");
+		for (const legacy of legacyToRemove) {
+			const replacement = {
+				eslint: "oxlint",
+				prettier: "oxfmt",
+				jest: "vitest",
+				webpack: "tsdown",
+				rollup: "tsdown"
+			}[legacy.tool];
+			sections.push(`- Remove ${legacy.tool} config files (${legacy.files.map((f) => `\`${f}\``).join(", ")}). This project now uses **${replacement}**.`);
+			sections.push(`  - Uninstall ${legacy.tool}-related packages from devDependencies`);
+			if (legacy.tool === "eslint") sections.push("  - Migrate any custom ESLint rules that don't have oxlint equivalents");
+			if (legacy.tool === "jest") sections.push("  - Migrate any jest-specific test utilities (jest.mock, jest.fn) to vitest equivalents (vi.mock, vi.fn)");
+		}
+		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");
+		sections.push("");
+		sections.push("A new `oxlint.config.ts` has been generated using `defineConfig` from the `oxlint` package. The existing `.oxlintrc.json` needs to be migrated:");
+		sections.push("");
+		sections.push("1. Read `.oxlintrc.json` and compare its `rules` against the rules provided by `@bensandee/config/oxlint/recommended` (check `node_modules/@bensandee/config`). Most standard rules are already included in the recommended config.");
+		sections.push("2. If there are any custom rules, overrides, settings, or `jsPlugins` not covered by the recommended config, add them to `oxlint.config.ts` alongside the `extends`.");
+		sections.push("3. Delete `.oxlintrc.json`.");
+		sections.push("4. Run `pnpm lint` to verify the new config works correctly.");
+		sections.push("");
+	} else if (oxlintWasSkipped && detected.hasOxlintConfig) {
+		sections.push("### Verify oxlint.config.ts includes recommended rules");
+		sections.push("");
+		sections.push("The existing `oxlint.config.ts` was kept as-is. Verify that it extends the recommended config from `@bensandee/config/oxlint`:");
+		sections.push("");
+		sections.push("1. Open `oxlint.config.ts` and check that it imports and extends `@bensandee/config/oxlint/recommended`.");
+		sections.push("2. The expected pattern is:");
+		sections.push("   ```ts");
+		sections.push("   import recommended from \"@bensandee/config/oxlint/recommended\";");
+		sections.push("   import { defineConfig } from \"oxlint\";");
+		sections.push("");
+		sections.push("   export default defineConfig({ extends: [recommended] });");
+		sections.push("   ```");
+		sections.push("3. If it uses a different pattern, update it to extend the recommended config while preserving any project-specific customizations.");
+		sections.push("4. Run `pnpm lint` to verify the config works correctly.");
+		sections.push("");
+	}
+	if (config.structure === "monorepo" && !detected.hasPnpmWorkspace) {
+		sections.push("### Migrate to monorepo structure");
+		sections.push("");
+		sections.push("This project was converted from a single repo to a monorepo. Complete the migration:");
+		sections.push("");
+		sections.push("1. Move existing source into `packages/<name>/` (using the existing package name)");
+		sections.push("2. Split the root `package.json` into a root workspace manifest + package-level `package.json`");
+		sections.push("3. Move the existing `tsconfig.json` into the package and update the root tsconfig with project references");
+		sections.push("4. Create a package-level `tsdown.config.ts` in the new package");
+		sections.push("5. Update any import paths or build scripts affected by the move");
+		sections.push("");
+	}
+	const skippedConfigs = skipped.filter((r) => r.filePath !== "ci" && r.description !== "Not a monorepo");
+	if (skippedConfigs.length > 0) {
+		sections.push("### Review skipped files");
+		sections.push("");
+		sections.push("The following files were left unchanged. Review them for compatibility:");
+		sections.push("");
+		for (const r of skippedConfigs) sections.push(`- \`${r.filePath}\` — ${r.description}`);
+		sections.push("");
+	}
+	if (results.some((r) => r.filePath === "test/example.test.ts" && r.action === "created")) {
+		sections.push("### Generate tests");
+		sections.push("");
+		sections.push("A starter test was created at `test/example.test.ts`. Now:");
+		sections.push("");
+		sections.push("1. Review the existing source code in `src/`");
+		sections.push("2. Create additional test files following the starter test's patterns (import style, describe/it structure)");
+		sections.push("3. Focus on edge cases and core business logic");
+		sections.push("4. Aim for meaningful coverage of exported functions and key code paths");
+		sections.push("");
+	}
+	sections.push("## Ground rules");
+	sections.push("");
+	sections.push("When resolving errors from the checklist below, prefer fixing the root cause over suppressing the issue. For example:");
+	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("- **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.");
+	sections.push("");
+	sections.push("## Verification checklist");
+	sections.push("");
+	sections.push("Run each of these commands and fix any errors before moving on:");
+	sections.push("");
+	sections.push("1. `pnpm install`");
+	const updateCmd = `pnpm update --latest ${getAddedDevDepNames(config).join(" ")}`;
+	sections.push(`2. \`${updateCmd}\` — bump added dependencies to their latest versions`);
+	sections.push("3. `pnpm typecheck` — fix any type errors");
+	sections.push("4. `pnpm build` — fix any build errors");
+	sections.push("5. `pnpm test` — fix any test failures");
+	sections.push("6. `pnpm lint` — fix the code to satisfy lint rules");
+	sections.push("7. `pnpm knip` — remove unused exports, dependencies, and dead code");
+	sections.push("8. `pnpm format` — fix any formatting issues");
+	sections.push("");
+	return sections.join("\n");
+}
+
+//#endregion
+//#region src/generators/tsconfig.ts
+async function generateTsconfig(ctx) {
+	const filePath = "tsconfig.json";
+	const existing = ctx.read(filePath);
+	if (ctx.config.structure === "monorepo") return [generateMonorepoRootTsconfig(ctx, existing), ...ctx.config.detectPackageTypes ? generateMonorepoPackageTsconfigs(ctx) : []];
+	const extendsValue = `@bensandee/config/tsconfig/${ctx.config.projectType}`;
+	const config = {
+		extends: extendsValue,
+		include: ["src"],
+		exclude: ["node_modules", "dist"]
+	};
+	if (existing) {
+		const parsed = parseTsconfig(existing);
+		const changes = [];
+		if (!parsed.extends) {
+			parsed.extends = extendsValue;
+			changes.push(`added extends: ${extendsValue}`);
+		}
+		const existingInclude = parsed.include ?? [];
+		for (const entry of config.include) if (!existingInclude.includes(entry)) {
+			existingInclude.push(entry);
+			changes.push(`added "${entry}" to include`);
+		}
+		parsed.include = existingInclude;
+		if (changes.length === 0) return [{
+			filePath,
+			action: "skipped",
+			description: "Already up to spec"
+		}];
+		ctx.write(filePath, JSON.stringify(parsed, null, 2) + "\n");
+		return [{
+			filePath,
+			action: "updated",
+			description: changes.join(", ")
+		}];
+	}
+	ctx.write(filePath, JSON.stringify(config, null, 2) + "\n");
+	return [{
+		filePath,
+		action: "created",
+		description: `Generated tsconfig.json with @bensandee/config/tsconfig/${ctx.config.projectType}`
+	}];
+}
+function generateMonorepoRootTsconfig(ctx, existing) {
+	const filePath = "tsconfig.json";
+	if (existing) {
+		const parsed = parseTsconfig(existing);
+		if (!parsed.references) {
+			parsed.files = [];
+			parsed.references = [];
+			ctx.write(filePath, JSON.stringify(parsed, null, 2) + "\n");
+			return {
+				filePath,
+				action: "updated",
+				description: "Added project references structure for monorepo"
+			};
+		}
+		return {
+			filePath,
+			action: "skipped",
+			description: "Already has project references"
+		};
+	}
+	ctx.write(filePath, JSON.stringify({
+		files: [],
+		references: []
+	}, null, 2) + "\n");
+	return {
+		filePath,
+		action: "created",
+		description: "Generated monorepo root tsconfig.json with project references"
+	};
+}
+function generateMonorepoPackageTsconfigs(ctx) {
+	const packages = getMonorepoPackages(ctx.targetDir);
+	const results = [];
+	for (const pkg of packages) {
+		const relDir = path.relative(ctx.targetDir, pkg.dir);
+		const filePath = path.join(relDir, "tsconfig.json");
+		const existing = ctx.read(filePath);
+		const projectType = detectProjectType(pkg.dir);
+		const extendsValue = `@bensandee/config/tsconfig/${projectType}`;
+		if (existing) {
+			const parsed = parseTsconfig(existing);
+			const changes = [];
+			if (parsed.extends !== extendsValue) {
+				const prev = parsed.extends;
+				parsed.extends = extendsValue;
+				changes.push(prev ? `changed extends: ${String(prev)} → ${extendsValue}` : `added extends: ${extendsValue}`);
+			}
+			const existingInclude = parsed.include ?? [];
+			if (!existingInclude.includes("src")) {
+				existingInclude.push("src");
+				changes.push("added \"src\" to include");
+			}
+			parsed.include = existingInclude;
+			if (changes.length === 0) {
+				results.push({
+					filePath,
+					action: "skipped",
+					description: `Already up to spec (${projectType})`
+				});
+				continue;
+			}
+			ctx.write(filePath, JSON.stringify(parsed, null, 2) + "\n");
+			results.push({
+				filePath,
+				action: "updated",
+				description: changes.join(", ")
+			});
+		} else {
+			const config = {
+				extends: extendsValue,
+				include: ["src"],
+				exclude: ["node_modules", "dist"]
+			};
+			ctx.write(filePath, JSON.stringify(config, null, 2) + "\n");
+			results.push({
+				filePath,
+				action: "created",
+				description: `Generated tsconfig.json with @bensandee/config/tsconfig/${projectType} (detected ${projectType})`
+			});
+		}
+	}
+	return results;
+}
+
+//#endregion
+//#region src/generators/vitest.ts
+const VITEST_CONFIG = `import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    include: ["test/**/*.test.ts"],
+  },
+});
+`;
+const STARTER_TEST = `import { describe, it, expect } from "vitest";
+
+describe("example", () => {
+  it("should pass a basic assertion", () => {
+    expect(1 + 1).toBe(2);
+  });
+});
+`;
+async function generateVitest(ctx) {
+	const results = [];
+	if (!ctx.config.setupVitest) return [{
+		filePath: "vitest.config.ts",
+		action: "skipped",
+		description: "Vitest setup not requested"
+	}];
+	if (ctx.config.structure === "monorepo") return [{
+		filePath: "vitest.config.ts",
+		action: "skipped",
+		description: "Monorepo: vitest config belongs in individual packages"
+	}];
+	const configPath = "vitest.config.ts";
+	if (ctx.exists(configPath)) if (await ctx.confirmOverwrite(configPath) === "skip") results.push({
+		filePath: configPath,
+		action: "skipped",
+		description: "Existing config preserved"
+	});
+	else {
+		ctx.write(configPath, VITEST_CONFIG);
+		results.push({
+			filePath: configPath,
+			action: "updated",
+			description: "Replaced vitest config"
+		});
+	}
+	else {
+		ctx.write(configPath, VITEST_CONFIG);
+		results.push({
+			filePath: configPath,
+			action: "created",
+			description: "Generated vitest.config.ts"
+		});
+	}
+	const testPath = "test/example.test.ts";
+	if (!ctx.exists("test")) {
+		ctx.write(testPath, STARTER_TEST);
+		results.push({
+			filePath: testPath,
+			action: "created",
+			description: "Generated starter test file"
+		});
+	}
+	return results;
+}
+
+//#endregion
+//#region src/generators/oxlint.ts
+const CONFIG_WITH_LINT_RULES = `import recommended from "@bensandee/config/oxlint/recommended";
+import { defineConfig } from "oxlint";
+
+export default defineConfig({
+  extends: [recommended],
+});
+`;
+const CONFIG_PRESET_ONLY = `import { presetRules } from "@bensandee/config/oxlint";
+import { defineConfig } from "oxlint";
+
+export default defineConfig({
+  rules: presetRules,
+});
+`;
+async function generateOxlint(ctx) {
+	const filePath = "oxlint.config.ts";
+	const content = ctx.config.useLintRules ? CONFIG_WITH_LINT_RULES : CONFIG_PRESET_ONLY;
+	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: "User chose to keep existing"
+		};
+	}
+	ctx.write(filePath, content);
+	return {
+		filePath,
+		action: existing ? "updated" : "created",
+		description: "Generated oxlint.config.ts"
+	};
+}
+
+//#endregion
+//#region src/generators/formatter.ts
+const OXFMT_CONFIG = `{}\n`;
+const PRETTIER_CONFIG = `{
+  "semi": true,
+  "singleQuote": false,
+  "trailingComma": "all",
+  "tabWidth": 2,
+  "printWidth": 120
+}
+`;
+async function generateFormatter(ctx) {
+	if (ctx.config.formatter === "oxfmt") return generateOxfmt(ctx);
+	return generatePrettier(ctx);
+}
+async function generateOxfmt(ctx) {
+	const filePath = ".oxfmtrc.json";
+	const existed = ctx.exists(filePath);
+	if (existed) {
+		if (await ctx.confirmOverwrite(filePath) === "skip") return {
+			filePath,
+			action: "skipped",
+			description: "Existing oxfmt config preserved"
+		};
+	}
+	ctx.write(filePath, OXFMT_CONFIG);
+	return {
+		filePath,
+		action: existed ? "updated" : "created",
+		description: "Generated .oxfmtrc.json"
+	};
+}
+async function generatePrettier(ctx) {
+	const filePath = ".prettierrc";
+	if (ctx.exists(filePath)) return {
+		filePath,
+		action: "skipped",
+		description: "Existing prettier config preserved"
+	};
+	ctx.write(filePath, PRETTIER_CONFIG);
+	return {
+		filePath,
+		action: "created",
+		description: "Generated .prettierrc"
+	};
+}
+
+//#endregion
+//#region src/generators/tsdown.ts
+const TSDOWN_CONFIG = `import { defineConfig } from "tsdown";
+
+export default defineConfig({
+  entry: ["src/index.ts"],
+});
+`;
+async function generateTsdown(ctx) {
+	const filePath = "tsdown.config.ts";
+	if (ctx.config.structure === "monorepo") return {
+		filePath,
+		action: "skipped",
+		description: "Monorepo: tsdown config belongs in individual packages"
+	};
+	if (ctx.exists(filePath)) {
+		if (await ctx.confirmOverwrite(filePath) === "skip") return {
+			filePath,
+			action: "skipped",
+			description: "Existing tsdown config preserved"
+		};
+	}
+	ctx.write(filePath, TSDOWN_CONFIG);
+	return {
+		filePath,
+		action: "created",
+		description: "Generated tsdown.config.ts"
+	};
+}
+
+//#endregion
+//#region src/generators/gitignore.ts
+const STANDARD_ENTRIES = [
+	"node_modules/",
+	"dist/",
+	"*.tsbuildinfo",
+	".env",
+	".env.*",
+	"!.env.example",
+	".tooling-migrate.md"
+];
+async function generateGitignore(ctx) {
+	const filePath = ".gitignore";
+	const existing = ctx.read(filePath);
+	if (existing) {
+		const existingLines = new Set(existing.split("\n").map((line) => line.trim()).filter((line) => line.length > 0));
+		const missing = STANDARD_ENTRIES.filter((entry) => !existingLines.has(entry));
+		if (missing.length === 0) return {
+			filePath,
+			action: "skipped",
+			description: "Already has all standard entries"
+		};
+		const updated = existing.trimEnd() + "\n\n# Added by @bensandee/tooling\n" + missing.join("\n") + "\n";
+		ctx.write(filePath, updated);
+		return {
+			filePath,
+			action: "updated",
+			description: `Appended ${String(missing.length)} missing entries`
+		};
+	}
+	ctx.write(filePath, STANDARD_ENTRIES.join("\n") + "\n");
+	return {
+		filePath,
+		action: "created",
+		description: "Generated .gitignore"
+	};
+}
+
+//#endregion
+//#region src/generators/ci.ts
+function hasEnginesNode$1(ctx) {
+	return typeof ctx.packageJson?.["engines"]?.["node"] === "string";
+}
+function ciWorkflow(isMonorepo, nodeVersionYaml) {
+	return `name: CI
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: pnpm/action-setup@v4
+      - uses: actions/setup-node@v4
+        with:
+          ${nodeVersionYaml}
+          cache: pnpm
+      - run: pnpm install --frozen-lockfile
+      - run: ${isMonorepo ? "pnpm -r --parallel run typecheck" : "pnpm typecheck"}
+      - run: pnpm lint
+      - run: ${isMonorepo ? "pnpm -r build" : "pnpm build"}
+      - run: ${isMonorepo ? "pnpm -r test" : "pnpm test"}
+      - run: pnpm format --check
+      - run: pnpm knip
+`;
+}
+async function generateCi(ctx) {
+	if (ctx.config.ci === "none") return {
+		filePath: "ci",
+		action: "skipped",
+		description: "CI workflow not requested"
+	};
+	const isMonorepo = ctx.config.structure === "monorepo";
+	const isGitHub = ctx.config.ci === "github";
+	const nodeVersionYaml = hasEnginesNode$1(ctx) ? "node-version-file: package.json" : "node-version: \"24\"";
+	const filePath = isGitHub ? ".github/workflows/check.yml" : ".forgejo/workflows/check.yml";
+	const content = ciWorkflow(isMonorepo, nodeVersionYaml);
+	if (ctx.exists(filePath)) {
+		if (await ctx.confirmOverwrite(filePath) === "skip") return {
+			filePath,
+			action: "skipped",
+			description: "Existing CI workflow preserved"
+		};
+	}
+	ctx.write(filePath, content);
+	return {
+		filePath,
+		action: "created",
+		description: `Generated ${isGitHub ? "GitHub" : "Forgejo"} Actions CI workflow`
+	};
+}
+
+//#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/**"]
+		}
+	}
+};
+async function generateKnip(ctx) {
+	const filePath = "knip.json";
+	const existing = ctx.read(filePath);
+	const isMonorepo = ctx.config.structure === "monorepo";
+	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(", ")
+		};
+	}
+	const config = isMonorepo ? KNIP_CONFIG_MONOREPO : KNIP_CONFIG_SINGLE;
+	ctx.write(filePath, JSON.stringify(config, null, 2) + "\n");
+	return {
+		filePath,
+		action: "created",
+		description: "Generated knip.json for dead code analysis"
+	};
+}
+
+//#endregion
+//#region src/generators/renovate.ts
+const SHARED_PRESET = "@bensandee/config";
+async function generateRenovate(ctx) {
+	const filePath = "renovate.json";
+	if (!ctx.config.setupRenovate) return {
+		filePath,
+		action: "skipped",
+		description: "Renovate not requested"
+	};
+	const existing = ctx.read(filePath);
+	if (existing) {
+		const parsed = parseRenovateJson(existing);
+		const existingExtends = parsed.extends ?? [];
+		if (!existingExtends.includes(SHARED_PRESET)) {
+			existingExtends.unshift(SHARED_PRESET);
+			parsed.extends = existingExtends;
+			ctx.write(filePath, JSON.stringify(parsed, null, 2) + "\n");
+			return {
+				filePath,
+				action: "updated",
+				description: `Added extends: ${SHARED_PRESET}`
+			};
+		}
+		return {
+			filePath,
+			action: "skipped",
+			description: "Already extends shared config"
+		};
+	}
+	const config = {
+		$schema: "https://docs.renovatebot.com/renovate-schema.json",
+		extends: [SHARED_PRESET]
+	};
+	ctx.write(filePath, JSON.stringify(config, null, 2) + "\n");
+	return {
+		filePath,
+		action: "created",
+		description: "Generated renovate.json extending shared config"
+	};
+}
+
+//#endregion
+//#region src/generators/pnpm-workspace.ts
+const WORKSPACE_YAML = `packages:
+  - "packages/*"
+`;
+async function generatePnpmWorkspace(ctx) {
+	const filePath = "pnpm-workspace.yaml";
+	if (ctx.config.structure !== "monorepo") return {
+		filePath,
+		action: "skipped",
+		description: "Not a monorepo"
+	};
+	if (ctx.exists(filePath)) return {
+		filePath,
+		action: "skipped",
+		description: "pnpm-workspace.yaml already exists"
+	};
+	ctx.write(filePath, WORKSPACE_YAML);
+	return {
+		filePath,
+		action: "created",
+		description: "Generated pnpm-workspace.yaml"
+	};
+}
+
+//#endregion
+//#region src/generators/claude-settings.ts
+const ClaudeSettingsSchema = z.object({
+	permissions: z.object({
+		allow: z.array(z.string()).default([]),
+		deny: z.array(z.string()).default([])
+	}).default({
+		allow: [],
+		deny: []
+	}),
+	instructions: z.array(z.string()).default([])
+});
+function parseClaudeSettings(raw) {
+	try {
+		const result = ClaudeSettingsSchema.safeParse(JSON.parse(raw));
+		return result.success ? result.data : void 0;
+	} catch {
+		return;
+	}
+}
+function buildSettings(ctx) {
+	const pm = "pnpm";
+	const allow = [
+		`Bash(${pm} install)`,
+		`Bash(${pm} install *)`,
+		`Bash(${pm} add *)`,
+		`Bash(${pm} update *)`,
+		`Bash(${pm} view *)`,
+		`Bash(${pm} list)`,
+		`Bash(${pm} list *)`,
+		"Bash(npm view *)",
+		"Bash(npm info *)",
+		"Bash(npm show *)",
+		`Bash(${pm} build)`,
+		`Bash(${pm} -r build)`,
+		`Bash(${pm} dev)`,
+		`Bash(${pm} test)`,
+		`Bash(${pm} test *)`,
+		`Bash(${pm} -r test)`,
+		`Bash(${pm} vitest)`,
+		`Bash(${pm} vitest *)`,
+		`Bash(${pm} exec vitest)`,
+		`Bash(${pm} exec vitest *)`,
+		`Bash(${pm} exec oxfmt)`,
+		`Bash(${pm} exec oxfmt *)`,
+		`Bash(${pm} typecheck)`,
+		`Bash(${pm} -r --parallel run typecheck)`,
+		`Bash(${pm} tsc *)`,
+		`Bash(${pm} exec tsc *)`,
+		`Bash(${pm} lint)`,
+		`Bash(${pm} lint *)`,
+		`Bash(${pm} format)`,
+		`Bash(${pm} format *)`,
+		`Bash(${pm} knip)`,
+		`Bash(${pm} knip *)`,
+		`Bash(${pm} check)`,
+		`Bash(${pm} exec oxlint *)`,
+		`Bash(${pm} exec knip *)`,
+		"Bash(git status *)",
+		"Bash(git log *)",
+		"Bash(git diff *)",
+		"Bash(git branch *)",
+		"Bash(git show *)",
+		"Bash(git rev-parse *)",
+		"Bash(ls *)",
+		"Bash(cat *)",
+		"Bash(head *)",
+		"Bash(tail *)",
+		"Bash(wc *)",
+		"Bash(find *)",
+		"Bash(which *)",
+		"Bash(node -e *)",
+		"Bash(node -p *)"
+	];
+	if (ctx.config.structure === "monorepo") allow.push(`Bash(${pm} --filter *)`, `Bash(${pm} -r *)`);
+	return {
+		permissions: {
+			allow,
+			deny: [
+				"Bash(npx *)",
+				"Bash(git push *)",
+				"Bash(git push)",
+				"Bash(git reset --hard *)",
+				"Bash(rm -rf *)"
+			]
+		},
+		instructions: [
+			"Use pnpm, not npm/yarn/npx. Run binaries with `pnpm exec`.",
+			"No typecasts (as/any). Use zod schemas, type guards, or narrowing instead.",
+			"Fix lint violations instead of suppressing them. Only add disable comments when suppression is genuinely the best option."
+		]
+	};
+}
+async function generateClaudeSettings(ctx) {
+	const filePath = ".claude/settings.json";
+	const existing = ctx.read(filePath);
+	const generated = buildSettings(ctx);
+	if (existing) {
+		const parsed = parseClaudeSettings(existing);
+		if (!parsed) return {
+			filePath,
+			action: "skipped",
+			description: "Could not parse existing settings"
+		};
+		const missingAllow = generated.permissions.allow.filter((rule) => !parsed.permissions.allow.includes(rule));
+		const missingDeny = generated.permissions.deny.filter((rule) => !parsed.permissions.deny.includes(rule));
+		const missingInstructions = generated.instructions.filter((inst) => !parsed.instructions.includes(inst));
+		if (missingAllow.length === 0 && missingDeny.length === 0 && missingInstructions.length === 0) return {
+			filePath,
+			action: "skipped",
+			description: "Already has all rules and instructions"
+		};
+		parsed.permissions.allow = [...parsed.permissions.allow, ...missingAllow];
+		parsed.permissions.deny = [...parsed.permissions.deny, ...missingDeny];
+		parsed.instructions = [...parsed.instructions, ...missingInstructions];
+		const added = missingAllow.length + missingDeny.length + missingInstructions.length;
+		ctx.write(filePath, JSON.stringify(parsed, null, 2) + "\n");
+		return {
+			filePath,
+			action: "updated",
+			description: `Added ${String(added)} rules/instructions`
+		};
+	}
+	ctx.write(filePath, JSON.stringify(generated, null, 2) + "\n");
+	return {
+		filePath,
+		action: "created",
+		description: "Generated .claude/settings.json with safe operation permissions"
+	};
+}
+
+//#endregion
+//#region src/generators/release-it.ts
+function buildConfig$2(ci, isMonorepo) {
+	const config = {
+		$schema: "https://unpkg.com/release-it/schema/release-it.json",
+		git: {
+			commitMessage: "chore: release v${version}",
+			tagName: "v${version}"
+		},
+		npm: { publish: true }
+	};
+	if (ci === "github") config["github"] = { release: true };
+	const plugins = {};
+	if (ci === "forgejo") plugins["@bensandee/release-it-forgejo"] = { release: true };
+	if (isMonorepo) {
+		config["npm"] = {
+			publish: true,
+			allowSameVersion: true
+		};
+		plugins["@release-it/bumper"] = { out: "packages/*/package.json" };
+	}
+	if (Object.keys(plugins).length > 0) config["plugins"] = plugins;
+	return config;
+}
+async function generateReleaseIt(ctx) {
+	const filePath = ".release-it.json";
+	if (ctx.config.releaseStrategy !== "release-it") return {
+		filePath,
+		action: "skipped",
+		description: "release-it not requested"
+	};
+	const content = JSON.stringify(buildConfig$2(ctx.config.ci, ctx.config.structure === "monorepo"), null, 2) + "\n";
+	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 release-it config preserved"
+		};
+	}
+	ctx.write(filePath, content);
+	return {
+		filePath,
+		action: existing ? "updated" : "created",
+		description: "Generated .release-it.json"
+	};
+}
+
+//#endregion
+//#region src/generators/changesets.ts
+function buildConfig$1() {
+	return {
+		$schema: "https://unpkg.com/@changesets/config@3.1.1/schema.json",
+		changelog: "@changesets/cli/changelog",
+		commit: false,
+		fixed: [],
+		linked: [],
+		access: "public",
+		baseBranch: "main",
+		updateInternalDependencies: "patch",
+		ignore: []
+	};
+}
+async function generateChangesets(ctx) {
+	const filePath = ".changeset/config.json";
+	if (ctx.config.releaseStrategy !== "changesets") return {
+		filePath,
+		action: "skipped",
+		description: "Changesets not requested"
+	};
+	const content = JSON.stringify(buildConfig$1(), null, 2) + "\n";
+	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 changesets config preserved"
+		};
+	}
+	ctx.write(filePath, content);
+	return {
+		filePath,
+		action: existing ? "updated" : "created",
+		description: "Generated .changeset/config.json"
+	};
+}
+
+//#endregion
+//#region src/generators/release-ci.ts
+function hasEnginesNode(ctx) {
+	return typeof ctx.packageJson?.["engines"]?.["node"] === "string";
+}
+function commonSteps(nodeVersionYaml) {
+	return `      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: pnpm/action-setup@v4
+      - uses: actions/setup-node@v4
+        with:
+          ${nodeVersionYaml}
+          cache: pnpm
+          registry-url: "https://registry.npmjs.org"
+      - run: pnpm install --frozen-lockfile
+      - run: pnpm build`;
+}
+function releaseItWorkflow(ci, nodeVersionYaml) {
+	const isGitHub = ci === "github";
+	const permissions = isGitHub ? `
+permissions:
+  contents: write
+` : "";
+	const tokenEnv = isGitHub ? `GITHUB_TOKEN: \${{ github.token }}` : `FORGEJO_TOKEN: \${{ secrets.FORGEJO_TOKEN }}`;
+	return `name: Release
+on:
+  workflow_dispatch:
+${permissions}
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+${commonSteps(nodeVersionYaml)}
+      - run: pnpm release-it --ci
+        env:
+          ${tokenEnv}
+          NODE_AUTH_TOKEN: \${{ secrets.NPM_TOKEN }}
+`;
+}
+function commitAndTagVersionWorkflow(ci, nodeVersionYaml) {
+	const isGitHub = ci === "github";
+	const permissions = isGitHub ? `
+permissions:
+  contents: write
+` : "";
+	const gitConfigStep = `
+      - name: Configure git
+        run: |
+          git config user.name "${isGitHub ? "github-actions[bot]" : "forgejo-actions[bot]"}"
+          git config user.email "${isGitHub ? "github-actions[bot]@users.noreply.github.com" : "forgejo-actions[bot]@noreply.localhost"}"`;
+	const releaseStep = isGitHub ? `
+      - name: Release
+        env:
+          GITHUB_TOKEN: \${{ github.token }}
+          NODE_AUTH_TOKEN: \${{ secrets.NPM_TOKEN }}
+        run: |
+          pnpm exec commit-and-tag-version
+          git push --follow-tags
+          TAG=$(git describe --tags --abbrev=0)
+          pnpm publish --no-git-checks
+          gh release create "$TAG" --generate-notes` : `
+      - name: Release
+        env:
+          FORGEJO_SERVER_URL: \${{ github.server_url }}
+          FORGEJO_REPOSITORY: \${{ github.repository }}
+          FORGEJO_TOKEN: \${{ secrets.FORGEJO_TOKEN }}
+          NODE_AUTH_TOKEN: \${{ secrets.NPM_TOKEN }}
+        run: |
+          pnpm exec commit-and-tag-version
+          git push --follow-tags
+          TAG=$(git describe --tags --abbrev=0)
+          pnpm publish --no-git-checks
+          pnpm exec tooling release:create-forgejo-release --tag "$TAG"`;
+	return `name: Release
+on:
+  workflow_dispatch:
+${permissions}
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+${commonSteps(nodeVersionYaml)}${gitConfigStep}${releaseStep}
+`;
+}
+function changesetsWorkflow(ci, nodeVersionYaml) {
+	if (ci === "github") return `name: Release
+on:
+  push:
+    branches:
+      - main
+
+permissions:
+  contents: write
+  pull-requests: write
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+${commonSteps(nodeVersionYaml)}
+      - uses: changesets/action@v1
+        with:
+          publish: pnpm changeset publish
+          version: pnpm changeset version
+        env:
+          GITHUB_TOKEN: \${{ github.token }}
+          NPM_TOKEN: \${{ secrets.NPM_TOKEN }}
+`;
+	return `name: Release
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+${commonSteps(nodeVersionYaml)}
+      - name: Configure git
+        run: |
+          git config user.name "forgejo-actions[bot]"
+          git config user.email "forgejo-actions[bot]@noreply.localhost"
+      - name: Release
+        env:
+          FORGEJO_SERVER_URL: \${{ github.server_url }}
+          FORGEJO_REPOSITORY: \${{ github.repository }}
+          FORGEJO_TOKEN: \${{ secrets.FORGEJO_TOKEN }}
+          NODE_AUTH_TOKEN: \${{ secrets.NPM_TOKEN }}
+        run: pnpm exec tooling release:changesets
+`;
+}
+function buildWorkflow(strategy, ci, nodeVersionYaml) {
+	switch (strategy) {
+		case "release-it": return releaseItWorkflow(ci, nodeVersionYaml);
+		case "commit-and-tag-version": return commitAndTagVersionWorkflow(ci, nodeVersionYaml);
+		case "changesets": return changesetsWorkflow(ci, nodeVersionYaml);
+		default: return null;
+	}
+}
+async function generateReleaseCi(ctx) {
+	const filePath = "release-ci";
+	if (ctx.config.releaseStrategy === "none" || ctx.config.ci === "none") return {
+		filePath,
+		action: "skipped",
+		description: "Release CI workflow not applicable"
+	};
+	const isGitHub = ctx.config.ci === "github";
+	const workflowPath = isGitHub ? ".github/workflows/release.yml" : ".forgejo/workflows/release.yml";
+	const nodeVersionYaml = hasEnginesNode(ctx) ? "node-version-file: package.json" : "node-version: \"24\"";
+	const content = buildWorkflow(ctx.config.releaseStrategy, ctx.config.ci, nodeVersionYaml);
+	if (!content) return {
+		filePath,
+		action: "skipped",
+		description: "Release CI workflow not applicable"
+	};
+	if (ctx.exists(workflowPath)) {
+		if (await ctx.confirmOverwrite(workflowPath) === "skip") return {
+			filePath: workflowPath,
+			action: "skipped",
+			description: "Existing release workflow preserved"
+		};
+	}
+	ctx.write(workflowPath, content);
+	return {
+		filePath: workflowPath,
+		action: "created",
+		description: `Generated ${isGitHub ? "GitHub" : "Forgejo"} Actions release workflow`
+	};
+}
+
+//#endregion
+//#region src/generators/lint-staged.ts
+function buildConfig(formatter) {
+	return `export default {\n  "*": "${formatter === "prettier" ? "prettier --write" : "oxfmt"}",\n};\n`;
+}
+const HUSKY_PRE_COMMIT = "pnpm exec lint-staged\n";
+async function generateLintStaged(ctx) {
+	const filePath = "lint-staged.config.mjs";
+	const huskyPath = ".husky/pre-commit";
+	const content = buildConfig(ctx.config.formatter);
+	const existing = ctx.read(filePath);
+	if (ctx.read(huskyPath) !== HUSKY_PRE_COMMIT) ctx.write(huskyPath, HUSKY_PRE_COMMIT);
+	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"
+		};
+	}
+	ctx.write(filePath, content);
+	return {
+		filePath,
+		action: existing ? "updated" : "created",
+		description: "Generated lint-staged config and husky pre-commit hook"
+	};
+}
+
+//#endregion
+//#region src/commands/repo-init.ts
+const initCommand = defineCommand({
+	meta: {
+		name: "repo:init",
+		description: "Interactive setup wizard"
+	},
+	args: {
+		dir: {
+			type: "positional",
+			description: "Target directory (default: current directory)",
+			required: false
+		},
+		yes: {
+			type: "boolean",
+			alias: "y",
+			description: "Accept all defaults (non-interactive)"
+		},
+		"lint-rules": {
+			type: "boolean",
+			description: "Include @bensandee/lint-rules (default: true)"
+		},
+		"no-ci": {
+			type: "boolean",
+			description: "Skip CI workflow generation"
+		},
+		"no-prompt": {
+			type: "boolean",
+			description: "Skip migration prompt generation"
+		}
+	},
+	async run({ args }) {
+		const targetDir = path.resolve(args.dir ?? ".");
+		await runInit(args.yes ? buildDefaultConfig(targetDir, {
+			lintRules: args["lint-rules"] === 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 result = await p.select({
+			message: `${relativePath} already exists. What do you want to do?`,
+			options: [{
+				value: "overwrite",
+				label: "Overwrite"
+			}, {
+				value: "skip",
+				label: "Skip"
+			}]
+		});
+		if (p.isCancel(result)) return "skip";
+		return result;
+	}));
+	const results = [];
+	const s = p.spinner();
+	s.start("Generating configuration files...");
+	results.push(await generatePackageJson(ctx));
+	results.push(await generatePnpmWorkspace(ctx));
+	results.push(...await generateTsconfig(ctx));
+	results.push(await generateTsdown(ctx));
+	results.push(await generateOxlint(ctx));
+	results.push(await generateFormatter(ctx));
+	results.push(await generateLintStaged(ctx));
+	results.push(await generateGitignore(ctx));
+	results.push(await generateKnip(ctx));
+	results.push(await generateRenovate(ctx));
+	results.push(await generateCi(ctx));
+	results.push(await generateClaudeSettings(ctx));
+	results.push(await generateReleaseIt(ctx));
+	results.push(await generateChangesets(ctx));
+	results.push(await generateReleaseCi(ctx));
+	const vitestResults = await generateVitest(ctx);
+	results.push(...vitestResults);
+	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 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 (skipped.length > 0) summaryLines.push(`Skipped: ${skipped.map((r) => r.filePath).join(", ")}`);
+	p.note(summaryLines.join("\n"), "Summary");
+	if (!options.noPrompt) {
+		const prompt = generateMigratePrompt(results, config, detected);
+		const promptPath = ".tooling-migrate.md";
+		ctx.write(promptPath, prompt);
+		p.log.info(`Migration prompt written to ${promptPath}`);
+		p.log.info("Paste its contents into Claude Code to finish the migration.");
+	}
+	const updateCmd = `pnpm update --latest ${getAddedDevDepNames(config).join(" ")}`;
+	p.note([
+		"1. Run: pnpm install",
+		`2. Run: ${updateCmd}`,
+		"3. Run: pnpm typecheck",
+		"4. Run: pnpm build",
+		"5. Run: pnpm test",
+		...options.noPrompt ? [] : ["6. Paste .tooling-migrate.md into Claude Code for cleanup"]
+	].join("\n"), "Next steps");
+	return results;
+}
+
+//#endregion
+//#region src/commands/repo-update.ts
+const updateCommand = defineCommand({
+	meta: {
+		name: "repo:update",
+		description: "Add missing config (never overwrites)"
+	},
+	args: { dir: {
+		type: "positional",
+		description: "Target directory (default: current directory)",
+		required: false
+	} },
+	async run({ args }) {
+		await runUpdate(path.resolve(args.dir ?? "."));
+	}
+});
+async function runUpdate(targetDir) {
+	return runInit(buildDefaultConfig(targetDir, {}), {
+		noPrompt: true,
+		confirmOverwrite: async () => "skip"
+	});
+}
+
+//#endregion
+//#region src/utils/errors.ts
+/** An error caused by an external transient condition (network, API rate limit, etc). */
+var TransientError = class extends Error {
+	name = "TransientError";
+};
+/** An error indicating a fatal misconfiguration or invariant violation. */
+var FatalError = class extends Error {
+	name = "FatalError";
+};
+/** An error for conditions that should be unreachable. */
+var UnexpectedError = class extends Error {
+	name = "UnexpectedError";
+};
+
+//#endregion
+//#region src/utils/exec.ts
+/** Type guard for `execSync` errors that carry stdout/stderr/status. */
+function isExecSyncError(err) {
+	return err instanceof Error && "stdout" in err && typeof err.stdout === "string" && "stderr" in err && typeof err.stderr === "string" && "status" in err && typeof err.status === "number";
+}
+
+//#endregion
+//#region src/release/executor.ts
+/** Create an executor that runs real commands, fetches, and reads the filesystem. */
+function createRealExecutor() {
+	return {
+		exec(command, options) {
+			try {
+				return {
+					stdout: execSync(command, {
+						cwd: options?.cwd,
+						env: {
+							...process.env,
+							...options?.env
+						},
+						encoding: "utf-8",
+						stdio: [
+							"pipe",
+							"pipe",
+							"pipe"
+						]
+					}),
+					stderr: "",
+					exitCode: 0
+				};
+			} catch (err) {
+				if (isExecSyncError(err)) return {
+					stdout: err.stdout,
+					stderr: err.stderr,
+					exitCode: err.status
+				};
+				return {
+					stdout: "",
+					stderr: "",
+					exitCode: 1
+				};
+			}
+		},
+		fetch: globalThis.fetch,
+		listChangesetFiles(cwd) {
+			const dir = path.join(cwd, ".changeset");
+			try {
+				return readdirSync(dir).filter((f) => f.endsWith(".md") && f !== "README.md");
+			} catch {
+				return [];
+			}
+		},
+		listWorkspacePackages(cwd) {
+			const packagesDir = path.join(cwd, "packages");
+			const packages = [];
+			try {
+				for (const entry of readdirSync(packagesDir)) {
+					const pkgPath = path.join(packagesDir, entry, "package.json");
+					try {
+						const pkg = parsePackageJson(readFileSync(pkgPath, "utf-8"));
+						if (pkg?.name && pkg.version && !pkg.private) packages.push({
+							name: pkg.name,
+							version: pkg.version,
+							dir: entry
+						});
+					} catch (_error) {}
+				}
+			} catch (_error) {}
+			return packages;
+		},
+		readFile(filePath) {
+			try {
+				return readFileSync(filePath, "utf-8");
+			} catch {
+				return null;
+			}
+		}
+	};
+}
+/** 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 = [];
+	for (const line of output.split("\n")) {
+		const match = /New tag:\s+(\S+)/.exec(line);
+		if (match?.[1]) tags.push(match[1]);
+	}
+	return tags;
+}
+/** Map workspace packages to their expected tag strings (name@version). */
+function computeExpectedTags(packages) {
+	return packages.map((p) => `${p.name}@${p.version}`);
+}
+/** Parse `git ls-remote --tags` output into tag names, filtering out `^{}` dereference entries. */
+function parseRemoteTags(output) {
+	const tags = [];
+	for (const line of output.split("\n")) {
+		const match = /refs\/tags\/(.+)/.exec(line);
+		if (match?.[1] && !match[1].endsWith("^{}")) tags.push(match[1]);
+	}
+	return tags;
+}
+/**
+* Reconcile expected tags with what already exists on the remote.
+* Returns `(expected - remote) ∪ stdoutTags`, deduplicated.
+*/
+function reconcileTags(expectedTags, remoteTags, stdoutTags) {
+	const remoteSet = new Set(remoteTags);
+	const result = /* @__PURE__ */ new Set();
+	for (const tag of expectedTags) if (!remoteSet.has(tag)) result.add(tag);
+	for (const tag of stdoutTags) result.add(tag);
+	return [...result];
+}
+
+//#endregion
+//#region src/release/forgejo.ts
+const PullRequestSchema = z.array(z.object({ number: z.number() }));
+/** Find an open PR with the given head branch. Returns the PR number or null. */
+async function findOpenPr(executor, conn, head) {
+	const url = `${conn.serverUrl}/api/v1/repos/${conn.repository}/pulls?state=open&head=${head}`;
+	const res = await executor.fetch(url, { headers: { Authorization: `token ${conn.token}` } });
+	if (!res.ok) throw new TransientError(`Failed to list PRs: ${res.status} ${res.statusText}`);
+	const parsed = PullRequestSchema.safeParse(await res.json());
+	if (!parsed.success) throw new UnexpectedError(`Unexpected PR list response: ${parsed.error.message}`);
+	return parsed.data[0]?.number ?? null;
+}
+/** Create a new pull request. */
+async function createPr(executor, conn, options) {
+	const url = `${conn.serverUrl}/api/v1/repos/${conn.repository}/pulls`;
+	const payload = {
+		title: options.title,
+		head: options.head,
+		base: options.base
+	};
+	if (options.body) payload["body"] = options.body;
+	const res = await executor.fetch(url, {
+		method: "POST",
+		headers: {
+			Authorization: `token ${conn.token}`,
+			"Content-Type": "application/json"
+		},
+		body: JSON.stringify(payload)
+	});
+	if (!res.ok) throw new TransientError(`Failed to create PR: ${res.status} ${res.statusText}`);
+}
+/** Update an existing pull request's title and body. */
+async function updatePr(executor, conn, prNumber, options) {
+	const url = `${conn.serverUrl}/api/v1/repos/${conn.repository}/pulls/${String(prNumber)}`;
+	const res = await executor.fetch(url, {
+		method: "PATCH",
+		headers: {
+			Authorization: `token ${conn.token}`,
+			"Content-Type": "application/json"
+		},
+		body: JSON.stringify({
+			title: options.title,
+			body: options.body
+		})
+	});
+	if (!res.ok) throw new TransientError(`Failed to update 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);
+	const url = `${conn.serverUrl}/api/v1/repos/${conn.repository}/releases/tags/${encodedTag}`;
+	const res = await executor.fetch(url, { headers: { Authorization: `token ${conn.token}` } });
+	if (res.status === 200) return true;
+	if (res.status === 404) return false;
+	throw new TransientError(`Failed to check release for ${tag}: ${res.status} ${res.statusText}`);
+}
+/** Create a Forgejo release for a given tag. */
+async function createRelease(executor, conn, tag) {
+	const url = `${conn.serverUrl}/api/v1/repos/${conn.repository}/releases`;
+	const res = await executor.fetch(url, {
+		method: "POST",
+		headers: {
+			Authorization: `token ${conn.token}`,
+			"Content-Type": "application/json"
+		},
+		body: JSON.stringify({
+			tag_name: tag,
+			name: tag,
+			body: `Published ${tag}`
+		})
+	});
+	if (!res.ok) throw new TransientError(`Failed to create release for ${tag}: ${res.status} ${res.statusText}`);
+}
+
+//#endregion
+//#region src/release/version.ts
+const BRANCH = "changeset-release/main";
+/** Extract the latest changelog entry (content between first and second `## ` heading). */
+function extractLatestEntry(changelog) {
+	const lines = changelog.split("\n");
+	let start = -1;
+	let end = lines.length;
+	for (let i = 0; i < lines.length; i++) if (lines[i]?.startsWith("## ")) if (start === -1) start = i;
+	else {
+		end = i;
+		break;
+	}
+	if (start === -1) return null;
+	return lines.slice(start, end).join("\n").trim();
+}
+/** Read the root package.json name and version. */
+function readRootPackage(executor, cwd) {
+	const content = executor.readFile(path.join(cwd, "package.json"));
+	if (!content) return null;
+	const pkg = parsePackageJson(content);
+	if (!pkg?.name || !pkg.version) return null;
+	if (pkg.private) return null;
+	return {
+		name: pkg.name,
+		version: pkg.version
+	};
+}
+/** Determine which packages changed and collect their changelog entries. */
+function buildPrContent(executor, cwd, packagesBefore) {
+	const packagesAfter = executor.listWorkspacePackages(cwd);
+	if (!(packagesBefore.length > 0 || packagesAfter.length > 0)) {
+		const rootPkg = readRootPackage(executor, cwd);
+		if (rootPkg) {
+			const changelog = executor.readFile(path.join(cwd, "CHANGELOG.md"));
+			const entry = changelog ? extractLatestEntry(changelog) : null;
+			return {
+				title: `chore: release ${rootPkg.name}@${rootPkg.version}`,
+				body: entry ?? ""
+			};
+		}
+		return {
+			title: "chore: version packages",
+			body: ""
+		};
+	}
+	const beforeMap = new Map(packagesBefore.map((pkg) => [pkg.name, pkg.version]));
+	const changed = packagesAfter.filter((pkg) => beforeMap.get(pkg.name) !== pkg.version);
+	if (changed.length === 0) return {
+		title: "chore: version packages",
+		body: ""
+	};
+	const title = `chore: release ${changed.map((pkg) => `${pkg.name}@${pkg.version}`).join(", ")}`;
+	const entries = [];
+	for (const pkg of changed) {
+		const changelogPath = path.join(cwd, "packages", pkg.dir, "CHANGELOG.md");
+		const changelog = executor.readFile(changelogPath);
+		const entry = changelog ? extractLatestEntry(changelog) : null;
+		if (entry) {
+			const labeled = entry.replace(/^## .+/, `## ${pkg.name}@${pkg.version}`);
+			entries.push(labeled);
+		}
+	}
+	return {
+		title,
+		body: entries.join("\n\n")
+	};
+}
+/** Mode 1: version packages and create/update a PR. */
+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 });
+	const { title, body } = buildPrContent(executor, config.cwd, packagesBefore);
+	executor.exec("git add -A", { cwd: config.cwd });
+	if (executor.exec("git commit -m \"chore: version packages\"", { cwd: config.cwd }).exitCode !== 0) {
+		p.log.info("Nothing to commit after versioning");
+		return {
+			mode: "version",
+			pr: "none"
+		};
+	}
+	if (config.dryRun) {
+		p.log.info("[dry-run] Would push and create/update PR");
+		return {
+			mode: "version",
+			pr: "none"
+		};
+	}
+	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);
+	if (existingPr === null) {
+		await createPr(executor, conn, {
+			title,
+			head: BRANCH,
+			base: "main",
+			body
+		});
+		p.log.info("Created version PR");
+		return {
+			mode: "version",
+			pr: "created"
+		};
+	}
+	await updatePr(executor, conn, existingPr, {
+		title,
+		body
+	});
+	p.log.info(`Updated version PR #${String(existingPr)}`);
+	return {
+		mode: "version",
+		pr: "updated"
+	};
+}
+
+//#endregion
+//#region src/release/publish.ts
+const RETRY_ATTEMPTS = 3;
+const RETRY_BASE_DELAY_MS = 1e3;
+async function retryAsync(fn) {
+	let lastError;
+	for (let attempt = 0; attempt <= RETRY_ATTEMPTS; attempt++) try {
+		return await fn();
+	} catch (error) {
+		lastError = error;
+		if (attempt < RETRY_ATTEMPTS) {
+			const delay = RETRY_BASE_DELAY_MS * 2 ** attempt;
+			await new Promise((resolve) => setTimeout(resolve, delay));
+		}
+	}
+	throw lastError;
+}
+/** Mode 2: publish to npm, push tags, and create Forgejo releases. */
+async function runPublishMode(executor, config) {
+	p.log.info("No changesets — publishing packages");
+	const publishResult = executor.exec("pnpm changeset publish", { cwd: config.cwd });
+	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);
+	const expectedTags = computeExpectedTags(executor.listWorkspacePackages(config.cwd));
+	const remoteTags = parseRemoteTags(executor.exec("git ls-remote --tags origin", { cwd: config.cwd }).stdout);
+	const remoteSet = new Set(remoteTags);
+	const tagsToPush = reconcileTags(expectedTags, remoteTags, stdoutTags);
+	if (config.dryRun) {
+		if (tagsToPush.length === 0) {
+			p.log.info("No packages were published");
+			return { mode: "none" };
+		}
+		p.log.info(`Tags to process: ${tagsToPush.join(", ")}`);
+		p.log.info("[dry-run] Would push tags and create releases");
+		return {
+			mode: "publish",
+			tags: tagsToPush
+		};
+	}
+	const conn = {
+		serverUrl: config.serverUrl,
+		repository: config.repository,
+		token: config.token
+	};
+	const remoteExpectedTags = expectedTags.filter((t) => remoteSet.has(t) && !tagsToPush.includes(t));
+	const tagsWithMissingReleases = [];
+	for (const tag of remoteExpectedTags) if (!await findRelease(executor, conn, tag)) tagsWithMissingReleases.push(tag);
+	const allTags = [...tagsToPush, ...tagsWithMissingReleases];
+	if (allTags.length === 0) {
+		p.log.info("No packages were published");
+		return { mode: "none" };
+	}
+	p.log.info(`Tags to process: ${allTags.join(", ")}`);
+	const errors = [];
+	for (const tag of allTags) try {
+		if (!remoteSet.has(tag)) {
+			if (executor.exec(`git tag -l ${JSON.stringify(tag)}`, { cwd: config.cwd }).stdout.trim() === "") executor.exec(`git tag ${JSON.stringify(tag)}`, { cwd: config.cwd });
+			executor.exec(`git push origin refs/tags/${tag}`, { cwd: config.cwd });
+		}
+		if (await findRelease(executor, conn, tag)) p.log.warn(`Release for ${tag} already exists — skipping`);
+		else {
+			await retryAsync(async () => {
+				try {
+					await createRelease(executor, conn, tag);
+				} catch (error) {
+					if (await findRelease(executor, conn, tag)) return;
+					throw error;
+				}
+			});
+			p.log.info(`Created release for ${tag}`);
+		}
+	} catch (error) {
+		errors.push({
+			tag,
+			error
+		});
+		p.log.warn(`Failed to process ${tag}: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	if (errors.length > 0) throw new TransientError(`Failed to create releases for: ${errors.map((e) => e.tag).join(", ")}`);
+	return {
+		mode: "publish",
+		tags: allTags
+	};
+}
+
+//#endregion
+//#region src/commands/release-changesets.ts
+const releaseForgejoCommand = defineCommand({
+	meta: {
+		name: "release:changesets",
+		description: "Changesets version/publish for Forgejo CI"
+	},
+	args: { "dry-run": {
+		type: "boolean",
+		description: "Skip push, API calls, and publishing side effects"
+	} },
+	async run({ args }) {
+		if ((await runRelease(buildReleaseConfig({ dryRun: args["dry-run"] === true }), createRealExecutor())).mode === "none") process.exitCode = 0;
+	}
+});
+/** Build release config from environment variables 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");
+	return {
+		serverUrl,
+		repository,
+		token,
+		cwd: process.cwd(),
+		dryRun: flags.dryRun ?? false
+	};
+}
+/** Core release logic — testable with a mock executor. */
+async function runRelease(config, executor) {
+	if (hasChangesets(executor, config.cwd)) return runVersionMode(executor, config);
+	return runPublishMode(executor, config);
+}
+
+//#endregion
+//#region src/commands/release-trigger.ts
+const releaseTriggerCommand = defineCommand({
+	meta: {
+		name: "release:trigger",
+		description: "Trigger the release CI workflow"
+	},
+	args: { ref: {
+		type: "string",
+		description: "Git ref to trigger on (default: main)",
+		required: false
+	} },
+	async run({ args }) {
+		const ref = args.ref ?? "main";
+		const serverUrl = process.env["FORGEJO_SERVER_URL"];
+		if (serverUrl) await triggerForgejo(serverUrl, 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`;
+	const res = await fetch(url, {
+		method: "POST",
+		headers: {
+			Authorization: `token ${token}`,
+			"Content-Type": "application/json"
+		},
+		body: JSON.stringify({ ref })
+	});
+	if (!res.ok) throw new FatalError(`Failed to trigger Forgejo workflow: ${res.status} ${res.statusText}`);
+	p.log.info(`Triggered release workflow on Forgejo (ref: ${ref})`);
+}
+function triggerGitHub(ref) {
+	createRealExecutor().exec(`gh workflow run release.yml --ref ${ref}`, { cwd: process.cwd() });
+	p.log.info(`Triggered release workflow on GitHub (ref: ${ref})`);
+}
+
+//#endregion
+//#region src/commands/release-create-forgejo-release.ts
+const createForgejoReleaseCommand = defineCommand({
+	meta: {
+		name: "release:create-forgejo-release",
+		description: "Create a Forgejo release for a given tag"
+	},
+	args: { tag: {
+		type: "string",
+		description: "Git tag to create a release for",
+		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 executor = createRealExecutor();
+		const conn = {
+			serverUrl,
+			repository,
+			token
+		};
+		if (await findRelease(executor, conn, args.tag)) {
+			p.log.info(`Release for ${args.tag} already exists — skipping`);
+			return;
+		}
+		await createRelease(executor, conn, args.tag);
+		p.log.info(`Created Forgejo release for ${args.tag}`);
+	}
+});
+
+//#endregion
+//#region src/bin.ts
+runMain(defineCommand({
+	meta: {
+		name: "tooling",
+		version: "0.1.0",
+		description: "Bootstrap and maintain standardized TypeScript project tooling"
+	},
+	subCommands: {
+		"repo:init": initCommand,
+		"repo:update": updateCommand,
+		"release:changesets": releaseForgejoCommand,
+		"release:trigger": releaseTriggerCommand,
+		"release:create-forgejo-release": createForgejoReleaseCommand
+	}
+}));
+
+//#endregion
+export {  };