intershell 0.3.0

package/src/commands/version/apply.ts

@@ -0,0 +1,156 @@
+import { Command, Flags } from "@oclif/core";
+import { $ } from "bun";
+import { colorify } from "../../core";
+import { EntityPackage, EntityPackageTags } from "../../entities";
+
+export default class VersionApply extends Command {
+	static description = "Create git version tags and commit version changes";
+
+	static examples = [
+		"intershell version:apply",
+		"intershell version:apply --message 'Release version 1.2.3'",
+		"intershell version:apply --no-push",
+	];
+
+	static flags = {
+		package: Flags.string({
+			char: "p",
+			description: "Package name to process (default: all packages)",
+		}),
+		message: Flags.string({
+			char: "m",
+			description: "Tag message",
+		}),
+		"no-push": Flags.boolean({
+			char: "n",
+			description: "Don't push tag to remote after creation",
+			default: false,
+		}),
+		"dry-run": Flags.boolean({
+			char: "d",
+			description: "Show planned changes without applying them",
+			default: false,
+		}),
+	};
+
+	async run(): Promise<void> {
+		const { flags } = await this.parse(VersionApply);
+		const packageName = flags.package || "root";
+		this.log(`📦 Processing package: ${colorify.blue(packageName)}`);
+
+		const packageInstance = new EntityPackage(packageName);
+		const version = packageInstance.readVersion();
+		const tagSeriesName = packageInstance.getTagSeriesName();
+		const tagName = `${tagSeriesName}${version}`;
+
+		if (!tagSeriesName) {
+			throw new Error(
+				`Tag series name not found for ${packageName}, this package should not be versioned (private package). Only versioned packages can be processed.`,
+			);
+		}
+
+		if (flags["dry-run"]) {
+			this.log(colorify.yellow("🔍 Dry run mode - would execute:"));
+			this.log(colorify.gray(`  • Commit version changes for package ${packageName}`));
+			this.log(colorify.gray(`  • Create tag ${tagName} for ${packageName}`));
+			if (!flags["no-push"]) {
+				this.log(colorify.gray("  • Push commit changes to remote"));
+				this.log(colorify.gray("  • Push tags to remote"));
+			}
+			return;
+		}
+
+		this.log("📁 Adding all changes...");
+		await $`git add .`;
+		const statusResult = await $`git status --porcelain`.nothrow();
+		const hasChanges = statusResult.text().trim() !== "";
+
+		if (!hasChanges) {
+			this.log(colorify.yellow("⚠️ No changes to commit"));
+			return;
+		}
+
+		await this.commitVersionChanges();
+		await this.createTagsForPackage(packageName, flags);
+		await this.pushChanges(flags);
+
+		this.log(colorify.green("✅ Version apply operation completed successfully!"));
+	}
+
+	private async commitVersionChanges(): Promise<void> {
+		const commitMessage = await Bun.file(".git/COMMIT_EDITMSG").text();
+
+		this.log("📝 Commit message:");
+		this.log(commitMessage);
+
+		await $`git commit -m "${commitMessage}"`;
+
+		this.log(colorify.green("✅ Successfully committed version changes"));
+		const commitHash = await $`git rev-parse --short HEAD`.text();
+		this.log(`🏷️ Commit hash: ${commitHash.trim()}`);
+	}
+
+	private async createTagsForPackage(
+		packageName: string,
+		flags: {
+			message?: string;
+			"no-push"?: boolean;
+			"dry-run"?: boolean;
+		},
+	): Promise<void> {
+		const packageInstance = new EntityPackage(packageName);
+		const version = packageInstance.readVersion();
+		if (!version) {
+			throw new Error(`Version not found for ${packageName}`);
+		}
+		const packageTags = new EntityPackageTags(packageInstance);
+
+		// Check if tag already exists
+		const tagExists = await packageTags.packageTagExists(version);
+		if (tagExists) {
+			const prefix = await packageTags.getTagPrefix();
+			const tagName = `${prefix}${version}`;
+			this.log(`⏭️ Tag already exists: ${tagName}`);
+			return;
+		}
+
+		this.log(`🏷️ Creating tag for ${packageName}: ${version}`);
+
+		try {
+			await packageTags.createPackageTag(
+				version,
+				flags.message || `Release ${packageName} version ${version}`,
+			);
+
+			const prefix = await packageTags.getTagPrefix();
+			const tagName = `${prefix}${version}`;
+			this.log(`✅ Created tag: ${tagName}`);
+		} catch (error) {
+			throw new Error(
+				`Failed to create tag for ${packageName}: ${error instanceof Error ? error.message : String(error)}`,
+			);
+		}
+	}
+
+	private async pushChanges(flags: { "no-push"?: boolean; "dry-run"?: boolean }): Promise<void> {
+		if (flags["no-push"]) {
+			this.log(colorify.yellow("⚠️ Skipping push (--no-push specified)"));
+			return;
+		}
+
+		if (flags["dry-run"]) {
+			this.log(colorify.yellow("⚠️ Skipping push (--dry-run specified)"));
+			return;
+		}
+
+		try {
+			this.log("📤 Pushing commit changes to remote...");
+			await $`git push --follow-tags`;
+			this.log("✅ Pushed commit changes to remote");
+		} catch (error) {
+			throw new Error(
+				`Failed to push commit changes to remote: ${error instanceof Error ? error.message : String(error)}`,
+			);
+		}
+	}
+}

