intershell 0.3.7 → 0.4.0

package/src/commands/version/ci.ts

@@ -1,85 +0,0 @@
-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

@@ -1,223 +0,0 @@
-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")}`,
-		);
-
-		try {
-			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)}`);
-			}
-		} catch (error) {
-			this.log(
-				colorify.yellow(`📦 ${packageName}: ${colorify.yellow("No services found")}: ${error}`),
-			);
-		}
-
-		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

@@ -1,61 +0,0 @@
-/**
- * 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

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

package/src/core/types.ts

@@ -1,262 +0,0 @@
-/**
- * Core type definitions for the InterShell CLI framework
- */
-
-// Basic CLI types
-export interface KeyPress {
-	sequence: string;
-	name?: string;
-	ctrl: boolean;
-	meta: boolean;
-	shift: boolean;
-}
-
-export interface ValidationResult<T = unknown> {
-	isValid: boolean;
-	value?: T;
-	error?: string;
-	warnings?: string[];
-}
-
-export interface ValidationError {
-	message: string;
-	field?: string;
-	code?: string;
-}
-
-// Event system types
-export type EventHandler<T = unknown> = (data: T) => void | Promise<void>;
-
-export interface EventEmitter<TEvents extends Record<string, unknown> = Record<string, unknown>> {
-	on<K extends keyof TEvents>(event: K, handler: EventHandler<TEvents[K]>): void;
-	off<K extends keyof TEvents>(event: K, handler: EventHandler<TEvents[K]>): void;
-	emit<K extends keyof TEvents>(event: K, data: TEvents[K]): void;
-}
-
-// State management types
-export type StateListener<TState> = (state: TState, prevState: TState) => void;
-
-export interface StateManager<TState> {
-	getState(): TState;
-	setState(newState: TState): void;
-	subscribe(listener: StateListener<TState>): () => void;
-}
-
-// Script configuration types
-export type ArgOption = {
-	short?: string; // pay attention, this turned optional! in affects the logic
-	long: string;
-	description: string;
-	examples?: string[];
-} & (
-	| {
-			required: true;
-			type: "string" | "boolean" | "number";
-			validator: (value: string) => boolean | string | Promise<boolean | string>;
-	  }
-	| {
-			required: false;
-			type: "string" | "boolean" | "number";
-			defaultValue?: string | boolean | number;
-			validator: (value: string) => boolean | string | Promise<boolean | string>;
-	  }
-	| {
-			required: true;
-			type: "string[]" | "number[]"; // there is no multi boolean anymore, we must use type conditionals
-			validator: (value: string[]) => boolean | string | Promise<boolean | string>;
-	  }
-	| {
-			required: false;
-			type: "string[]" | "number[]";
-			defaultValue?: string[] | number[];
-			validator: (value: string[]) => boolean | string | Promise<boolean | string>;
-	  }
-);
-
-export interface ScriptConfig {
-	name: string;
-	description: string;
-	usage?: string;
-	examples?: string[];
-	options: ArgOption[];
-}
-
-export type ScriptHandler<TConfig extends ScriptConfig> = (
-	args: InferArgs<TConfig>,
-	console: Console,
-) => Promise<void> | void;
-
-export interface ScriptInstance<TConfig extends ScriptConfig> {
-	config: TConfig;
-	handler: ScriptHandler<TConfig>;
-	run(args?: Partial<InferArgs<TConfig>>): Promise<void>;
-}
-
-// Utility type to infer argument types from config
-export type InferArgs<TConfig extends ScriptConfig> = {
-	[K in TConfig["options"][number] as K["long"] extends `--${infer Name}`
-		? Name
-		: never]: K extends { required: true; type: infer T }
-		? T extends "string[]" | "number[]"
-			? string[] | number[]
-			: T extends "string"
-				? string
-				: T extends "boolean"
-					? boolean
-					: T extends "number"
-						? number
-						: never
-		: K extends { required: false; type: infer T; defaultValue: infer D }
-			? T extends "string[]" | "number[]"
-				? (string[] | number[]) | D
-				: T extends "string"
-					? string | D
-					: T extends "boolean"
-						? boolean | D
-						: T extends "number"
-							? number | D
-							: never
-			: K extends { required: false; type: infer T }
-				? T extends "string[]" | "number[]"
-					? (string[] | number[]) | undefined
-					: T extends "string"
-						? string | undefined
-						: T extends "boolean"
-							? boolean | undefined
-							: T extends "number"
-								? number | undefined
-								: never
-				: never;
-} & {
-	verbose?: boolean;
-	quiet?: boolean;
-	"dry-run"?: boolean;
-	help?: boolean;
-	debug?: boolean;
-};
-
-// Hook system types
-export interface HookContext<TConfig extends ScriptConfig> {
-	script: ScriptInstance<TConfig>;
-	args: InferArgs<TConfig>;
-	startTime: number;
-	error?: Error;
-}
-
-export type Hook<TConfig extends ScriptConfig, TReturn = void> = (
-	context: HookContext<TConfig>,
-) => Promise<TReturn> | TReturn;
-
-export interface HookSystem<TConfig extends ScriptConfig> {
-	beforeRun: Hook<TConfig>[];
-	afterRun: Hook<TConfig, unknown>[];
-	onError: Hook<TConfig>[];
-	onValidation: Hook<TConfig, ValidationResult>[];
-}
-
-// Color system types
-export type ColorFunction = (text: string) => string;
-
-export interface ColorSystem {
-	// Basic colors
-	red: ColorFunction;
-	green: ColorFunction;
-	blue: ColorFunction;
-	yellow: ColorFunction;
-	cyan: ColorFunction;
-	magenta: ColorFunction;
-	white: ColorFunction;
-	black: ColorFunction;
-	gray: ColorFunction;
-	grey: ColorFunction;
-
-	// Styles
-	bold: ColorFunction;
-	italic: ColorFunction;
-	underline: ColorFunction;
-	strikethrough: ColorFunction;
-
-	// Advanced colors
-	rgb(r: number, g: number, b: number): ColorFunction;
-	hsl(h: number, s: number, l: number): ColorFunction;
-	hex(color: string): ColorFunction;
-
-	// Effects
-	gradient(colors: string[]): ColorFunction;
-	rainbow: ColorFunction;
-
-	// Utilities
-	strip(text: string): string;
-	supportsColor(): boolean;
-	enable(): void;
-	disable(): void;
-}
-
-// CLI Tools types
-export interface QuickAction {
-	key: string;
-	label: string;
-	description: string;
-	shortcut?: string;
-	action: () => void | Promise<void>;
-}
-
-export interface SelectConfig {
-	multiple?: boolean;
-	clearScreen?: boolean;
-	showCursor?: boolean;
-	exitOnCtrlC?: boolean;
-	quickActions?: QuickAction[];
-}
-
-export interface PromptConfig {
-	clearScreen?: boolean;
-	allowEmpty?: boolean;
-	showCursor?: boolean;
-	exitOnCtrlC?: boolean;
-	quickActions?: QuickAction[];
-	onLeft?: () => void;
-}
-
-export interface ConfirmConfig {
-	clearScreen?: boolean;
-	defaultValue?: boolean;
-	exitOnCtrlC?: boolean;
-}
-
-// Interactive CLI types
-export interface InteractiveCLIOptions {
-	enableRawMode?: boolean;
-	exitOnCtrlC?: boolean;
-	clearOnExit?: boolean;
-}
-
-export interface InteractiveCLI {
-	// Core methods
-	select(question: string, options: string[], config?: SelectConfig): Promise<string[]>;
-	prompt(question: string, config?: PromptConfig): Promise<string>;
-	confirm(question: string, config?: ConfirmConfig): Promise<boolean>;
-
-	// Screen management
-	clearScreen(): void;
-	showCursor(): void;
-	hideCursor(): void;
-
-	// Event handling
-	onKeyPress(callback: (key: KeyPress) => void): void;
-	offKeyPress(callback: (key: KeyPress) => void): void;
-
-	// Lifecycle
-	cleanup(): void;
-}
-
-// Framework-specific types (will be extended by interactive package)
-export interface FrameworkOptions {
-	debug?: boolean;
-	logLevel?: "error" | "warn" | "info" | "debug";
-	enableHotkeys?: boolean;
-	enableHistory?: boolean;
-	maxHistorySize?: number;
-	renderMode?: "immediate" | "debounced" | "throttled";
-	renderDelay?: number;
-}