intershell 0.3.0

package/src/entities/intershell-config/intershell-config.test.ts

@@ -0,0 +1,117 @@
+import { describe, expect, mock, test } from "bun:test";
+
+describe("Config", () => {
+	// Common mock setup for dependencies
+	const setupMocks = async () => {
+		// Mock EntityPackage methods
+		const { EntityPackage } = await import("../package");
+		EntityPackage.prototype.readJson = mock(() => ({
+			name: "test-package",
+			version: "1.0.0",
+		}));
+
+		return { EntityPackage };
+	};
+
+	test.skip("should have default commit configuration", async () => {
+		await setupMocks();
+		const { entitiesConfig } = await import("./intershell-config");
+		const config = entitiesConfig.getConfig();
+
+		expect(config.commit.conventional.type?.list).toBeDefined();
+		expect(config.commit.conventional.type?.list?.length).toBeGreaterThan(0);
+		expect(config.commit.staged).toBeDefined();
+		expect(config.commit.staged?.length).toBeGreaterThan(0);
+	});
+
+	test.skip("should have default branch configuration", async () => {
+		await setupMocks();
+		const { entitiesConfig } = await import("./intershell-config");
+		const config = entitiesConfig.getConfig();
+
+		expect(config.branch.defaultBranch).toBe("main");
+		expect(config.branch.prefixes).toEqual([
+			"feature",
+			"fix",
+			"hotfix",
+			"release",
+			"docs",
+			"refactor",
+			"ci",
+			"chore",
+			"wip",
+			"renovate",
+		]);
+	});
+
+	test.skip("should have default tag configuration", async () => {
+		await setupMocks();
+		const { entitiesConfig } = await import("./intershell-config");
+		const config = entitiesConfig.getConfig();
+
+		expect(config.tag.name.enabled).toBe(true);
+		expect(config.tag.name.minLength).toBe(1);
+		expect(config.tag.name.maxLength).toBe(100);
+		expect(config.tag.name.noSpaces).toBe(true);
+		expect(config.tag.name.noSpecialChars).toBe(false);
+	});
+
+	test.skip("should merge custom commit configuration", async () => {
+		await setupMocks();
+		const { entitiesConfig } = await import("./intershell-config");
+
+		// Mock custom config as a JSON string (as expected by PackageJson interface)
+		const customConfig = {
+			commit: {
+				conventional: {
+					type: {
+						list: [
+							{
+								type: "feat",
+								label: "Features",
+								description: "A new feature",
+								category: "features" as const,
+								emoji: "🚀",
+								badgeColor: "00D4AA",
+								breakingAllowed: true,
+							},
+						],
+					},
+				},
+			},
+		};
+
+		// Mock EntityPackage to return custom config
+		const { EntityPackage } = await import("../package");
+		EntityPackage.prototype.readJson = mock(() => ({
+			name: "test-package",
+			version: "1.0.0",
+			intershell: {
+				config: JSON.stringify(customConfig),
+			},
+		}));
+
+		const config = entitiesConfig.getConfig();
+		expect(config.commit.conventional.type?.list?.[0]?.type).toBe("feat");
+		expect(config.commit.conventional.type?.list?.[0]?.emoji).toBe("🚀");
+	});
+
+	test("should validate branch name regex pattern", async () => {
+		await setupMocks();
+		const { entitiesConfig } = await import("./intershell-config");
+		const config = entitiesConfig.getConfig();
+		const allowedCharacters = config.branch.name.allowedCharacters;
+
+		expect(allowedCharacters).toBeInstanceOf(RegExp);
+
+		// Test valid characters
+		expect(allowedCharacters.test("feature-branch")).toBe(true);
+		expect(allowedCharacters.test("fix_bug_123")).toBe(true);
+		expect(allowedCharacters.test("docs/update-readme")).toBe(true);
+
+		// Test invalid characters
+		expect(allowedCharacters.test("feature branch")).toBe(false); // space
+		expect(allowedCharacters.test("fix@bug")).toBe(false); // @ symbol
+		expect(allowedCharacters.test("docs#update")).toBe(false); // # symbol
+	});
+});

package/src/entities/intershell-config/intershell-config.ts

