nucleus-core-ts 0.8.0

package/scripts/publish.ts

@@ -0,0 +1,210 @@
+#!/usr/bin/env bun
+
+/**
+ * Nucleus Core Publish Script
+ * Handles npm publishing with pre-checks
+ */
+
+import { access, readFile, stat } from "node:fs/promises";
+import { join } from "node:path";
+import { $ } from "bun";
+import config from "../nucleus.config";
+
+const GREEN = "\x1b[32m";
+const YELLOW = "\x1b[33m";
+const BLUE = "\x1b[34m";
+const RED = "\x1b[31m";
+const NC = "\x1b[0m";
+
+const log = {
+	info: (msg: string) => console.log(`${BLUE}ℹ️  ${msg}${NC}`),
+	success: (msg: string) => console.log(`${GREEN}✅ ${msg}${NC}`),
+	warn: (msg: string) => console.log(`${YELLOW}⚠️  ${msg}${NC}`),
+	error: (msg: string) => console.log(`${RED}❌ ${msg}${NC}`),
+};
+
+async function checkNpmAuth(): Promise<boolean> {
+	try {
+		const result = await $`npm whoami`.quiet();
+		const username = result.stdout.toString().trim();
+		log.success(`Logged in as: ${username}`);
+		return true;
+	} catch {
+		log.error("Not logged in to npm. Run: npm login");
+		return false;
+	}
+}
+
+async function checkDistExists(): Promise<boolean> {
+	try {
+		await access(config.build.outDir);
+		const stats = await stat(config.build.outDir);
+		if (stats.isDirectory()) {
+			log.success("Dist directory exists");
+			return true;
+		}
+	} catch {}
+	log.error("Dist directory not found. Run: bun run build");
+	return false;
+}
+
+async function checkVersion(): Promise<{
+	current: string;
+	published: string | null;
+}> {
+	const pkg = JSON.parse(await readFile("package.json", "utf-8"));
+	const current = pkg.version;
+	const name = pkg.name;
+
+	try {
+		const result = await $`npm view ${name} version`.quiet();
+		const published = result.stdout.toString().trim();
+		return { current, published };
+	} catch {
+		return { current, published: null };
+	}
+}
+
+async function checkEntryPoints(): Promise<boolean> {
+	let allExist = true;
+
+	for (const [exportPath, entryPoint] of Object.entries(config.entryPoints)) {
+		const outputFile = entryPoint.replace(/\.ts$/, ".js");
+		const fullPath = join(config.build.outDir, outputFile.replace("./", ""));
+
+		try {
+			await access(fullPath);
+			console.log(`  ${GREEN}✓${NC} ${exportPath}`);
+		} catch {
+			console.log(`  ${RED}✗${NC} ${exportPath} (missing: ${fullPath})`);
+			allExist = false;
+		}
+	}
+
+	return allExist;
+}
+
+async function checkTypeDefinitions(): Promise<boolean> {
+	let hasTypes = false;
+
+	for (const entryPoint of Object.values(config.entryPoints)) {
+		const dtsFile = entryPoint.replace(/\.ts$/, ".d.ts");
+		const fullPath = join(config.build.outDir, dtsFile.replace("./", ""));
+
+		try {
+			await access(fullPath);
+			hasTypes = true;
+		} catch {}
+	}
+
+	if (hasTypes) {
+		log.success("Type definitions found");
+	} else {
+		log.warn("No type definitions found");
+	}
+
+	return hasTypes;
+}
+
+async function checkSourceMaps(): Promise<boolean> {
+	const result =
+		await $`find ${config.build.outDir} -name "*.map" | head -1`.quiet();
+	const output = result.stdout.toString().trim();
+
+	if (output) {
+		log.error("Source maps found! Remove them before publishing");
+		return false;
+	}
+
+	log.success("No source maps (good)");
+	return true;
+}
+
+async function publishToNpm(dryRun: boolean, tag: string): Promise<void> {
+	const args = ["publish", "--access", config.npm.access, "--tag", tag];
+
+	if (dryRun) {
+		args.push("--dry-run");
+	}
+
+	log.info(`Running: npm ${args.join(" ")}`);
+
+	const result = await $`npm ${args}`;
+
+	if (result.exitCode === 0) {
+		log.success(dryRun ? "Dry run successful" : "Published to npm!");
+	} else {
+		throw new Error("Publish failed");
+	}
+}
+
+async function main() {
+	const args = process.argv.slice(2);
+	const dryRun = args.includes("--dry-run");
+	const skipChecks = args.includes("--skip-checks");
+	const tag =
+		args.find((a) => a.startsWith("--tag="))?.split("=")[1] || config.npm.tag;
+
+	console.log(`\n${GREEN}╔══════════════════════════════════════════╗${NC}`);
+	console.log(`${GREEN}║       📦 NUCLEUS CORE PUBLISH            ║${NC}`);
+	console.log(`${GREEN}╚══════════════════════════════════════════╝${NC}\n`);
+
+	if (dryRun) {
+		log.warn("DRY RUN MODE - No actual publish will happen\n");
+	}
+
+	// Pre-flight checks
+	if (!skipChecks) {
+		console.log(`${BLUE}Pre-flight Checks:${NC}\n`);
+
+		const npmAuth = await checkNpmAuth();
+		if (!npmAuth && !dryRun) process.exit(1);
+
+		const distExists = await checkDistExists();
+		if (!distExists) process.exit(1);
+
+		console.log(`\n${BLUE}Entry Points:${NC}`);
+		const entryPointsOk = await checkEntryPoints();
+		if (!entryPointsOk) {
+			log.error("Missing entry points. Run: bun run build");
+			process.exit(1);
+		}
+
+		console.log("");
+		await checkTypeDefinitions();
+
+		const noSourceMaps = await checkSourceMaps();
+		if (!noSourceMaps) process.exit(1);
+
+		const { current, published } = await checkVersion();
+		console.log(`\n${BLUE}Version:${NC}`);
+		console.log(`  Current:   ${GREEN}${current}${NC}`);
+		console.log(
+			`  Published: ${published ? YELLOW + published : GREEN + "(new package)"}${NC}`,
+		);
+		console.log(`  Tag:       ${tag}`);
+
+		if (published && current === published) {
+			log.error(`Version ${current} is already published. Bump version first.`);
+			console.log(`\n  Run: bun run version:patch (or minor/major)\n`);
+			process.exit(1);
+		}
+	}
+
+	// Publish
+	console.log(`\n${BLUE}Publishing...${NC}\n`);
+	await publishToNpm(dryRun, tag);
+
+	if (!dryRun) {
+		const { current } = await checkVersion();
+		console.log(
+			`\n${GREEN}🎉 nucleus-core@${current} published successfully!${NC}`,
+		);
+		console.log(`\n${BLUE}Install:${NC} npm install nucleus-core@${current}\n`);
+	}
+}
+
+main().catch((err) => {
+	log.error(err.message);
+	process.exit(1);
+});