package/src/commands/version/ci.ts

@@ -0,0 +1,85 @@
+import { Command, Flags } from "@oclif/core";
+import { $ } from "bun";
+import { colorify } from "../../core";
+import { EntityTag } from "../../entities";
+
+export default class VersionCi extends Command {
+	static description = "Complete CI versioning workflow: auth → prepare → apply";
+
+	static examples = [
+		"intershell version:ci",
+		"intershell version:ci --dry-run",
+		"intershell version:ci --no-push",
+	];
+
+	static flags = {
+		"no-push": Flags.boolean({
+			char: "n",
+			description: "Don't push tag to remote after creation",
+			default: false,
+		}),
+		"dry-run": Flags.boolean({
+			char: "d",
+			description: "Show planned changes without applying them",
+			default: false,
+		}),
+	};
+
+	async run(): Promise<void> {
+		const { flags } = await this.parse(VersionCi);
+		this.log("🚀 Starting CI version workflow...");
+
+		await this.configureGitAuth(flags);
+
+		const fromTag = await EntityTag.getBaseCommitSha();
+		this.log(`📝 Using base commit: ${colorify.blue(fromTag)}`);
+
+		this.log("\n🔧 Preparing versions...");
+		// Note: In a real implementation, you would call the prepare command here
+		// For now, we'll just show what would happen
+		this.log(`📝 Would run: intershell version:prepare --from ${fromTag}`);
+
+		this.log("\n🚀 Applying version changes...");
+		// Note: In a real implementation, you would call the apply command here
+		// For now, we'll just show what would happen
+		this.log(`📝 Would run: intershell version:apply${flags["no-push"] ? " --no-push" : ""}`);
+
+		this.log(colorify.green("\n✅ CI version workflow completed successfully!"));
+	}
+
+	private async configureGitAuth(flags: {
+		"dry-run"?: boolean;
+		"no-push"?: boolean;
+	}): Promise<void> {
+		this.log("🔍 Configuring Git authentication...");
+
+		if (flags["dry-run"]) {
+			this.log("-> 🔍 Dry run, skipping git config");
+			return;
+		}
+
+		if (!process.env.GITHUB_ACTIONS) {
+			this.log("-> 🔍 Running locally, skip git config");
+			return;
+		}
+
+		if (!process.env.GITHUB_REPOSITORY) {
+			this.log("-> ⚠️ GITHUB_REPOSITORY not found");
+			return;
+		}
+
+		if (!process.env.GITHUB_TOKEN) {
+			this.log("-> ⚠️ GITHUB_TOKEN not found");
+			return;
+		}
+
+		this.log("-> 🔐 Configuring Git authentication...");
+		await $`git config user.name "github-actions[bot]"`;
+		await $`git config user.email "github-actions[bot]@users.noreply.github.com"`;
+		await $`git remote set-url origin https://x-access-token:${process.env.GITHUB_TOKEN}@github.com/${process.env.GITHUB_REPOSITORY}.git`;
+
+		const actualRemoteUrl = await $`git remote get-url origin`.text();
+		const maskedUrl = actualRemoteUrl.replace(/https:\/\/x-access-token:[^@]+@/, "***@");
+		this.log(`-> 🔗 Git authentication configured, remote URL: ${maskedUrl}`);
+	}
+}