@@ -0,0 +1,143 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { defaultConfig } from "./intershell-config.default";
+import type { CustomConfigJson, IConfig } from "./intershell-config.types";
+
+class Config {
+	private config: IConfig;
+
+	constructor(customConfig?: CustomConfigJson) {
+		if (customConfig) {
+			this.config = this.mergeConfig(customConfig);
+		} else {
+			this.config = this.mergeConfig({});
+		}
+	}
+
+	getConfig(): IConfig {
+		return this.config;
+	}
+
+	private mergeConfig(config: CustomConfigJson): IConfig {
+		// Load packages for commit scopes if not provided
+		let commitScopes: string[] = [];
+		if (!config.commit?.conventional?.scopes?.list) {
+			try {
+				// This is a synchronous operation that reads from the filesystem
+				// We'll populate it with available packages
+				commitScopes = this.getAvailablePackages();
+			} catch {
+				commitScopes = [];
+			}
+		}
+
+		return {
+			...defaultConfig,
+			commit: {
+				...defaultConfig.commit,
+				...config.commit,
+				conventional: {
+					...defaultConfig.commit.conventional,
+					...config.commit?.conventional,
+					type: {
+						...defaultConfig.commit.conventional.type,
+						...config.commit?.conventional?.type,
+					},
+					scopes: {
+						...defaultConfig.commit.conventional.scopes,
+						...config.commit?.conventional?.scopes,
+						list: config.commit?.conventional?.scopes?.list || commitScopes,
+					},
+					description: {
+						...defaultConfig.commit.conventional.description,
+						...config.commit?.conventional?.description,
+					},
+					bodyLines: {
+						...defaultConfig.commit.conventional.bodyLines,
+						...config.commit?.conventional?.bodyLines,
+					},
+				},
+				staged: config.commit?.staged || defaultConfig.commit.staged,
+			} as IConfig["commit"],
+			branch: {
+				...defaultConfig.branch,
+				...config.branch,
+			} as IConfig["branch"],
+			package: {
+				...defaultConfig.package,
+				...config.package,
+			} as IConfig["package"],
+			tag: {
+				...defaultConfig.tag,
+				...config.tag,
+				name: {
+					...defaultConfig.tag.name,
+					...config.tag?.name,
+				},
+			} as IConfig["tag"],
+		};
+	}
+
+	private getAvailablePackages(): string[] {
+		const packages: string[] = ["root"];
+
+		try {
+			// Get workspace root
+			const workspaceRoot = process.cwd();
+
+			// Check for apps directory
+			const appsPath = join(workspaceRoot, "apps");
+			if (existsSync(appsPath)) {
+				const apps = readdirSync(appsPath, { withFileTypes: true })
+					.filter((dirent) => dirent.isDirectory())
+					.map((dirent) => dirent.name);
+				packages.push(...apps);
+			}
+
+			// Check for packages directory
+			const packagesPath = join(workspaceRoot, "packages");
+			if (existsSync(packagesPath)) {
+				const pkgs = readdirSync(packagesPath, { withFileTypes: true })
+					.filter((dirent) => dirent.isDirectory())
+					.map((dirent) => `@repo/${dirent.name}`);
+				packages.push(...pkgs);
+			}
+		} catch {
+			// If we can't read directories, just return basic packages
+			packages.push("admin", "api", "storefront", "ui", "utils");
+		}
+
+		return packages;
+	}
+}
+
+function getCustomConfig(): CustomConfigJson | undefined {
+	let customConfig: CustomConfigJson | undefined;
+	try {
+		// Read root package.json directly
+		const rootPackageJsonPath = join(process.cwd(), "package.json");
+		const rootPackageJsonContent = readFileSync(rootPackageJsonPath, "utf-8");
+		const rootPackageJson = JSON.parse(rootPackageJsonContent);
+
+		const configFilePath = rootPackageJson.intershell?.config;
+		if (!configFilePath) throw new Error();
+
+		const config = readFileSync(configFilePath, "utf-8");
+		customConfig = JSON.parse(config) as CustomConfigJson;
+	} catch {
+		customConfig = undefined;
+	}
+	return customConfig;
+}
+
+// Lazy initialization to allow mocking in tests
+let _entitiesConfig: Config | undefined;
+
+function getEntitiesConfig(): Config {
+	if (!_entitiesConfig) {
+		_entitiesConfig = new Config(getCustomConfig());
+	}
+	return _entitiesConfig;
+}
+
+export const entitiesConfig = getEntitiesConfig();

package/src/entities/intershell-config/intershell-config.types.ts