package/scripts/version.ts

@@ -0,0 +1,125 @@
+#!/usr/bin/env bun
+/**
+ * Nucleus Core Version Management Script
+ * Handles version bumping with semantic versioning
+ */
+
+import { readFile, writeFile } from "node:fs/promises";
+import config from "../nucleus.config";
+
+const GREEN = "\x1b[32m";
+const YELLOW = "\x1b[33m";
+const BLUE = "\x1b[34m";
+const RED = "\x1b[31m";
+const NC = "\x1b[0m";
+
+type BumpType = "patch" | "minor" | "major" | "prerelease";
+
+interface PackageJson {
+	name: string;
+	version: string;
+	[key: string]: unknown;
+}
+
+async function readPackageJson(): Promise<PackageJson> {
+	const content = await readFile("package.json", "utf-8");
+	return JSON.parse(content);
+}
+
+async function writePackageJson(pkg: PackageJson): Promise<void> {
+	await writeFile("package.json", JSON.stringify(pkg, null, "\t") + "\n");
+}
+
+function parseVersion(version: string): {
+	major: number;
+	minor: number;
+	patch: number;
+	prerelease?: string;
+} {
+	const match = version.match(/^(\d+)\.(\d+)\.(\d+)(?:-(.+))?$/);
+	if (!match) throw new Error(`Invalid version: ${version}`);
+
+	return {
+		major: parseInt(match[1] ?? "0"),
+		minor: parseInt(match[2] ?? "0"),
+		patch: parseInt(match[3] ?? "0"),
+		prerelease: match[4],
+	};
+}
+
+function bumpVersion(current: string, type: BumpType): string {
+	const { major, minor, patch } = parseVersion(current);
+
+	switch (type) {
+		case "major":
+			return `${major + 1}.0.0`;
+		case "minor":
+			return `${major}.${minor + 1}.0`;
+		case "patch":
+			return `${major}.${minor}.${patch + 1}`;
+		case "prerelease":
+			return `${major}.${minor}.${patch + 1}-beta.0`;
+		default:
+			throw new Error(`Invalid bump type: ${type}`);
+	}
+}
+
+async function main() {
+	const args = process.argv.slice(2);
+	const bumpType = (args[0] as BumpType) || "patch";
+	const dryRun = args.includes("--dry-run");
+
+	if (!["patch", "minor", "major", "prerelease"].includes(bumpType)) {
+		console.log(`${RED}❌ Invalid bump type: ${bumpType}${NC}`);
+		console.log(
+			`\nUsage: bun run scripts/version.ts <patch|minor|major|prerelease> [--dry-run]`,
+		);
+		process.exit(1);
+	}
+
+	console.log(`\n${BLUE}📦 Nucleus Version Bump${NC}\n`);
+
+	const pkg = await readPackageJson();
+	const currentVersion = pkg.version;
+	const newVersion = bumpVersion(currentVersion, bumpType);
+
+	console.log(`  Current: ${YELLOW}${currentVersion}${NC}`);
+	console.log(`  New:     ${GREEN}${newVersion}${NC}`);
+	console.log(`  Type:    ${bumpType}`);
+
+	if (dryRun) {
+		console.log(`\n${YELLOW}⚠️  Dry run - no changes made${NC}\n`);
+		return;
+	}
+
+	pkg.version = newVersion;
+	await writePackageJson(pkg);
+
+	console.log(`\n${GREEN}✅ Version bumped to ${newVersion}${NC}`);
+
+	if (config.versioning.gitCommit) {
+		const { $ } = await import("bun");
+		const commitMsg = config.versioning.commitMessage.replace(
+			"{version}",
+			newVersion,
+		);
+		await $`git add package.json`.quiet();
+		await $`git commit -m ${commitMsg}`.quiet();
+		console.log(`${GREEN}✅ Changes committed${NC}`);
+
+		if (config.versioning.gitTag) {
+			const tag = `${config.versioning.tagPrefix}${newVersion}`;
+			await $`git tag ${tag}`.quiet();
+			console.log(`${GREEN}✅ Tagged as ${tag}${NC}`);
+		}
+	}
+
+	console.log(`\n${BLUE}Next steps:${NC}`);
+	console.log(`  1. bun run build`);
+	console.log(`  2. bun run publish:npm\n`);
+}
+
+main().catch((err) => {
+	console.error(`${RED}❌ Error: ${err.message}${NC}`);
+	process.exit(1);
+});