ts-builds 2.6.1 → 2.6.2

package/README.md

@@ -107,7 +107,7 @@ Create `ts-builds.config.json` to customize behavior:
 
 ### With Custom ESLint Plugins
 
-If your project uses ESLint plugins not bundled with ts-builds (e.g., `eslint-plugin-functional`, `eslint-plugin-react-hooks`):
+If your project uses ESLint plugins not bundled with ts-builds (e.g., `eslint-plugin-react-hooks`):
 
 ```json
 {

package/dist/cli.js

@@ -1,10 +1,13 @@
 #!/usr/bin/env node
-import { spawn } from "node:child_process";
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
+import { join, relative } from "node:path";
+import { spawn } from "node:child_process";
+import { $, Do, List, Option } from "functype";
+import { Fs, Process } from "functype-os";
 import { createInterface } from "node:readline";
+import { gzipSync } from "node:zlib";
 
-//#region src/cli.ts
+//#region src/cli/config.ts
 const targetDir = process.cwd();
 const defaultChains = { validate: [
 	"format",
@@ -31,10 +34,15 @@ function loadConfig() {
 		testDir: userConfig.testDir ?? "./test",
 		buildMode: userConfig.buildMode ?? "tsdown",
 		lint: { useProjectEslint: userConfig.lint?.useProjectEslint ?? false },
+		size: userConfig.size ?? {},
+		changelog: userConfig.changelog ?? {},
 		commands,
 		chains
 	};
 }
+
+//#endregion
+//#region src/cli/runner.ts
 function runCommand(command, args, options = {}) {
 	const cwd = options.cwd ? join(targetDir, options.cwd) : targetDir;
 	return new Promise((resolve) => {
@@ -69,6 +77,264 @@ function runShellCommand(shellCmd, options = {}) {
 		});
 	});
 }
+function getBuiltinCommands(config) {
+	const eslintCmd = config.lint.useProjectEslint ? "npx eslint" : "eslint";
+	const buildCmd = config.buildMode === "vite" ? { run: "rimraf dist && vite build" } : { run: "rimraf dist && cross-env NODE_ENV=production tsdown" };
+	const buildWatchCmd = config.buildMode === "vite" ? { run: "vite build --watch" } : { run: "tsdown --watch" };
+	const devCmd = config.buildMode === "vite" ? { run: "vite" } : { run: "tsdown --watch" };
+	return {
+		format: { run: "prettier --write ." },
+		"format:check": { run: "prettier --check ." },
+		lint: { run: `${eslintCmd} --fix ${config.srcDir}` },
+		"lint:check": { run: `${eslintCmd} ${config.srcDir}` },
+		typecheck: { run: "tsc --noEmit" },
+		"ts-types": { run: "tsc --noEmit" },
+		test: { run: "vitest run" },
+		"test:watch": { run: "vitest" },
+		"test:coverage": { run: "vitest run --coverage" },
+		"test:ui": { run: "vitest --ui" },
+		build: buildCmd,
+		"build:watch": buildWatchCmd,
+		dev: devCmd,
+		preview: { run: "vite preview" },
+		compile: { run: "tsc" }
+	};
+}
+async function runChain(chainName, config, visited = /* @__PURE__ */ new Set()) {
+	if (visited.has(chainName)) {
+		console.error(`Circular chain reference detected: ${chainName}`);
+		return 1;
+	}
+	visited.add(chainName);
+	const chain = config.chains[chainName];
+	if (!chain) {
+		console.error(`Unknown chain: ${chainName}`);
+		return 1;
+	}
+	const builtins = getBuiltinCommands(config);
+	console.log(`\n📋 Running chain: ${chainName} [${chain.join(" → ")}]`);
+	for (const step of chain) {
+		if (config.chains[step]) {
+			const code = await runChain(step, config, visited);
+			if (code !== 0) return code;
+			continue;
+		}
+		const cmdDef = config.commands[step] ?? builtins[step];
+		if (!cmdDef) {
+			console.error(`Unknown command or chain: ${step}`);
+			return 1;
+		}
+		const cwdLabel = cmdDef.cwd ? ` (in ${cmdDef.cwd})` : "";
+		console.log(`\n▶ Running ${step}...${cwdLabel}`);
+		const code = await runShellCommand(cmdDef.run, { cwd: cmdDef.cwd });
+		if (code !== 0) {
+			console.error(`\n✗ ${step} failed with exit code ${code}`);
+			return code;
+		}
+		console.log(`✓ ${step} complete`);
+	}
+	return 0;
+}
+
+//#endregion
+//#region src/cli/commands/build.ts
+async function runFormat(check = false) {
+	return runCommand("prettier", check ? ["--check", "."] : ["--write", "."]);
+}
+async function runLint(check = false) {
+	const config = loadConfig();
+	return runCommand(config.lint.useProjectEslint ? "npx eslint" : "eslint", check ? [config.srcDir] : ["--fix", config.srcDir]);
+}
+async function runTypecheck() {
+	return runCommand("tsc", ["--noEmit"]);
+}
+async function runTest(mode = "run") {
+	switch (mode) {
+		case "watch": return runCommand("vitest", []);
+		case "coverage": return runCommand("vitest", ["run", "--coverage"]);
+		case "ui": return runCommand("vitest", ["--ui"]);
+		default: return runCommand("vitest", ["run"]);
+	}
+}
+async function runBuild(watch = false) {
+	if (loadConfig().buildMode === "vite") {
+		if (watch) return runCommand("vite", ["build", "--watch"]);
+		const cleanCode = await runCommand("rimraf", ["dist"]);
+		if (cleanCode !== 0) return cleanCode;
+		return runCommand("vite", ["build"]);
+	}
+	if (watch) return runCommand("tsdown", ["--watch"]);
+	const cleanCode = await runCommand("rimraf", ["dist"]);
+	if (cleanCode !== 0) return cleanCode;
+	return runCommand("cross-env", ["NODE_ENV=production", "tsdown"]);
+}
+async function runDev() {
+	return loadConfig().buildMode === "vite" ? runCommand("vite", []) : runCommand("tsdown", ["--watch"]);
+}
+async function runValidate(chainName = "validate") {
+	return runChain(chainName, loadConfig());
+}
+
+//#endregion
+//#region src/cli/commands/changelog.ts
+const defaultTypeMap = {
+	feat: "Features",
+	fix: "Bug Fixes",
+	perf: "Performance",
+	refactor: "Refactoring",
+	docs: "Documentation",
+	test: "Tests",
+	ci: "CI/CD",
+	build: "Build",
+	style: "Style",
+	chore: "Chores"
+};
+const defaultExclude = List(["chore"]);
+function execGit(args) {
+	return Process.execSync(`git ${args}`, { cwd: targetDir }).fold(() => Option.none(), (result) => {
+		const trimmed = result.stdout.trim();
+		return trimmed ? Option(trimmed) : Option.none();
+	});
+}
+function getLastTag() {
+	return execGit("describe --tags --abbrev=0");
+}
+function getCommitsSince(since) {
+	const delimiter = "---COMMIT---";
+	const fieldSep = "|||";
+	const format = `${delimiter}%H${fieldSep}%s${fieldSep}%b${fieldSep}%an${fieldSep}%aI`;
+	return execGit(`log ${since.fold(() => "HEAD", (tag) => `${tag}..HEAD`)} --format="${format}"`).fold(() => List.empty(), (output) => List(output.split(delimiter)).filter((s) => s.trim().length > 0).map((entry) => {
+		const parts = entry.split(fieldSep);
+		return {
+			hash: (parts[0] ?? "").trim(),
+			subject: (parts[1] ?? "").trim(),
+			body: (parts[2] ?? "").trim(),
+			author: (parts[3] ?? "").trim(),
+			date: (parts[4] ?? "").trim()
+		};
+	}).filter((c) => c.hash.length > 0 && c.subject.length > 0));
+}
+function parseConventionalCommit(subject) {
+	const match = subject.match(/^(\w+)(?:\(([^)]+)\))?(!)?:\s+(.+)$/);
+	if (!match) return null;
+	return {
+		type: match[1],
+		scope: Option(match[2]),
+		breaking: match[3] === "!",
+		description: match[4]
+	};
+}
+function extractIssueRefs(text) {
+	const matches = text.match(/#(\d+)/g);
+	return matches ? List(matches.map((m) => m.slice(1))) : List.empty();
+}
+function getRepoUrl() {
+	const packageJsonPath = join(targetDir, "package.json");
+	return Fs.readFileSync(packageJsonPath).toOption().flatMap((content) => {
+		const pkg = JSON.parse(content);
+		return Option(typeof pkg.repository === "string" ? pkg.repository : pkg.repository?.url);
+	}).map((url) => url.replace(/^git\+/, "").replace(/\.git$/, "").replace(/^git:\/\//, "https://"));
+}
+function groupCommits(commits, typeMap, exclude) {
+	const filtered = commits.filter((c) => !exclude.contains(c.type));
+	const breaking = filtered.filter((c) => c.breaking);
+	const byType = filtered.filter((c) => typeMap[c.type] !== void 0).groupBy((c) => typeMap[c.type]);
+	return {
+		breaking,
+		sections: List([...new Set(Object.values(typeMap))]).filter((title) => byType.has(title)).map((title) => ({
+			title,
+			commits: byType.get(title) ?? List.empty()
+		}))
+	};
+}
+function formatCommitLine(commit, repoUrl) {
+	const shortHash = commit.hash.slice(0, 7);
+	const scope = commit.scope.fold(() => "", (s) => `**${s}**: `);
+	const hashLink = repoUrl.fold(() => `(${shortHash})`, (url) => `([${shortHash}](${url}/commit/${commit.hash}))`);
+	const issueLinks = commit.issues.map((num) => repoUrl.fold(() => `#${num}`, (url) => `[#${num}](${url}/issues/${num})`)).toArray().join(", ");
+	const issueRef = issueLinks ? ` ${issueLinks}` : "";
+	return `- ${scope}${commit.description} ${hashLink}${issueRef}`;
+}
+function formatMarkdown(grouped, repoUrl, version) {
+	const lines = [];
+	const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+	lines.push(version.fold(() => `## Unreleased (${date})`, (v) => `## ${v} (${date})`));
+	lines.push("");
+	if (grouped.breaking.nonEmpty) {
+		lines.push("### BREAKING CHANGES");
+		lines.push("");
+		for (const commit of grouped.breaking) lines.push(formatCommitLine(commit, repoUrl));
+		lines.push("");
+	}
+	for (const section of grouped.sections) {
+		lines.push(`### ${section.title}`);
+		lines.push("");
+		for (const commit of section.commits) lines.push(formatCommitLine(commit, repoUrl));
+		lines.push("");
+	}
+	return lines.join("\n");
+}
+async function runChangelog(args) {
+	const changelogConfig = loadConfig().changelog;
+	const typeMap = {
+		...defaultTypeMap,
+		...changelogConfig.types
+	};
+	const exclude = changelogConfig.exclude ? List(changelogConfig.exclude) : defaultExclude;
+	let since = Option.none();
+	let output = Option.none();
+	let version = Option.none();
+	let sinceExplicit = false;
+	for (let i = 0; i < args.length; i++) switch (args[i]) {
+		case "--since":
+			since = Option(args[++i]);
+			sinceExplicit = true;
+			break;
+		case "--output":
+			output = Option(args[++i]);
+			break;
+		case "--version":
+			version = Option(args[++i]);
+			break;
+	}
+	if (!sinceExplicit) since = getLastTag();
+	const rawCommits = getCommitsSince(since);
+	if (rawCommits.isEmpty) {
+		console.log(since.fold(() => "No commits found", (tag) => `No commits found since ${tag}`));
+		return 0;
+	}
+	const repoUrl = getRepoUrl();
+	const parsed = rawCommits.map((raw) => {
+		const conv = parseConventionalCommit(raw.subject);
+		if (!conv) return null;
+		const bodyBreaking = raw.body.includes("BREAKING CHANGE");
+		const issues = extractIssueRefs(raw.subject).concat(extractIssueRefs(raw.body)).distinct();
+		return {
+			hash: raw.hash,
+			type: conv.type,
+			scope: conv.scope,
+			breaking: conv.breaking || bodyBreaking,
+			description: conv.description,
+			author: raw.author,
+			date: raw.date,
+			issues
+		};
+	}).filter((c) => c !== null);
+	if (parsed.isEmpty) {
+		console.log("No conventional commits found");
+		return 0;
+	}
+	const markdown = formatMarkdown(groupCommits(parsed, typeMap, exclude), repoUrl, version);
+	output.fold(() => console.log(markdown), (file) => {
+		const outputPath = join(targetDir, file);
+		Fs.writeFileSync(outputPath, markdown);
+		console.log(`Changelog written to ${file}`);
+	});
+	return 0;
+}
+
+//#endregion
+//#region src/cli/commands/info.ts
 const bundledPackages = [
 	"@eslint/js",
 	"@vitest/coverage-v8",
@@ -85,30 +351,6 @@ const bundledPackages = [
 	"typescript-eslint",
 	"vitest"
 ];
-const requiredHoistPatterns = [
-	"public-hoist-pattern[]=*eslint*",
-	"public-hoist-pattern[]=*prettier*",
-	"public-hoist-pattern[]=*vitest*",
-	"public-hoist-pattern[]=typescript",
-	"public-hoist-pattern[]=*rimraf*",
-	"public-hoist-pattern[]=*cross-env*"
-];
-function ensureNpmrcHoistPatterns() {
-	const npmrcPath = join(targetDir, ".npmrc");
-	const existingContent = existsSync(npmrcPath) ? readFileSync(npmrcPath, "utf-8") : "";
-	const missingPatterns = requiredHoistPatterns.filter((pattern) => !existingContent.includes(pattern));
-	if (missingPatterns.length === 0) return;
-	const header = "# Hoist CLI tool binaries from peer dependencies";
-	const hasHeader = existingContent.includes(header);
-	let newContent = existingContent;
-	if (!hasHeader && missingPatterns.length > 0) newContent = existingContent + (existingContent.length > 0 && !existingContent.endsWith("\n") ? "\n\n" : existingContent.length > 0 ? "\n" : "") + header + "\n";
-	for (const pattern of missingPatterns) {
-		if (!newContent.endsWith("\n") && newContent.length > 0) newContent += "\n";
-		newContent += pattern + "\n";
-	}
-	writeFileSync(npmrcPath, newContent);
-	console.log(`✓ Updated .npmrc with ${missingPatterns.length} missing hoist pattern(s)`);
-}
 function showHelp() {
 	console.log(`
 ts-builds - Shared TypeScript build tooling
@@ -139,6 +381,11 @@ SCRIPT COMMANDS:
   dev           Development mode (tsdown --watch or vite dev server)
   preview       Preview production build (vite preview)
 
+ANALYSIS COMMANDS:
+  size          Report bundle sizes (use --save to update baseline)
+  doctor        Check package health (exports, files, types)
+  changelog     Generate changelog from conventional commits
+
 CONFIGURATION:
   Create ts-builds.config.json in your project root:
 
@@ -154,7 +401,7 @@ CONFIGURATION:
     "buildMode": "vite"
   }
 
-  With custom ESLint plugins (e.g., eslint-plugin-functional):
+  With custom ESLint plugins (e.g., eslint-plugin-react-hooks):
   {
     "srcDir": "./src",
     "lint": {
@@ -223,6 +470,9 @@ Example minimal package.json for SPAs/React apps:
 }
 `);
 }
+
+//#endregion
+//#region src/cli/commands/cleanup.ts
 async function cleanup() {
 	const packageJsonPath = join(targetDir, "package.json");
 	if (!existsSync(packageJsonPath)) {
@@ -272,6 +522,247 @@ async function cleanup() {
 	console.log(`\n✓ Removed ${totalRemoved} redundant package(s) from package.json`);
 	console.log("\nRun 'pnpm install' to update your lockfile.");
 }
+
+//#endregion
+//#region src/cli/commands/doctor.ts
+function resolveExportValue(value) {
+	if (typeof value === "string") return List([value]);
+	if (typeof value === "object" && value !== null) return List(Object.values(value)).flatMap((v) => resolveExportValue(v));
+	return List.empty();
+}
+function checkExports(pkg) {
+	return Option(pkg.exports).fold(() => List([{
+		severity: "info",
+		message: "No exports field defined"
+	}]), (exports) => List(Object.entries(exports)).flatMap(([key, value]) => resolveExportValue(value).map((p) => {
+		const absPath = join(targetDir, p);
+		return Fs.existsSync(absPath) ? {
+			severity: "info",
+			message: `${key} -> ${p}`
+		} : {
+			severity: "error",
+			message: `${key} -> ${p} -- file not found`
+		};
+	})));
+}
+function checkFiles(pkg) {
+	return Option(pkg.files).fold(() => List([{
+		severity: "warning",
+		message: "No files field defined -- npm will publish everything"
+	}]), (files) => List(files).map((entry) => {
+		const absPath = join(targetDir, entry);
+		if (!Fs.existsSync(absPath)) return {
+			severity: "warning",
+			message: `${entry} -- not found`
+		};
+		return Fs.statSync(absPath).fold(() => ({
+			severity: "warning",
+			message: `${entry} -- cannot stat`
+		}), (info) => ({
+			severity: "info",
+			message: `${entry}${info.isDirectory ? "/" : ""}`
+		}));
+	}));
+}
+function checkEntryPoints(pkg) {
+	const fieldResults = List([
+		{
+			name: "main",
+			value: Option(pkg.main)
+		},
+		{
+			name: "module",
+			value: Option(pkg.module)
+		},
+		{
+			name: "types",
+			value: Option(pkg.types)
+		}
+	]).flatMap(({ name, value }) => value.fold(() => List.empty(), (v) => {
+		const absPath = join(targetDir, v);
+		return List([Fs.existsSync(absPath) ? {
+			severity: "info",
+			message: `${name} -> ${v}`
+		} : {
+			severity: "error",
+			message: `${name} -> ${v} -- file not found`
+		}]);
+	}));
+	const binResults = Option(pkg.bin).fold(() => List.empty(), (bin) => {
+		const bins = typeof bin === "string" ? { [pkg.name ?? "cli"]: bin } : bin;
+		return List(Object.entries(bins)).map(([name, path]) => {
+			const absPath = join(targetDir, path);
+			return Fs.existsSync(absPath) ? {
+				severity: "info",
+				message: `bin.${name} -> ${path}`
+			} : {
+				severity: "error",
+				message: `bin.${name} -> ${path} -- file not found`
+			};
+		});
+	});
+	return fieldResults.concat(binResults);
+}
+function checkDeclarations(distDir) {
+	const absDir = join(targetDir, distDir);
+	if (!Fs.existsSync(absDir)) return List([{
+		severity: "warning",
+		message: `${distDir}/ directory not found`
+	}]);
+	return Fs.readdirSync(absDir).fold(() => List([{
+		severity: "warning",
+		message: `Cannot read ${distDir}/`
+	}]), (entries) => {
+		const allFiles = entries.flatMap((entry) => {
+			const fullPath = join(absDir, entry);
+			return Fs.statSync(fullPath).fold(() => List.empty(), (info) => info.isFile ? List([{
+				name: entry,
+				relPath: `${distDir}/${entry}`
+			}]) : List.empty());
+		});
+		const dtsFiles = allFiles.filter((f) => f.name.endsWith(".d.ts") || f.name.endsWith(".d.mts") || f.name.endsWith(".d.cts")).map((f) => f.relPath.replace(/\.d\.(m?ts|cts)$/, ""));
+		const jsFiles = allFiles.filter((f) => f.name.endsWith(".js") || f.name.endsWith(".mjs") || f.name.endsWith(".cjs"));
+		const warnings = jsFiles.flatMap((jsFile) => {
+			const base = jsFile.relPath.replace(/\.(m?js|cjs)$/, "");
+			return dtsFiles.contains(base) ? List.empty() : List([{
+				severity: "warning",
+				message: `${jsFile.relPath} has no matching .d.ts`
+			}]);
+		});
+		return warnings.isEmpty ? List([{
+			severity: "info",
+			message: `All ${jsFiles.size} JS files have declarations`
+		}]) : warnings;
+	});
+}
+function checkRequiredFields(pkg) {
+	return List([
+		{
+			field: "name",
+			severity: "error"
+		},
+		{
+			field: "version",
+			severity: "error"
+		},
+		{
+			field: "license",
+			severity: "warning"
+		},
+		{
+			field: "description",
+			severity: "warning"
+		},
+		{
+			field: "repository",
+			severity: "warning"
+		}
+	]).map(({ field, severity }) => Option(pkg[field]).fold(() => ({
+		severity,
+		message: `${field} is missing`
+	}), (value) => ({
+		severity: "info",
+		message: `${field}: ${typeof value === "string" ? value : "defined"}`
+	})));
+}
+function checkPeerDeps(pkg) {
+	return Option(pkg.peerDependencies).fold(() => List.empty(), (deps) => List(Object.entries(deps)).map(([name, range]) => {
+		return range.startsWith("^") || range.startsWith(">=") || range.startsWith("~") || range.includes("||") ? {
+			severity: "info",
+			message: `${name}: "${range}"`
+		} : {
+			severity: "warning",
+			message: `${name}: "${range}" -- consider using a range (^, ~, >=)`
+		};
+	}));
+}
+async function runDoctor() {
+	const packageJsonPath = join(targetDir, "package.json");
+	return Fs.readFileSync(packageJsonPath).fold(() => {
+		console.error("No package.json found in current directory");
+		return 1;
+	}, (content) => {
+		const pkg = JSON.parse(content);
+		console.log("\nts-builds doctor\n");
+		const sections = List([
+			{
+				name: "Required fields",
+				results: checkRequiredFields(pkg)
+			},
+			{
+				name: "Entry points",
+				results: checkEntryPoints(pkg)
+			},
+			{
+				name: "Exports",
+				results: checkExports(pkg)
+			},
+			{
+				name: "Files",
+				results: checkFiles(pkg)
+			},
+			{
+				name: "Declarations",
+				results: checkDeclarations("dist")
+			},
+			{
+				name: "Peer dependencies",
+				results: checkPeerDeps(pkg)
+			}
+		]);
+		let errors = 0;
+		let warnings = 0;
+		let passed = 0;
+		for (const section of sections) {
+			if (section.results.isEmpty) continue;
+			console.log(`Checking ${section.name}...`);
+			for (const result of section.results) switch (result.severity) {
+				case "error":
+					console.log(`  x ${result.message}`);
+					errors++;
+					break;
+				case "warning":
+					console.log(`  ! ${result.message}`);
+					warnings++;
+					break;
+				case "info":
+					console.log(`  + ${result.message}`);
+					passed++;
+					break;
+			}
+			console.log();
+		}
+		console.log(`Summary: ${errors} error(s), ${warnings} warning(s), ${passed} passed`);
+		return errors > 0 ? 1 : 0;
+	});
+}
+
+//#endregion
+//#region src/cli/commands/init.ts
+const requiredHoistPatterns = [
+	"public-hoist-pattern[]=*eslint*",
+	"public-hoist-pattern[]=*prettier*",
+	"public-hoist-pattern[]=*vitest*",
+	"public-hoist-pattern[]=typescript",
+	"public-hoist-pattern[]=*rimraf*",
+	"public-hoist-pattern[]=*cross-env*"
+];
+function ensureNpmrcHoistPatterns() {
+	const npmrcPath = join(targetDir, ".npmrc");
+	const existingContent = existsSync(npmrcPath) ? readFileSync(npmrcPath, "utf-8") : "";
+	const missingPatterns = requiredHoistPatterns.filter((pattern) => !existingContent.includes(pattern));
+	if (missingPatterns.length === 0) return;
+	const header = "# Hoist CLI tool binaries from peer dependencies";
+	const hasHeader = existingContent.includes(header);
+	let newContent = existingContent;
+	if (!hasHeader && missingPatterns.length > 0) newContent = existingContent + (existingContent.length > 0 && !existingContent.endsWith("\n") ? "\n\n" : existingContent.length > 0 ? "\n" : "") + header + "\n";
+	for (const pattern of missingPatterns) {
+		if (!newContent.endsWith("\n") && newContent.length > 0) newContent += "\n";
+		newContent += pattern + "\n";
+	}
+	writeFileSync(npmrcPath, newContent);
+	console.log(`✓ Updated .npmrc with ${missingPatterns.length} missing hoist pattern(s)`);
+}
 function init() {
 	console.log("Initializing ts-builds...");
 	ensureNpmrcHoistPatterns();
@@ -331,100 +822,128 @@ Example with custom commands:
 }
 `);
 }
-async function runFormat(check = false) {
-	return runCommand("prettier", check ? ["--check", "."] : ["--write", "."]);
+
+//#endregion
+//#region src/cli/commands/size.ts
+function measureEntry(dir, entry, absDir) {
+	const fullPath = join(absDir, entry);
+	return Do(function* () {
+		const info = yield* $(Fs.statSync(fullPath));
+		if (info.isDirectory) return getFileSizes(join(dir, entry));
+		const content = yield* $(Fs.readFileSync(fullPath));
+		const buf = Buffer.from(content);
+		return List([{
+			path: relative(targetDir, fullPath),
+			raw: info.size,
+			gzip: gzipSync(buf).length
+		}]);
+	}).fold(() => List.empty(), (list) => list);
 }
-async function runLint(check = false) {
-	const config = loadConfig();
-	return runCommand(config.lint.useProjectEslint ? "npx eslint" : "eslint", check ? [config.srcDir] : ["--fix", config.srcDir]);
+function getFileSizes(dir) {
+	const absDir = join(targetDir, dir);
+	if (!Fs.existsSync(absDir)) return List.empty();
+	return Fs.readdirSync(absDir).fold(() => List.empty(), (entries) => entries.flatMap((entry) => measureEntry(dir, entry, absDir)));
 }
-async function runTypecheck() {
-	return runCommand("tsc", ["--noEmit"]);
+function loadBaseline(baselinePath) {
+	const absPath = join(targetDir, baselinePath);
+	return Fs.readFileSync(absPath).toOption().flatMap((content) => {
+		try {
+			return Option(JSON.parse(content));
+		} catch {
+			return Option.none();
+		}
+	});
 }
-async function runTest(mode = "run") {
-	switch (mode) {
-		case "watch": return runCommand("vitest", []);
-		case "coverage": return runCommand("vitest", ["run", "--coverage"]);
-		case "ui": return runCommand("vitest", ["--ui"]);
-		default: return runCommand("vitest", ["run"]);
-	}
+function saveBaseline(baselinePath, files) {
+	const absPath = join(targetDir, baselinePath);
+	const totalRaw = files.fold(0, (sum, f) => sum + f.raw);
+	const totalGzip = files.fold(0, (sum, f) => sum + f.gzip);
+	const baseline = {
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		total: {
+			raw: totalRaw,
+			gzip: totalGzip
+		},
+		files: Object.fromEntries(files.map((f) => [f.path, {
+			raw: f.raw,
+			gzip: f.gzip
+		}]).toArray())
+	};
+	Fs.writeFileSync(absPath, JSON.stringify(baseline, null, 2) + "\n");
 }
-async function runBuild(watch = false) {
-	if (loadConfig().buildMode === "vite") {
-		if (watch) return runCommand("vite", ["build", "--watch"]);
-		const cleanCode = await runCommand("rimraf", ["dist"]);
-		if (cleanCode !== 0) return cleanCode;
-		return runCommand("vite", ["build"]);
-	}
-	if (watch) return runCommand("tsdown", ["--watch"]);
-	const cleanCode = await runCommand("rimraf", ["dist"]);
-	if (cleanCode !== 0) return cleanCode;
-	return runCommand("cross-env", ["NODE_ENV=production", "tsdown"]);
+function formatBytes(bytes) {
+	if (bytes < 1024) return `${bytes} B`;
+	const kb = bytes / 1024;
+	return kb < 1024 ? `${kb.toFixed(2)} kB` : `${(kb / 1024).toFixed(2)} MB`;
 }
-async function runDev() {
-	return loadConfig().buildMode === "vite" ? runCommand("vite", []) : runCommand("tsdown", ["--watch"]);
+function formatDelta(current, previous) {
+	const diff = current - previous;
+	if (diff === 0) return "";
+	return ` (${diff > 0 ? "+" : ""}${formatBytes(diff)})`;
 }
-function getBuiltinCommands(config) {
-	const eslintCmd = config.lint.useProjectEslint ? "npx eslint" : "eslint";
-	const buildCmd = config.buildMode === "vite" ? { run: "rimraf dist && vite build" } : { run: "rimraf dist && cross-env NODE_ENV=production tsdown" };
-	const buildWatchCmd = config.buildMode === "vite" ? { run: "vite build --watch" } : { run: "tsdown --watch" };
-	const devCmd = config.buildMode === "vite" ? { run: "vite" } : { run: "tsdown --watch" };
-	return {
-		format: { run: "prettier --write ." },
-		"format:check": { run: "prettier --check ." },
-		lint: { run: `${eslintCmd} --fix ${config.srcDir}` },
-		"lint:check": { run: `${eslintCmd} ${config.srcDir}` },
-		typecheck: { run: "tsc --noEmit" },
-		"ts-types": { run: "tsc --noEmit" },
-		test: { run: "vitest run" },
-		"test:watch": { run: "vitest" },
-		"test:coverage": { run: "vitest run --coverage" },
-		"test:ui": { run: "vitest --ui" },
-		build: buildCmd,
-		"build:watch": buildWatchCmd,
-		dev: devCmd,
-		preview: { run: "vite preview" },
-		compile: { run: "tsc" }
-	};
+function formatSizeTable(files, baseline, showGzip) {
+	const lines = [];
+	const nameWidth = Math.max(4, ...files.map((f) => f.path.length).toArray());
+	const sizeWidth = 10;
+	const gzipWidth = 10;
+	const deltaWidth = 16;
+	const header = showGzip ? `${"File".padEnd(nameWidth)}  ${"Size".padStart(sizeWidth)}  ${"Gzip".padStart(gzipWidth)}  ${"Delta".padStart(deltaWidth)}` : `${"File".padEnd(nameWidth)}  ${"Size".padStart(sizeWidth)}  ${"Delta".padStart(deltaWidth)}`;
+	lines.push(header);
+	lines.push("-".repeat(header.length));
+	const baselineData = baseline.orUndefined();
+	for (const file of files) {
+		const prev = baselineData?.files[file.path];
+		const delta = prev ? formatDelta(file.raw, prev.raw) : "";
+		const row = showGzip ? `${file.path.padEnd(nameWidth)}  ${formatBytes(file.raw).padStart(sizeWidth)}  ${formatBytes(file.gzip).padStart(gzipWidth)}  ${delta.padStart(deltaWidth)}` : `${file.path.padEnd(nameWidth)}  ${formatBytes(file.raw).padStart(sizeWidth)}  ${delta.padStart(deltaWidth)}`;
+		lines.push(row);
+	}
+	const totalRaw = files.fold(0, (sum, f) => sum + f.raw);
+	const totalGzip = files.fold(0, (sum, f) => sum + f.gzip);
+	const totalDelta = baselineData ? formatDelta(totalRaw, baselineData.total.raw) : "";
+	lines.push("-".repeat(header.length));
+	const totalRow = showGzip ? `${"Total".padEnd(nameWidth)}  ${formatBytes(totalRaw).padStart(sizeWidth)}  ${formatBytes(totalGzip).padStart(gzipWidth)}  ${totalDelta.padStart(deltaWidth)}` : `${"Total".padEnd(nameWidth)}  ${formatBytes(totalRaw).padStart(sizeWidth)}  ${totalDelta.padStart(deltaWidth)}`;
+	lines.push(totalRow);
+	return lines.join("\n");
 }
-async function runChain(chainName, config, visited = /* @__PURE__ */ new Set()) {
-	if (visited.has(chainName)) {
-		console.error(`Circular chain reference detected: ${chainName}`);
+async function runSize(args) {
+	const sizeConfig = loadConfig().size;
+	const showGzip = sizeConfig.gzip !== false;
+	const baselineFile = sizeConfig.baselineFile ?? ".ts-builds-size.json";
+	const save = args.includes("--save");
+	const files = getFileSizes("dist").sorted((a, b) => b.raw - a.raw);
+	if (files.isEmpty) {
+		console.error("No files found in dist/. Run a build first.");
 		return 1;
 	}
-	visited.add(chainName);
-	const chain = config.chains[chainName];
-	if (!chain) {
-		console.error(`Unknown chain: ${chainName}`);
-		return 1;
+	const baseline = loadBaseline(baselineFile);
+	const table = formatSizeTable(files, baseline, showGzip);
+	console.log("\nBundle Size Report\n");
+	console.log(table);
+	baseline.map((b) => {
+		console.log(`\nBaseline: ${b.timestamp}`);
+		return b;
+	});
+	if (save) {
+		saveBaseline(baselineFile, files);
+		console.log(`\nBaseline saved to ${baselineFile}`);
 	}
-	const builtins = getBuiltinCommands(config);
-	console.log(`\n📋 Running chain: ${chainName} [${chain.join(" → ")}]`);
-	for (const step of chain) {
-		if (config.chains[step]) {
-			const code = await runChain(step, config, visited);
-			if (code !== 0) return code;
-			continue;
-		}
-		const cmdDef = config.commands[step] ?? builtins[step];
-		if (!cmdDef) {
-			console.error(`Unknown command or chain: ${step}`);
-			return 1;
-		}
-		const cwdLabel = cmdDef.cwd ? ` (in ${cmdDef.cwd})` : "";
-		console.log(`\n▶ Running ${step}...${cwdLabel}`);
-		const code = await runShellCommand(cmdDef.run, { cwd: cmdDef.cwd });
-		if (code !== 0) {
-			console.error(`\n✗ ${step} failed with exit code ${code}`);
-			return code;
+	const totalRaw = files.fold(0, (sum, f) => sum + f.raw);
+	let failed = false;
+	if (sizeConfig.maxTotal && totalRaw > sizeConfig.maxTotal) {
+		console.error(`\nTotal size ${formatBytes(totalRaw)} exceeds max ${formatBytes(sizeConfig.maxTotal)}`);
+		failed = true;
+	}
+	if (sizeConfig.maxFile) {
+		for (const file of files) if (file.raw > sizeConfig.maxFile) {
+			console.error(`\n${file.path} (${formatBytes(file.raw)}) exceeds max file size ${formatBytes(sizeConfig.maxFile)}`);
+			failed = true;
 		}
-		console.log(`✓ ${step} complete`);
 	}
-	return 0;
-}
-async function runValidate(chainName = "validate") {
-	return runChain(chainName, loadConfig());
+	return failed ? 1 : 0;
 }
+
+//#endregion
+//#region src/cli.ts
 const command = process.argv[2] || "init";
 const subCommand = process.argv[3];
 switch (command) {
@@ -484,6 +1003,15 @@ switch (command) {
 	case "validate":
 		process.exit(await runValidate());
 		break;
+	case "size":
+		process.exit(await runSize(process.argv.slice(3)));
+		break;
+	case "doctor":
+		process.exit(await runDoctor());
+		break;
+	case "changelog":
+		process.exit(await runChangelog(process.argv.slice(3)));
+		break;
 	case "init":
 		init();
 		break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-builds",
-  "version": "2.6.1",
+  "version": "2.6.2",
   "description": "Shared TypeScript configuration files for library templates. Provides standardized ESLint, Prettier, Vitest, TypeScript, and build configs.",
   "keywords": [
     "typescript",
@@ -55,24 +55,26 @@
   "dependencies": {
     "@eslint/js": "^10.0.1",
     "@types/node": "~24.10.15",
-    "@vitest/coverage-v8": "^4.1.0",
-    "@vitest/ui": "^4.1.0",
+    "@vitest/coverage-v8": "^4.1.1",
+    "@vitest/ui": "^4.1.1",
     "cross-env": "^10.1.0",
     "eslint": "^10.1.0",
-    "eslint-config-functype": "^2.1.0",
-    "eslint-plugin-functype": "^2.1.0",
+    "eslint-config-functype": "^2.1.1",
+    "eslint-plugin-functype": "^2.1.1",
     "eslint-plugin-prettier": "^5.5.5",
     "eslint-plugin-simple-import-sort": "^12.1.1",
+    "functype": "^0.51.0",
+    "functype-os": "^0.4.1",
     "globals": "^17.4.0",
     "prettier": "^3.8.1",
     "rimraf": "^6.1.3",
     "ts-node": "^10.9.2",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.57.1",
-    "vitest": "^4.1.0"
+    "typescript-eslint": "^8.57.2",
+    "vitest": "^4.1.1"
   },
   "devDependencies": {
-    "tsdown": "^0.21.4"
+    "tsdown": "^0.21.5"
   },
   "peerDependencies": {
     "tsdown": "^0.x",
@@ -108,5 +110,5 @@
       }
     }
   },
-  "packageManager": "pnpm@10.32.1+sha512.a706938f0e89ac1456b6563eab4edf1d1faf3368d1191fc5c59790e96dc918e4456ab2e67d613de1043d2e8c81f87303e6b40d4ffeca9df15ef1ad567348f2be"
+  "packageManager": "pnpm@10.33.0+sha512.10568bb4a6afb58c9eb3630da90cc9516417abebd3fabbe6739f0ae795728da1491e9db5a544c76ad8eb7570f5c4bb3d6c637b2cb41bfdcdb47fa823c8649319"
 }