@@ -0,0 +1,118 @@
+export type PRCategory =
+	| "features"
+	| "bugfixes"
+	| "dependencies"
+	| "infrastructure"
+	| "documentation"
+	| "refactoring"
+	| "other";
+
+type Validator = (commit: unknown) => true | string;
+
+export interface CommitConfig {
+	conventional: {
+		type?: {
+			list?: CommitTypeDefinition[];
+			validator?: Validator;
+		};
+		scopes?: {
+			list?: string[];
+			validator?: Validator;
+		};
+		description?: {
+			minLength?: number;
+			maxLength?: number;
+			shouldNotEndWithPeriod?: boolean;
+			shouldNotStartWithType?: boolean;
+			validator?: Validator;
+		};
+		bodyLines?: {
+			minLength?: number;
+			maxLength?: number;
+			validator?: Validator;
+		};
+		isBreaking?: {
+			validator?: Validator;
+		};
+		isMerge?: {
+			validator?: Validator;
+		};
+		isDependency?: {
+			validator?: Validator;
+		};
+	};
+	staged?: StagedConfig;
+}
+
+export interface CommitTypeDefinition {
+	readonly type: string;
+	readonly label: string;
+	readonly description: string;
+	readonly category: PRCategory;
+	readonly emoji: string;
+	readonly badgeColor: string;
+	readonly breakingAllowed: boolean;
+}
+
+export type StagedConfig = {
+	filePattern: RegExp[];
+	contentPattern?: RegExp[];
+	description: string;
+	disabled?: boolean;
+	ignore?: {
+		mode: "create" | "update";
+	};
+}[];
+
+interface BranchConfig {
+	readonly defaultBranch: string;
+	readonly prefixes: string[];
+	readonly name: {
+		readonly minLength: number;
+		readonly maxLength: number;
+		readonly allowedCharacters: RegExp;
+		readonly noConsecutiveSeparators: boolean;
+		readonly noLeadingTrailingSeparators: boolean;
+	};
+}
+
+interface PackageValidationConfig {
+	readonly selectiveVersioning: {
+		readonly enabled: boolean;
+		readonly description: string;
+	};
+	readonly semanticVersioning: {
+		readonly enabled: boolean;
+		readonly description: string;
+	};
+	readonly description: {
+		readonly enabled: boolean;
+		readonly description: string;
+	};
+}
+
+interface TagValidationConfig {
+	readonly name: {
+		readonly enabled: boolean;
+		readonly description: string;
+		readonly minLength: number;
+		readonly maxLength: number;
+		readonly allowedCharacters: RegExp;
+		readonly noSpaces: boolean;
+		readonly noSpecialChars: boolean;
+		readonly validator?: Validator;
+	};
+}
+
+export interface IConfig {
+	readonly commit: CommitConfig;
+	readonly branch: BranchConfig;
+	readonly package: PackageValidationConfig;
+	readonly tag: TagValidationConfig;
+}
+
+type DeepPartial<T> = {
+	[P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+
+export type CustomConfigJson = DeepPartial<IConfig>;

package/src/entities/package/index.ts

@@ -0,0 +1,3 @@
+export * from "./package";
+export * from "./package.shell";
+export * from "./package.types";

package/src/entities/package/package.shell.ts

@@ -0,0 +1,124 @@
+import { readFileSync } from "node:fs";
+import { file, write } from "bun";
+import { entitiesShell } from "../entities.shell";
+import type { PackageJson } from "./package.types";
+
+export const packagesShell = {
+	/**
+	 * Reads a JSON file synchronously
+	 */
+	readJsonFile: (filePath: string): PackageJson => {
+		try {
+			const json = readFileSync(filePath, "utf8");
+			return JSON.parse(json);
+		} catch (error) {
+			throw new Error(`Failed to read JSON file ${filePath}: ${error}`);
+		}
+	},
+
+	/**
+	 * Writes JSON data to a file
+	 */
+	writeJsonFile: async (filePath: string, data: PackageJson): Promise<void> => {
+		await write(filePath, JSON.stringify(data, null, 2));
+	},
+
+	/**
+	 * Reads a changelog file
+	 */
+	readChangelogFile: (filePath: string): string => {
+		try {
+			const changelog = readFileSync(filePath, "utf8");
+			return changelog || "";
+		} catch {
+			return "";
+		}
+	},
+
+	/**
+	 * Writes content to a changelog file
+	 */
+	writeChangelogFile: async (filePath: string, content: string): Promise<void> => {
+		try {
+			await file(filePath).exists();
+		} catch {
+			await entitiesShell.touch(filePath);
+		}
+		await write(filePath, content);
+	},
+
+	/**
+	 * Checks if a file exists
+	 */
+	fileExists: async (filePath: string): Promise<boolean> => {
+		try {
+			await file(filePath).exists();
+			return true;
+		} catch {
+			return false;
+		}
+	},
+
+	/**
+	 * Reads directory contents
+	 */
+	readDirectory: async (dirPath: string): Promise<string[]> => {
+		const fs = await import("node:fs/promises");
+		const entries = await fs.readdir(dirPath, { withFileTypes: true });
+		return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+	},
+
+	/**
+	 * Checks if a file can be accessed
+	 */
+	canAccessFile: async (filePath: string): Promise<boolean> => {
+		const fs = await import("node:fs/promises");
+		try {
+			await fs.access(filePath);
+			return true;
+		} catch {
+			return false;
+		}
+	},
+
+	/**
+	 * Reads a file as text
+	 */
+	readFileAsText: async (filePath: string): Promise<string> => {
+		const fs = await import("node:fs/promises");
+		return await fs.readFile(filePath, "utf-8");
+	},
+
+	/**
+	 * Reads a file as text synchronously
+	 */
+	readFileAsTextSync: (filePath: string): string => {
+		return readFileSync(filePath, "utf8");
+	},
+
+	/**
+	 * Writes content to a file as text
+	 */
+	writeFileAsText: async (filePath: string, content: string): Promise<void> => {
+		await write(filePath, content);
+	},
+
+	/**
+	 * Gets the workspace root directory
+	 */
+	getWorkspaceRoot: async (): Promise<string> => {
+		const fs = await import("node:fs/promises");
+		const path = await import("node:path");
+
+		let workspaceRoot = process.cwd();
+		while (workspaceRoot !== path.dirname(workspaceRoot)) {
+			try {
+				await fs.access(path.join(workspaceRoot, "package.json"));
+				break; // Found package.json, this is the workspace root
+			} catch {
+				workspaceRoot = path.dirname(workspaceRoot);
+			}
+		}
+		return workspaceRoot;
+	},
+};