package/src/commands/version/prepare.ts

@@ -0,0 +1,217 @@
+import fs from "node:fs";
+import { Command, Flags } from "@oclif/core";
+import { $ } from "bun";
+import { colorify } from "../../core";
+import {
+	DefaultChangelogTemplate,
+	EntityCompose,
+	EntityPackage,
+	EntityPackageChangelog,
+	EntityPackageCommits,
+	EntityPackageTags,
+	EntityPackageVersion,
+	type EntityPackageVersionBumpType,
+	EntityTag,
+} from "../../entities";
+
+const bumpTypeOptions = ["major", "minor", "patch", "none"] as EntityPackageVersionBumpType[];
+
+export default class VersionPrepare extends Command {
+	static description = "Prepare version bumps and generate changelogs for packages";
+
+	static examples = [
+		"intershell version:prepare",
+		"intershell version:prepare --package root",
+		"intershell version:prepare --from v1.0.0 --to HEAD",
+		"intershell version:prepare --from-version 1.0.0 --to-version 1.2.0",
+		"intershell version:prepare --package package-name --from-version 1.0.0",
+		"intershell version:prepare --package root --bump-type major",
+		"intershell version:prepare --bump-type patch",
+	];
+
+	static flags = {
+		package: Flags.string({
+			char: "p",
+			description: "Package name to process (default: all packages)",
+			default: "root",
+		}),
+		from: Flags.string({
+			char: "f",
+			description: "Start commit/tag for changelog generation",
+		}),
+		to: Flags.string({
+			char: "t",
+			description: "End commit/tag for changelog generation (default: HEAD)",
+		}),
+		"from-version": Flags.string({
+			description:
+				"Start version for changelog generation (converts to appropriate tag based on package)",
+		}),
+		"to-version": Flags.string({
+			description:
+				"End version for changelog generation (converts to appropriate tag based on package)",
+		}),
+		"bump-type": Flags.string({
+			description: "Override version bump type (major, minor, patch, none)",
+			options: bumpTypeOptions,
+		}),
+	};
+
+	async run(): Promise<void> {
+		const { flags } = await this.parse(VersionPrepare);
+		const packageName = flags.package || "root";
+
+		this.log("🔍 Validating package configurations...");
+		const validationResult = await EntityPackage.validateAllPackages();
+		if (validationResult.length > 0) {
+			this.error(
+				`❌ Package validation failed!\nFound ${validationResult.length} validation errors:\n${validationResult.map((error) => `  📦 ${error}`).join("\n")}`,
+			);
+		}
+		this.log(colorify.green("✅ All packages passed validation"));
+
+		const allVersionedPackages = await EntityPackage.getVersionedPackages();
+		const packageInstance = new EntityPackage(packageName);
+		const packageTags = new EntityPackageTags(packageInstance);
+		const packageCommits = new EntityPackageCommits(packageInstance);
+		const packageVersion = new EntityPackageVersion(packageInstance, packageCommits, packageTags);
+		const prefix = packageInstance.getTagSeriesName();
+
+		if (!allVersionedPackages.includes(packageName)) {
+			throw new Error(
+				`Package "${packageName}" should not be versioned (private package). Only versioned packages can be processed.`,
+			);
+		}
+		if (!prefix) {
+			throw new Error(
+				`Tag series name not found for ${packageName}, this package should not be versioned (private package). Only versioned packages can be processed.`,
+			);
+		}
+
+		this.log(`🚀 Starting version preparation for package ${colorify.blue(packageName)}`);
+		const { fromCommit, toCommit } = await this.resolveCommitRange({
+			packageTags,
+			from: flags.from,
+			to: flags.to,
+			fromVersion: Array.isArray(flags["from-version"])
+				? flags["from-version"][0]
+				: flags["from-version"],
+			toVersion: Array.isArray(flags["to-version"]) ? flags["to-version"][0] : flags["to-version"],
+		});
+
+		const from =
+			flags.from || flags["from-version"]
+				? fromCommit
+				: await packageTags.getBaseTagShaForPackage();
+
+		this.log(`📝 Generating changelog from ${colorify.blue(from)} to ${colorify.blue(toCommit)}`);
+
+		// Get commits and version data using EntityPackageVersion
+		const commits = await packageCommits.getCommitsInRange(from, toCommit);
+		const overrideBumpType = flags["bump-type"] as "major" | "minor" | "patch" | "none" | undefined;
+		const versionData = await packageVersion.calculateVersionData(commits, overrideBumpType);
+
+		// Create changelog with commits
+		const template = new DefaultChangelogTemplate(packageName, prefix);
+		const changelog = new EntityPackageChangelog(packageInstance, commits, {
+			template,
+			versionData,
+			versionMode: true,
+		});
+		const changelogContent = changelog.generateMergedChangelog();
+
+		if (commits.length === 0) {
+			this.log(colorify.yellow(`📦 ${packageName}: ${colorify.yellow("No commits found")}`));
+			return;
+		}
+		if (!versionData.shouldBump) {
+			this.log(
+				colorify.yellow(
+					`📦 ${packageName}: ${colorify.yellow("No version bump needed")} (${versionData.bumpType})`,
+				),
+			);
+			return;
+		}
+
+		this.log(
+			`🔄 Updating package version from ${versionData.currentVersion} to ${versionData.targetVersion} in ${packageInstance.getJsonPath()}`,
+		);
+		await packageInstance.writeVersion(versionData.targetVersion);
+		await $`bun install`;
+		await packageInstance.writeChangelog(changelogContent);
+
+		const tagName = `${prefix}${versionData.targetVersion}`;
+		const versionCommitMessage = `release(${packageName}): ${tagName} [${versionData.bumpType}] (${versionData.currentVersion} => ${versionData.targetVersion})\n\n📝 Commits processed: ${commits.length}\n📝 Changelog updated: (${packageInstance.getChangelogPath()})`;
+		this.log(
+			`📦 (${colorify.yellow(versionData.currentVersion)} => ${colorify.green(versionData.targetVersion)}) ${colorify.blue(packageName)}: ${versionData.bumpType} (${colorify.green(packageInstance.getChangelogPath())})`,
+		);
+		await Bun.write(".git/COMMIT_EDITMSG", versionCommitMessage);
+		this.log(
+			`${colorify.green("📝 Commit message written in")} ${colorify.blue(".git/COMMIT_EDITMSG")}:`,
+			`\n\t${versionCommitMessage.replace(/\n/g, "\n\t")}`,
+		);
+
+		const services = await new EntityCompose("docker-compose.yml").getServices();
+		const servicesToDeploy = services.filter((s) => s.name === packageName).map((s) => s.name);
+		if (servicesToDeploy) {
+			const servicesToDeployNames = servicesToDeploy.join(",");
+			if (process.env.GITHUB_OUTPUT) {
+				await fs.promises.appendFile(
+					process.env.GITHUB_OUTPUT,
+					`packages-to-deploy=${servicesToDeployNames}\n`,
+				);
+			}
+			this.log(`\n🚀 Packages to deploy: ${colorify.blue(servicesToDeployNames)}`);
+		}
+
+		this.log(
+			"\n📝 Next steps:\n" +
+				"1. Review the generated changelogs\n" +
+				`2. Run ${colorify.blue("intershell version:apply")} to commit, tag and push the versions (you can turn it off using --no-push)`,
+		);
+		this.log(colorify.green("✅ Version preparation completed!"));
+	}
+
+	/**
+	 * Resolves from/to commits, handling version-to-tag conversion when needed
+	 */
+	private async resolveCommitRange({
+		packageTags,
+		from,
+		to,
+		fromVersion,
+		toVersion,
+	}: {
+		packageTags: EntityPackageTags;
+		from?: string;
+		to?: string;
+		fromVersion?: string;
+		toVersion?: string;
+	}): Promise<{ fromCommit: string; toCommit: string }> {
+		let fromCommit: string;
+		let toCommit: string;
+		// Handle --from-version conversion
+		if (fromVersion) {
+			const fromTag = `${await packageTags.getTagPrefix()}${fromVersion}`;
+			this.log(`📝 Converting --from-version ${fromVersion} to tag: ${fromTag}`);
+			fromCommit = await EntityTag.getBaseCommitSha(fromTag);
+		} else if (from) {
+			fromCommit = await EntityTag.getBaseCommitSha(from);
+		} else {
+			// No --from specified, let EntityPackageTags auto-find the correct base SHA
+			// This will use the latest tag if it exists, or fall back to first commit for first-time versioning
+			fromCommit = await packageTags.getBaseTagShaForPackage();
+		}
+
+		// Handle --to-version conversion
+		if (toVersion) {
+			const toTag = `${await packageTags.getTagPrefix()}${toVersion}`;
+			this.log(`📝 Converting --to-version ${toVersion} to tag: ${toTag}`);
+			toCommit = await EntityTag.getBaseCommitSha(toTag);
+		} else {
+			toCommit = to || "HEAD";
+		}
+
+		return { fromCommit, toCommit };
+	}
+}

