ts-builds 1.1.0 → 1.2.1

package/dist/cli.js

@@ -1,10 +1,72 @@
 #!/usr/bin/env node
+import { spawn } from "node:child_process";
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { createInterface } from "node:readline";
 
 //#region src/cli.ts
 const targetDir = process.cwd();
+const defaultChains = { validate: [
+	"format",
+	"lint",
+	"typecheck",
+	"test",
+	"build"
+] };
+function loadConfig() {
+	const configPath = join(targetDir, "ts-builds.config.json");
+	let userConfig = {};
+	if (existsSync(configPath)) try {
+		userConfig = JSON.parse(readFileSync(configPath, "utf-8"));
+	} catch {
+		console.error("Warning: Failed to parse ts-builds.config.json, using defaults");
+	}
+	const commands = {};
+	if (userConfig.commands) for (const [name, cmd] of Object.entries(userConfig.commands)) commands[name] = typeof cmd === "string" ? { run: cmd } : cmd;
+	const chains = { ...defaultChains };
+	if (userConfig.validateChain) chains.validate = userConfig.validateChain;
+	if (userConfig.chains) Object.assign(chains, userConfig.chains);
+	return {
+		srcDir: userConfig.srcDir ?? "./src",
+		testDir: userConfig.testDir ?? "./test",
+		commands,
+		chains
+	};
+}
+function runCommand(command$1, args, options = {}) {
+	const cwd = options.cwd ? join(targetDir, options.cwd) : targetDir;
+	return new Promise((resolve) => {
+		const child = spawn(command$1, args, {
+			cwd,
+			stdio: "inherit",
+			shell: true
+		});
+		child.on("close", (code) => {
+			resolve(code ?? 1);
+		});
+		child.on("error", (err) => {
+			console.error(`Failed to run ${command$1}: ${err.message}`);
+			resolve(1);
+		});
+	});
+}
+function runShellCommand(shellCmd, options = {}) {
+	const cwd = options.cwd ? join(targetDir, options.cwd) : targetDir;
+	return new Promise((resolve) => {
+		const child = spawn(shellCmd, {
+			cwd,
+			stdio: "inherit",
+			shell: true
+		});
+		child.on("close", (code) => {
+			resolve(code ?? 1);
+		});
+		child.on("error", (err) => {
+			console.error(`Failed to run: ${err.message}`);
+			resolve(1);
+		});
+	});
+}
 const bundledPackages = [
 	"@eslint/eslintrc",
 	"@eslint/js",
@@ -50,31 +112,72 @@ function ensureNpmrcHoistPatterns() {
 }
 function showHelp() {
 	console.log(`
-ts-builds - Shared TypeScript configuration files
+ts-builds - Shared TypeScript build tooling
 
 USAGE:
   npx ts-builds [command]
 
-COMMANDS:
-  init      Initialize project with config files (default)
+SETUP COMMANDS:
+  init      Initialize project with .npmrc hoist patterns (default)
+  config    Create ts-builds.config.json (use --force to overwrite)
   info      Show bundled packages you don't need to install
   cleanup   Remove redundant dependencies from package.json
   help      Show this help message
 
-EXAMPLES:
-  npx ts-builds          # Initialize project
-  npx ts-builds info     # List bundled packages
-  npx ts-builds cleanup  # Remove redundant deps
+SCRIPT COMMANDS:
+  validate      Run full validation chain (configurable)
+  format        Format code with Prettier (--write)
+  format:check  Check formatting without writing
+  lint          Lint and fix with ESLint
+  lint:check    Check lint without fixing
+  typecheck     Run TypeScript type checking (tsc --noEmit)
+  test          Run tests once (vitest run)
+  test:watch    Run tests in watch mode
+  test:coverage Run tests with coverage
+  test:ui       Launch Vitest UI
+  build         Production build (rimraf dist && tsdown)
+  build:watch   Watch mode build
+  dev           Alias for build:watch
 
-DESCRIPTION:
-  This package bundles all ESLint, Prettier, Vitest, and TypeScript
-  tooling as dependencies. You only need to install:
+CONFIGURATION:
+  Create ts-builds.config.json in your project root:
 
-  - ts-builds (this package)
-  - tsdown (peer dependency for building)
+  Basic:
+  {
+    "srcDir": "./src",
+    "validateChain": ["format", "lint", "typecheck", "test", "build"]
+  }
+
+  Advanced (monorepo with custom commands):
+  {
+    "srcDir": "./src",
+    "commands": {
+      "docs:validate": "pnpm docs:build && pnpm docs:check",
+      "landing:validate": { "run": "pnpm validate", "cwd": "./landing" }
+    },
+    "chains": {
+      "validate": ["validate:core", "validate:landing"],
+      "validate:core": ["format", "lint", "compile", "test", "docs:validate", "build"],
+      "validate:landing": ["landing:validate"]
+    }
+  }
 
-  Run 'npx ts-builds info' to see the full list
-  of bundled packages.
+USAGE IN PACKAGE.JSON:
+  {
+    "scripts": {
+      "validate": "ts-builds validate",
+      "validate:core": "ts-builds validate:core",
+      "format": "ts-builds format",
+      "lint": "ts-builds lint",
+      "test": "ts-builds test",
+      "build": "ts-builds build"
+    }
+  }
+
+EXAMPLES:
+  npx ts-builds validate       # Run default validation chain
+  npx ts-builds validate:core  # Run named chain
+  npx ts-builds lint           # Run single command
 `);
 }
 function showInfo() {
@@ -151,10 +254,133 @@ function init() {
 	ensureNpmrcHoistPatterns();
 	console.log("\nDone! Your project is configured to hoist CLI binaries from peer dependencies.");
 	console.log("\nNext steps:");
+	console.log("  - Run 'npx ts-builds config' to create a config file");
 	console.log("  - Run 'npx ts-builds info' to see bundled packages");
 	console.log("  - Run 'npx ts-builds cleanup' to remove redundant deps");
 }
-switch (process.argv[2] || "init") {
+function createConfig(force = false) {
+	const configPath = join(targetDir, "ts-builds.config.json");
+	if (existsSync(configPath) && !force) {
+		console.log("ts-builds.config.json already exists.");
+		console.log("Use 'ts-builds config --force' to overwrite.");
+		return;
+	}
+	writeFileSync(configPath, JSON.stringify({
+		srcDir: "./src",
+		validateChain: [
+			"format",
+			"lint",
+			"typecheck",
+			"test",
+			"build"
+		]
+	}, null, 2) + "\n");
+	console.log("✓ Created ts-builds.config.json");
+	console.log(`
+Configuration options:
+  srcDir         Source directory for linting (default: "./src")
+  testDir        Test directory (default: "./test")
+  validateChain  Commands to run for validate (default shown above)
+  commands       Custom commands: { "name": "shell command" }
+  chains         Named chains: { "validate:fast": ["format", "lint"] }
+
+Example with custom commands:
+{
+  "srcDir": "./src",
+  "commands": {
+    "docs": "pnpm docs:build",
+    "subproject": { "run": "pnpm validate", "cwd": "./packages/sub" }
+  },
+  "chains": {
+    "validate": ["format", "lint", "test", "build"],
+    "validate:full": ["format", "lint", "typecheck", "test", "docs", "build"]
+  }
+}
+`);
+}
+async function runFormat(check = false) {
+	return runCommand("prettier", check ? ["--check", "."] : ["--write", "."]);
+}
+async function runLint(check = false) {
+	const config = loadConfig();
+	return runCommand("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 (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 getBuiltinCommands(config) {
+	return {
+		format: { run: "prettier --write ." },
+		"format:check": { run: "prettier --check ." },
+		lint: { run: `eslint --fix ${config.srcDir}` },
+		"lint:check": { run: `eslint ${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: { run: "rimraf dist && cross-env NODE_ENV=production tsdown" },
+		"build:watch": { run: "tsdown --watch" },
+		dev: { run: "tsdown --watch" },
+		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$1 = await runChain(step, config, visited);
+			if (code$1 !== 0) return code$1;
+			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;
+}
+async function runValidate(chainName = "validate") {
+	return runChain(chainName, loadConfig());
+}
+const command = process.argv[2] || "init";
+const subCommand = process.argv[3];
+switch (command) {
 	case "help":
 	case "--help":
 	case "-h":
@@ -168,10 +394,64 @@ switch (process.argv[2] || "init") {
 	case "--cleanup":
 		await cleanup();
 		break;
+	case "format":
+		process.exit(await runFormat(subCommand === "check"));
+		break;
+	case "format:check":
+		process.exit(await runFormat(true));
+		break;
+	case "lint":
+		process.exit(await runLint(subCommand === "check"));
+		break;
+	case "lint:check":
+		process.exit(await runLint(true));
+		break;
+	case "typecheck":
+	case "ts-types":
+		process.exit(await runTypecheck());
+		break;
+	case "test":
+		process.exit(await runTest(subCommand));
+		break;
+	case "test:watch":
+		process.exit(await runTest("watch"));
+		break;
+	case "test:coverage":
+		process.exit(await runTest("coverage"));
+		break;
+	case "test:ui":
+		process.exit(await runTest("ui"));
+		break;
+	case "build":
+		process.exit(await runBuild(subCommand === "watch"));
+		break;
+	case "build:watch":
+	case "dev":
+		process.exit(await runBuild(true));
+		break;
+	case "validate":
+		process.exit(await runValidate());
+		break;
 	case "init":
-	default:
 		init();
 		break;
+	case "config":
+		createConfig(process.argv.includes("--force") || process.argv.includes("-f"));
+		break;
+	default: {
+		const config = loadConfig();
+		if (config.chains[command]) process.exit(await runValidate(command));
+		else if (config.commands[command]) {
+			const cmdDef = config.commands[command];
+			const code = await runShellCommand(cmdDef.run, { cwd: cmdDef.cwd });
+			process.exit(code);
+		} else {
+			console.error(`Unknown command: ${command}`);
+			console.log("Run 'ts-builds help' for usage information.");
+			process.exit(1);
+		}
+		break;
+	}
 }
 
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-builds",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "description": "Shared TypeScript configuration files for library templates. Provides standardized ESLint, Prettier, Vitest, TypeScript, and build configs.",
   "keywords": [
     "typescript",
@@ -18,11 +18,11 @@
   "homepage": "https://github.com/jordanburke/ts-builds",
   "repository": {
     "type": "git",
-    "url": "https://github.com/jordanburke/ts-builds"
+    "url": "git+https://github.com/jordanburke/ts-builds.git"
   },
   "main": "./prettier-config.js",
   "bin": {
-    "ts-builds": "./dist/cli.js"
+    "ts-builds": "dist/cli.js"
   },
   "exports": {
     ".": "./prettier-config.js",
@@ -79,11 +79,19 @@
     }
   },
   "scripts": {
-    "format": "prettier --write .",
-    "format:check": "prettier --check .",
-    "build": "rimraf dist && tsdown",
-    "test": "vitest run",
+    "bootstrap": "rimraf dist && tsdown",
+    "validate": "node dist/cli.js validate",
+    "validate:bootstrap": "pnpm bootstrap && pnpm validate",
+    "format": "node dist/cli.js format",
+    "format:check": "node dist/cli.js format:check",
+    "lint": "node dist/cli.js lint",
+    "lint:check": "node dist/cli.js lint:check",
+    "typecheck": "node dist/cli.js typecheck",
+    "test": "node dist/cli.js test",
     "test:watch": "vitest",
-    "validate": "pnpm format && pnpm build && pnpm test"
-  }
-}
+    "build": "node dist/cli.js build",
+    "dev": "node dist/cli.js dev",
+    "prepublishOnly": "pnpm validate:bootstrap"
+  },
+  "packageManager": "pnpm@10.24.0+sha512.01ff8ae71b4419903b65c60fb2dc9d34cf8bb6e06d03bde112ef38f7a34d6904c424ba66bea5cdcf12890230bf39f9580473140ed9c946fef328b6e5238a345a"
+}