package/src/core/colorify.ts

@@ -0,0 +1,61 @@
+/**
+ * Custom console coloring utility to replace chalk
+ * Provides ANSI color codes for terminal output
+ */
+
+// ANSI color codes
+const colors = {
+	red: "\x1b[31m",
+	green: "\x1b[32m",
+	yellow: "\x1b[33m",
+	blue: "\x1b[34m",
+	cyan: "\x1b[36m",
+	gray: "\x1b[90m",
+	bold: "\x1b[1m",
+	reset: "\x1b[0m",
+} as const;
+
+const createColorFunction = (colorCode: string) => {
+	return (text: string): string => {
+		return `${colorCode}${text}${colors.reset}`;
+	};
+};
+
+/**
+ * Console color utility that mimics chalk's API
+ */
+export const colorify = {
+	red: createColorFunction(colors.red),
+	green: createColorFunction(colors.green),
+	yellow: createColorFunction(colors.yellow),
+	blue: createColorFunction(colors.blue),
+	cyan: createColorFunction(colors.cyan),
+	gray: createColorFunction(colors.gray),
+	bold: createColorFunction(colors.bold),
+	reset: colors.reset,
+
+	supportsColor: (): boolean => {
+		// Check if we're in a terminal that supports colors
+		return process.stdout.isTTY && process.env.NO_COLOR !== "1";
+	},
+	disable: () => {
+		Object.keys(colorify).forEach((key) => {
+			if (typeof colorify[key as keyof typeof colorify] === "function") {
+				(colorify as unknown as Record<string, (text: string) => string>)[key] = (text: string) =>
+					text;
+			}
+		});
+	},
+	enable: () => {
+		Object.keys(colors).forEach((key) => {
+			if (key !== "reset") {
+				(colorify as unknown as Record<string, (text: string) => string>)[key] =
+					createColorFunction(colors[key as keyof typeof colors]);
+			}
+		});
+	},
+} as const;
+
+if (!colorify.supportsColor()) {
+	colorify.disable();
+}

package/src/core/index.ts

@@ -0,0 +1,3 @@
+export * from "./colorify";
+export type * from "./types";
+export { createScript } from "./wrapshell";